@vibeorm/generator 1.0.0

package/src/generators/generate-schemas.ts

@@ -0,0 +1,474 @@
+import type {
+  Model,
+  Schema,
+  ScalarField,
+  EnumField,
+  RelationField,
+  PrismaScalarType,
+} from "@vibeorm/parser";
+import { fileHeader } from "../utils.ts";
+
+/**
+ * Generates Zod v4 schemas for model validation:
+ * - Model schemas (validating query results / output)
+ * - CreateInput schemas (validating mutation input)
+ * - UpdateInput schemas (with atomic number operations)
+ */
+export function generateSchemas(params: { schema: Schema }): string {
+  const { schema } = params;
+  const parts: string[] = [fileHeader()];
+
+  // Import zod
+  parts.push(`import { z } from "zod/v4";\n`);
+
+  // Generate shared atomic operation schemas first (referenced by update schemas)
+  parts.push(generateAtomicOperationSchemas());
+
+  // Generate shared where filter schemas (referenced by WhereInput schemas)
+  parts.push(generateWhereFilterSchemas());
+
+  // Generate enum schemas (they're referenced by model schemas)
+  for (const enumDef of schema.enums) {
+    const values = enumDef.values.map((v) => `"${v.name}"`).join(", ");
+    parts.push(`export const ${enumDef.name}Schema = z.enum([${values}]);\n`);
+  }
+
+  // Generate model schemas
+  for (const model of schema.models) {
+    parts.push(generateModelSchema({ model, schema }));
+    parts.push(generateCreateInputSchema({ model, schema }));
+    parts.push(generateUpdateInputSchema({ model, schema }));
+    parts.push(generateWhereInputSchema({ model, schema }));
+  }
+
+  return parts.join("\n");
+}
+
+// ─── Model Schema ────────────────────────────────────────────────
+
+function generateModelSchema(params: { model: Model; schema: Schema }): string {
+  const { model } = params;
+  const fields: string[] = [];
+
+  for (const field of model.fields) {
+    if (field.kind === "scalar") {
+      const zodType = scalarToZod({ field });
+      fields.push(`  ${field.name}: ${zodType},`);
+    } else if (field.kind === "enum") {
+      let zodType = `${field.enumName}Schema`;
+      if (field.isList) {
+        zodType = `z.array(${zodType})`;
+      } else if (!field.isRequired) {
+        zodType = `${zodType}.nullable()`;
+      }
+      fields.push(`  ${field.name}: ${zodType},`);
+    }
+    // Relations are excluded from model schemas (they're separate queries)
+  }
+
+  return `export const ${model.name}Schema = z.object({
+${fields.join("\n")}
+});
+
+export type ${model.name}Validated = z.infer<typeof ${model.name}Schema>;
+`;
+}
+
+// ─── CreateInput Schema ──────────────────────────────────────────
+
+function generateCreateInputSchema(params: {
+  model: Model;
+  schema: Schema;
+}): string {
+  const { model } = params;
+  const fields: string[] = [];
+
+  for (const field of model.fields) {
+    if (field.kind === "scalar") {
+      const isAutoGenerated =
+        field.default &&
+        (field.default.kind === "autoincrement" ||
+          field.default.kind === "now" ||
+          field.default.kind === "uuid" ||
+          field.default.kind === "cuid" ||
+          field.default.kind === "nanoid" ||
+          field.default.kind === "ulid");
+      const isOptional =
+        !field.isRequired ||
+        field.default !== undefined ||
+        isAutoGenerated ||
+        field.isUpdatedAt;
+
+      let zodType = scalarToZodBase({ prismaType: field.prismaType });
+      if (field.isList) {
+        zodType = `z.array(${zodType})`;
+      } else if (!field.isRequired) {
+        zodType = `${zodType}.nullable()`;
+      }
+      if (isOptional) {
+        zodType = `${zodType}.optional()`;
+      }
+      fields.push(`  ${field.name}: ${zodType},`);
+    } else if (field.kind === "enum") {
+      const isOptional = !field.isRequired || field.default !== undefined;
+      let zodType = `${field.enumName}Schema`;
+      if (field.isList) {
+        zodType = `z.array(${zodType})`;
+      } else if (!field.isRequired) {
+        zodType = `${zodType}.nullable()`;
+      }
+      if (isOptional) {
+        zodType = `${zodType}.optional()`;
+      }
+      fields.push(`  ${field.name}: ${zodType},`);
+    }
+    // Relations are excluded — nested creates are complex and handled separately
+  }
+
+  return `export const ${model.name}CreateInputSchema = z.object({
+${fields.join("\n")}
+});
+`;
+}
+
+// ─── UpdateInput Schema ──────────────────────────────────────────
+
+function generateUpdateInputSchema(params: {
+  model: Model;
+  schema: Schema;
+}): string {
+  const { model } = params;
+  const fields: string[] = [];
+
+  for (const field of model.fields) {
+    if (field.kind === "scalar") {
+      if (field.isList) {
+        // Array field — support set/push operations
+        const baseZod = scalarToZodBase({ prismaType: field.prismaType });
+        const listSchema = `z.union([z.array(${baseZod}), z.object({ set: z.array(${baseZod}).optional(), push: z.union([${baseZod}, z.array(${baseZod})]).optional() })])`;
+        fields.push(`  ${field.name}: ${listSchema}.optional(),`);
+      } else {
+        let zodType = scalarToZodBase({ prismaType: field.prismaType });
+        if (!field.isRequired) {
+          zodType = `${zodType}.nullable()`;
+        }
+        // For numeric fields, also accept atomic operations
+        const atomicSchema = numericAtomicSchema({ prismaType: field.prismaType });
+        if (atomicSchema) {
+          zodType = `z.union([${zodType}, ${atomicSchema}])`;
+        }
+        fields.push(`  ${field.name}: ${zodType}.optional(),`);
+      }
+    } else if (field.kind === "enum") {
+      let zodType = `${field.enumName}Schema`;
+      if (field.isList) {
+        zodType = `z.array(${zodType})`;
+      } else if (!field.isRequired) {
+        zodType = `${zodType}.nullable()`;
+      }
+      fields.push(`  ${field.name}: ${zodType}.optional(),`);
+    }
+  }
+
+  return `export const ${model.name}UpdateInputSchema = z.object({
+${fields.join("\n")}
+});
+`;
+}
+
+// ─── Atomic Operation Schemas ────────────────────────────────────
+
+function generateAtomicOperationSchemas(): string {
+  return `
+// ─── Atomic Operation Schemas ────────────────────────────────────
+
+export const IntFieldUpdateOperationsSchema = z.object({
+  set: z.number().int().optional(),
+  increment: z.number().int().optional(),
+  decrement: z.number().int().optional(),
+  multiply: z.number().int().optional(),
+  divide: z.number().int().optional(),
+});
+
+export const FloatFieldUpdateOperationsSchema = z.object({
+  set: z.number().optional(),
+  increment: z.number().optional(),
+  decrement: z.number().optional(),
+  multiply: z.number().optional(),
+  divide: z.number().optional(),
+});
+
+export const BigIntFieldUpdateOperationsSchema = z.object({
+  set: z.bigint().optional(),
+  increment: z.bigint().optional(),
+  decrement: z.bigint().optional(),
+  multiply: z.bigint().optional(),
+  divide: z.bigint().optional(),
+});
+`;
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────
+
+function scalarToZod(params: { field: ScalarField }): string {
+  let base = scalarToZodBase({ prismaType: params.field.prismaType });
+  if (params.field.isList) {
+    return `z.array(${base})`;
+  }
+  if (!params.field.isRequired) {
+    return `${base}.nullable()`;
+  }
+  return base;
+}
+
+function scalarToZodBase(params: { prismaType: PrismaScalarType }): string {
+  switch (params.prismaType) {
+    case "String":
+      return "z.string()";
+    case "Boolean":
+      return "z.boolean()";
+    case "Int":
+      return "z.number().int()";
+    case "Float":
+    case "Decimal":
+      return "z.number()";
+    case "BigInt":
+      return "z.bigint()";
+    case "DateTime":
+      return "z.union([z.date(), z.string()])";
+    case "Json":
+      return "z.unknown()";
+    case "Bytes":
+      return "z.instanceof(Buffer)";
+    default:
+      return "z.unknown()";
+  }
+}
+
+function numericAtomicSchema(params: { prismaType: PrismaScalarType }): string | null {
+  switch (params.prismaType) {
+    case "Int":
+      return "IntFieldUpdateOperationsSchema";
+    case "Float":
+    case "Decimal":
+      return "FloatFieldUpdateOperationsSchema";
+    case "BigInt":
+      return "BigIntFieldUpdateOperationsSchema";
+    default:
+      return null;
+  }
+}
+
+// ─── Where Filter Schemas ───────────────────────────────────────
+
+function generateWhereFilterSchemas(): string {
+  return `
+// ─── Where Filter Schemas ───────────────────────────────────────
+
+export const StringFilterSchema = z.object({
+  equals: z.string().optional(),
+  not: z.union([z.string(), z.lazy(() => StringFilterSchema)]).optional(),
+  in: z.array(z.string()).optional(),
+  notIn: z.array(z.string()).optional(),
+  lt: z.string().optional(),
+  lte: z.string().optional(),
+  gt: z.string().optional(),
+  gte: z.string().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  mode: z.enum(["default", "insensitive"]).optional(),
+});
+
+export const NullableStringFilterSchema = z.object({
+  equals: z.string().nullable().optional(),
+  not: z.union([z.string().nullable(), z.lazy(() => NullableStringFilterSchema)]).optional(),
+  in: z.array(z.string().nullable()).optional(),
+  notIn: z.array(z.string().nullable()).optional(),
+  lt: z.string().optional(),
+  lte: z.string().optional(),
+  gt: z.string().optional(),
+  gte: z.string().optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional(),
+  mode: z.enum(["default", "insensitive"]).optional(),
+});
+
+export const NumberFilterSchema = z.object({
+  equals: z.number().optional(),
+  not: z.union([z.number(), z.lazy(() => NumberFilterSchema)]).optional(),
+  in: z.array(z.number()).optional(),
+  notIn: z.array(z.number()).optional(),
+  lt: z.number().optional(),
+  lte: z.number().optional(),
+  gt: z.number().optional(),
+  gte: z.number().optional(),
+});
+
+export const NullableNumberFilterSchema = z.object({
+  equals: z.number().nullable().optional(),
+  not: z.union([z.number().nullable(), z.lazy(() => NullableNumberFilterSchema)]).optional(),
+  in: z.array(z.number().nullable()).optional(),
+  notIn: z.array(z.number().nullable()).optional(),
+  lt: z.number().optional(),
+  lte: z.number().optional(),
+  gt: z.number().optional(),
+  gte: z.number().optional(),
+});
+
+export const BigIntFilterSchema = z.object({
+  equals: z.bigint().optional(),
+  not: z.union([z.bigint(), z.lazy(() => BigIntFilterSchema)]).optional(),
+  in: z.array(z.bigint()).optional(),
+  notIn: z.array(z.bigint()).optional(),
+  lt: z.bigint().optional(),
+  lte: z.bigint().optional(),
+  gt: z.bigint().optional(),
+  gte: z.bigint().optional(),
+});
+
+export const NullableBigIntFilterSchema = z.object({
+  equals: z.bigint().nullable().optional(),
+  not: z.union([z.bigint().nullable(), z.lazy(() => NullableBigIntFilterSchema)]).optional(),
+  in: z.array(z.bigint().nullable()).optional(),
+  notIn: z.array(z.bigint().nullable()).optional(),
+  lt: z.bigint().optional(),
+  lte: z.bigint().optional(),
+  gt: z.bigint().optional(),
+  gte: z.bigint().optional(),
+});
+
+export const BooleanFilterSchema = z.object({
+  equals: z.boolean().optional(),
+  not: z.union([z.boolean(), z.lazy(() => BooleanFilterSchema)]).optional(),
+});
+
+export const NullableBooleanFilterSchema = z.object({
+  equals: z.boolean().nullable().optional(),
+  not: z.union([z.boolean().nullable(), z.lazy(() => NullableBooleanFilterSchema)]).optional(),
+});
+
+export const DateTimeFilterSchema = z.object({
+  equals: z.union([z.date(), z.string()]).optional(),
+  not: z.union([z.date(), z.string(), z.lazy(() => DateTimeFilterSchema)]).optional(),
+  in: z.array(z.union([z.date(), z.string()])).optional(),
+  notIn: z.array(z.union([z.date(), z.string()])).optional(),
+  lt: z.union([z.date(), z.string()]).optional(),
+  lte: z.union([z.date(), z.string()]).optional(),
+  gt: z.union([z.date(), z.string()]).optional(),
+  gte: z.union([z.date(), z.string()]).optional(),
+});
+
+export const NullableDateTimeFilterSchema = z.object({
+  equals: z.union([z.date(), z.string()]).nullable().optional(),
+  not: z.union([z.date(), z.string(), z.lazy(() => NullableDateTimeFilterSchema)]).nullable().optional(),
+  in: z.array(z.union([z.date(), z.string()]).nullable()).optional(),
+  notIn: z.array(z.union([z.date(), z.string()]).nullable()).optional(),
+  lt: z.union([z.date(), z.string()]).optional(),
+  lte: z.union([z.date(), z.string()]).optional(),
+  gt: z.union([z.date(), z.string()]).optional(),
+  gte: z.union([z.date(), z.string()]).optional(),
+});
+
+export const EnumFilterSchema = z.object({
+  equals: z.string().optional(),
+  not: z.union([z.string(), z.lazy(() => EnumFilterSchema)]).optional(),
+  in: z.array(z.string()).optional(),
+  notIn: z.array(z.string()).optional(),
+});
+
+export const NullableEnumFilterSchema = z.object({
+  equals: z.string().nullable().optional(),
+  not: z.union([z.string().nullable(), z.lazy(() => NullableEnumFilterSchema)]).optional(),
+  in: z.array(z.string().nullable()).optional(),
+  notIn: z.array(z.string().nullable()).optional(),
+});
+`;
+}
+
+// ─── WhereInput Schema ──────────────────────────────────────────
+
+function generateWhereInputSchema(params: {
+  model: Model;
+  schema: Schema;
+}): string {
+  const { model } = params;
+  const fields: string[] = [];
+
+  for (const field of model.fields) {
+    if (field.kind === "scalar") {
+      if (field.isList) {
+        // Skip list/array fields — array filtering is complex and not included
+        continue;
+      }
+      const baseZod = scalarToZodBase({ prismaType: field.prismaType });
+      const filterName = scalarFilterSchemaName({
+        prismaType: field.prismaType,
+        isRequired: field.isRequired,
+      });
+      if (!field.isRequired) {
+        fields.push(
+          `  ${field.name}: z.union([${baseZod}.nullable(), ${filterName}]).optional(),`
+        );
+      } else {
+        fields.push(
+          `  ${field.name}: z.union([${baseZod}, ${filterName}]).optional(),`
+        );
+      }
+    } else if (field.kind === "enum") {
+      if (field.isList) {
+        continue;
+      }
+      const enumSchemaRef = `${field.enumName}Schema`;
+      const filterName = field.isRequired
+        ? "EnumFilterSchema"
+        : "NullableEnumFilterSchema";
+      if (!field.isRequired) {
+        fields.push(
+          `  ${field.name}: z.union([${enumSchemaRef}.nullable(), ${filterName}]).optional(),`
+        );
+      } else {
+        fields.push(
+          `  ${field.name}: z.union([${enumSchemaRef}, ${filterName}]).optional(),`
+        );
+      }
+    }
+    // Relations are excluded from WhereInput schemas
+  }
+
+  const schemaName = `${model.name}WhereInputSchema`;
+
+  return `export const ${schemaName}: z.ZodType<any> = z.lazy(() => z.object({
+  AND: z.union([${schemaName}, z.array(${schemaName})]).optional(),
+  OR: z.array(${schemaName}).optional(),
+  NOT: z.union([${schemaName}, z.array(${schemaName})]).optional(),
+${fields.join("\n")}
+}).partial());
+`;
+}
+
+function scalarFilterSchemaName(params: {
+  prismaType: PrismaScalarType;
+  isRequired: boolean;
+}): string {
+  const nullable = !params.isRequired;
+  switch (params.prismaType) {
+    case "String":
+      return nullable ? "NullableStringFilterSchema" : "StringFilterSchema";
+    case "Int":
+    case "Float":
+    case "Decimal":
+      return nullable ? "NullableNumberFilterSchema" : "NumberFilterSchema";
+    case "BigInt":
+      return nullable ? "NullableBigIntFilterSchema" : "BigIntFilterSchema";
+    case "Boolean":
+      return nullable ? "NullableBooleanFilterSchema" : "BooleanFilterSchema";
+    case "DateTime":
+      return nullable
+        ? "NullableDateTimeFilterSchema"
+        : "DateTimeFilterSchema";
+    default:
+      return "z.unknown()";
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { generate } from "./generate.ts";
+export type { GeneratedFile } from "./generate.ts";

package/src/utils.ts

@@ -0,0 +1,51 @@
+/**
+ * Code generation utilities
+ */
+
+/** Convert PascalCase to camelCase */
+export function toCamelCase(params: { str: string }): string {
+  const { str } = params;
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+/** Convert to PascalCase (first letter uppercase) */
+export function toPascalCase(params: { str: string }): string {
+  const { str } = params;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/** Indent a block of text by n spaces */
+export function indent(params: { text: string; spaces?: number }): string {
+  const { text, spaces = 2 } = params;
+  const pad = " ".repeat(spaces);
+  return text
+    .split("\n")
+    .map((line) => (line.trim() ? pad + line : line))
+    .join("\n");
+}
+
+/** Join lines with newline, filtering out empty/undefined */
+export function lines(params: { items: (string | undefined | false)[] }): string {
+  return params.items.filter(Boolean).join("\n");
+}
+
+/** Create a TypeScript type alias */
+export function typeAlias(params: {
+  name: string;
+  value: string;
+  exported?: boolean;
+}): string {
+  const { name, value, exported = true } = params;
+  return `${exported ? "export " : ""}type ${name} = ${value};`;
+}
+
+/** Wrap code in a block for file generation */
+export function fileHeader(): string {
+  return [
+    "// ============================================",
+    "// THIS FILE IS AUTO-GENERATED BY VIBEORM",
+    "// DO NOT EDIT MANUALLY",
+    "// ============================================",
+    "",
+  ].join("\n");
+}