Add support for more extended validation instead of just looking at the data type

[Rednas83]

Something like

// source.ts
export interface HeroContact {
  email: string; // v-email
  name: string; // 2..50
  phoneNumber: string; // p-^([+]?d{1,2}[-s]?|)d{3}[-s]?d{3}[-s]?d{4}$
  hasSuperPower?: boolean; // v-true
  age: number; // 0..500
}

// output.ts
export const heroContactSchema = z.object({
  email: z.string().email(),
  name: z.string().min(2).max(50),
  phoneNumber: z.string().regex(/^([+]?d{1,2}[-s]?|)d{3}[-s]?d{3}[-s]?d{4}$/),
  hasSuperPower: z.boolean().default(true),
  age: z.number().min(0).max(500),
});

Whereby v- is a shorthand for validation and p- is a shorthand for pattern

[yuzheng14]

This could be an alternative. But I still consider implementing this by DSL because it could provide more information like Prisma.

[Rednas83]

Is it not the idea to parse typescript to zod in the simplest way possible without the need of writing the entire schema in the first place?

Just tried peggy for some quick prototyping of a zod parser.

It seems to work as expected but will need a lot more work to complete

Peggy Grammar

{
  function num(x) { return parseInt(x.join(""), 10); }
}

Rule
  = Email         { return { type: "email" }; }
  / TrueDefault   { return { type: "true" }; }
  / Range
  / Pattern

Email
  = "v-email"

TrueDefault
  = "v-true"

Range
  = min:[0-9]+ ".." max:[0-9]+ {
      return {
        type: "range",
        min: parseInt(min.join(""), 10),
        max: parseInt(max.join(""), 10)
      };
    }

Pattern
  = "p-" pattern:Regex {
      return { type: "pattern", pattern };
    }

Regex
  = chars:.* { return chars.join("").trim(); }

buildZod.js [NOT TESTED]

function buildZod(type: string, rule: any, optional: boolean): string {
  let base = ""

  switch (type) {
    case "string":
      base = "z.string()"
      break
    case "number":
      base = "z.number()"
      break
    case "boolean":
      base = "z.boolean()"
      break
    default:
      base = "z.any()"
  }

  switch (rule.type) {
    case "email":
      if (type === "string") base += ".email()"
      break
    case "true":
      if (type === "boolean") base += ".default(true)"
      break
    case "range":
      if (type === "string" || type === "number") {
        base += `.min(${rule.min}).max(${rule.max})`
      }
      break
    case "pattern":
      if (type === "string") {
        base += `.regex(/${rule.pattern}/)`
      }
      break
  }

  return optional ? base + ".optional()" : base
}

[yuzheng14]

Hummmmmm, it seems like a DSL too. Standardized functions like email would be handled easily, however, some custom logic like refine maybe not processed easily. So that I'm thinking a DSL mixing type declaration and runtime code like vue mixing html and javascript.