kysely-gen 0.9.1 → 0.10.0

package/README.md

@@ -51,6 +51,54 @@ npx kysely-gen --dialect mysql --url mysql://user:pass@localhost:3306/db
 | `--camel-case` | Convert names to camelCase |
 | `--include-pattern <glob>` | Only include matching tables |
 | `--exclude-pattern <glob>` | Exclude matching tables |
+| `--zod` | Generate Zod schemas instead of TypeScript interfaces |
+
+## Zod Schema Generation
+
+Generate Zod validation schemas with inferred types instead of TypeScript interfaces. Requires Zod v4+:
+
+```sh
+npm install zod@4
+npx kysely-gen --zod
+```
+
+This generates `db-schemas.ts` with Zod schemas and inferred types:
+
+```typescript
+import { z } from 'zod';
+
+export const userSchema = z.object({
+  id: z.number(),
+  email: z.string(),
+  name: z.string().nullable(),
+  createdAt: z.date(),
+});
+
+export const newUserSchema = z.object({
+  id: z.number().optional(),
+  email: z.string(),
+  name: z.string().nullable().optional(),
+  createdAt: z.union([z.date(), z.string()]).optional(),
+});
+
+export const userUpdateSchema = z.object({
+  id: z.number().optional(),
+  email: z.string().optional(),
+  name: z.string().nullable().optional(),
+  createdAt: z.union([z.date(), z.string()]).optional(),
+});
+
+export type User = z.infer<typeof userSchema>;
+export type NewUser = z.infer<typeof newUserSchema>;
+export type UserUpdate = z.infer<typeof userUpdateSchema>;
+```
+
+Three schemas are generated per table:
+- **Select schema** (`userSchema`): What you get from queries
+- **Insert schema** (`newUserSchema`): For inserts - auto-increment/default columns are optional
+- **Update schema** (`userUpdateSchema`): For updates - all columns are optional
+
+The `--zod` flag replaces TypeScript interface generation. Types are inferred from schemas via `z.infer<>`, ensuring they never drift.
 
 ## Example
 

package/dist/cli.js

@@ -111124,9 +111124,404 @@ function detectDialect(connectionString) {
   }
 }
 
+// src/zod/type-mapper.ts
+function mapPostgresTypeToZod(dataType, options) {
+  const { isNullable, isArray, isOptional, mode } = options;
+  if (isArray || dataType.endsWith("[]")) {
+    const baseTypeName = dataType.endsWith("[]") ? dataType.slice(0, -2) : dataType;
+    const elementSchema = mapPostgresTypeToZod(baseTypeName, {
+      isNullable: false,
+      isArray: false,
+      isOptional: false,
+      mode
+    });
+    return applyModifiers({ kind: "zod-array", element: elementSchema }, isNullable, isOptional);
+  }
+  const baseSchema = mapScalarType(dataType, mode);
+  return applyModifiers(baseSchema, isNullable, isOptional);
+}
+function applyModifiers(schema, isNullable, isOptional) {
+  const modifiers = [];
+  if (isNullable)
+    modifiers.push("nullable");
+  if (isOptional)
+    modifiers.push("optional");
+  if (modifiers.length > 0) {
+    return { kind: "zod-modified", schema, modifiers };
+  }
+  return schema;
+}
+function mapScalarType(dataType, mode) {
+  switch (dataType) {
+    case "int2":
+    case "int4":
+    case "smallint":
+    case "integer":
+    case "float4":
+    case "float8":
+    case "real":
+    case "double precision":
+      return { kind: "zod-primitive", method: "number" };
+    case "int8":
+    case "bigint":
+      if (mode === "select") {
+        return { kind: "zod-primitive", method: "string" };
+      }
+      return {
+        kind: "zod-union",
+        schemas: [
+          { kind: "zod-primitive", method: "string" },
+          { kind: "zod-primitive", method: "number" },
+          { kind: "zod-primitive", method: "bigint" }
+        ]
+      };
+    case "numeric":
+    case "decimal":
+      if (mode === "select") {
+        return { kind: "zod-primitive", method: "string" };
+      }
+      return {
+        kind: "zod-union",
+        schemas: [
+          { kind: "zod-primitive", method: "string" },
+          { kind: "zod-primitive", method: "number" }
+        ]
+      };
+    case "varchar":
+    case "char":
+    case "text":
+    case "citext":
+    case "uuid":
+    case "money":
+    case "time":
+    case "timetz":
+      return { kind: "zod-primitive", method: "string" };
+    case "bool":
+    case "boolean":
+      return { kind: "zod-primitive", method: "boolean" };
+    case "timestamp":
+    case "timestamptz":
+    case "date":
+      if (mode === "select") {
+        return { kind: "zod-primitive", method: "date" };
+      }
+      return {
+        kind: "zod-union",
+        schemas: [
+          { kind: "zod-primitive", method: "date" },
+          { kind: "zod-primitive", method: "string" }
+        ]
+      };
+    case "interval":
+      return { kind: "zod-primitive", method: "unknown" };
+    case "json":
+    case "jsonb":
+      return { kind: "zod-primitive", method: "unknown" };
+    case "bytea":
+      return { kind: "zod-custom", typeReference: "Buffer" };
+    case "point":
+      return {
+        kind: "zod-object",
+        properties: [
+          { name: "x", schema: { kind: "zod-primitive", method: "number" } },
+          { name: "y", schema: { kind: "zod-primitive", method: "number" } }
+        ]
+      };
+    case "circle":
+      return {
+        kind: "zod-object",
+        properties: [
+          { name: "x", schema: { kind: "zod-primitive", method: "number" } },
+          { name: "y", schema: { kind: "zod-primitive", method: "number" } },
+          { name: "radius", schema: { kind: "zod-primitive", method: "number" } }
+        ]
+      };
+    case "int4range":
+    case "int8range":
+    case "numrange":
+    case "daterange":
+    case "tsrange":
+    case "tstzrange":
+      return { kind: "zod-primitive", method: "string" };
+    default:
+      return { kind: "zod-primitive", method: "unknown" };
+  }
+}
+
+// src/zod/transform.ts
+function uncapitalize(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function getSchemaName(baseName, mode) {
+  const uncap = uncapitalize(baseName);
+  switch (mode) {
+    case "select":
+      return `${uncap}Schema`;
+    case "insert":
+      return `new${baseName}Schema`;
+    case "update":
+      return `${uncap}UpdateSchema`;
+  }
+}
+function getTypeName(baseName, mode) {
+  switch (mode) {
+    case "select":
+      return baseName;
+    case "insert":
+      return `New${baseName}`;
+    case "update":
+      return `${baseName}Update`;
+  }
+}
+function transformEnumToZod(enumMeta, resolver) {
+  const name = resolver.getName(enumMeta);
+  return {
+    kind: "zod-schema-declaration",
+    name: `${uncapitalize(name)}Schema`,
+    schema: {
+      kind: "zod-enum",
+      values: enumMeta.values
+    },
+    exported: true
+  };
+}
+function transformColumnToZod(column, enums, enumResolver, mode, options) {
+  const columnName = options?.camelCase ? toCamelCase(column.name) : column.name;
+  const matchingEnum = enums.find((e) => e.name === column.dataType && e.schema === (column.dataTypeSchema ?? "public"));
+  let schema;
+  if (matchingEnum) {
+    const enumName = enumResolver.getName(matchingEnum);
+    schema = { kind: "zod-reference", name: `${uncapitalize(enumName)}Schema` };
+    const modifiers = [];
+    if (column.isNullable)
+      modifiers.push("nullable");
+    const isOptional = mode === "update" || mode === "insert" && (column.isAutoIncrement || column.hasDefaultValue);
+    if (isOptional)
+      modifiers.push("optional");
+    if (modifiers.length > 0) {
+      schema = { kind: "zod-modified", schema, modifiers };
+    }
+  } else {
+    const isOptional = mode === "update" || mode === "insert" && (column.isAutoIncrement || column.hasDefaultValue);
+    schema = mapPostgresTypeToZod(column.dataType, {
+      isNullable: column.isNullable,
+      isArray: column.isArray,
+      isOptional,
+      mode
+    });
+  }
+  return { name: columnName, schema };
+}
+function transformTableToZod(table, enums, enumResolver, mode, options) {
+  const baseName = toPascalCase(singularize(table.name));
+  const schemaName = getSchemaName(baseName, mode);
+  const properties = table.columns.map((col) => transformColumnToZod(col, enums, enumResolver, mode, options));
+  return {
+    kind: "zod-schema-declaration",
+    name: schemaName,
+    schema: { kind: "zod-object", properties },
+    exported: true
+  };
+}
+function createInferExport(baseName, mode) {
+  return {
+    kind: "zod-infer-export",
+    typeName: getTypeName(baseName, mode),
+    schemaName: getSchemaName(baseName, mode)
+  };
+}
+function transformDatabaseToZod(metadata, options) {
+  const declarations = [];
+  declarations.push({ kind: "zod-import" });
+  const enumResolver = new EnumNameResolver(metadata.enums);
+  for (const enumMeta of metadata.enums) {
+    declarations.push(transformEnumToZod(enumMeta, enumResolver));
+  }
+  for (const table of metadata.tables) {
+    const baseName = toPascalCase(singularize(table.name));
+    declarations.push(transformTableToZod(table, metadata.enums, enumResolver, "select", options));
+    declarations.push(transformTableToZod(table, metadata.enums, enumResolver, "insert", options));
+    declarations.push(transformTableToZod(table, metadata.enums, enumResolver, "update", options));
+    declarations.push(createInferExport(baseName, "select"));
+    declarations.push(createInferExport(baseName, "insert"));
+    declarations.push(createInferExport(baseName, "update"));
+  }
+  return { declarations };
+}
+
+// src/zod/serialize.ts
+var RESERVED_WORDS2 = new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  "let",
+  "static",
+  "implements",
+  "interface",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "await",
+  "abstract",
+  "as",
+  "async",
+  "declare",
+  "from",
+  "get",
+  "is",
+  "module",
+  "namespace",
+  "of",
+  "require",
+  "set",
+  "type"
+]);
+function escapeString2(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function needsQuotes2(name) {
+  if (RESERVED_WORDS2.has(name))
+    return true;
+  if (/^\d/.test(name))
+    return true;
+  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name))
+    return true;
+  return false;
+}
+function serializePropertyName2(name) {
+  return needsQuotes2(name) ? `'${escapeString2(name)}'` : name;
+}
+function serializeZodSchema(node) {
+  switch (node.kind) {
+    case "zod-primitive":
+      return serializeZodPrimitive(node);
+    case "zod-literal":
+      return serializeZodLiteral(node);
+    case "zod-union":
+      return serializeZodUnion(node);
+    case "zod-enum":
+      return serializeZodEnum(node);
+    case "zod-array":
+      return serializeZodArray(node);
+    case "zod-object":
+      return serializeZodObject(node);
+    case "zod-modified":
+      return serializeZodModified(node);
+    case "zod-reference":
+      return serializeZodReference(node);
+    case "zod-custom":
+      return serializeZodCustom(node);
+  }
+}
+function serializeZodPrimitive(node) {
+  return `z.${node.method}()`;
+}
+function serializeZodLiteral(node) {
+  if (typeof node.value === "string") {
+    return `z.literal('${escapeString2(node.value)}')`;
+  }
+  return `z.literal(${node.value})`;
+}
+function serializeZodUnion(node) {
+  const schemas = node.schemas.map(serializeZodSchema).join(", ");
+  return `z.union([${schemas}])`;
+}
+function serializeZodEnum(node) {
+  const values = node.values.map((v) => `'${escapeString2(v)}'`).join(", ");
+  return `z.enum([${values}])`;
+}
+function serializeZodArray(node) {
+  return `z.array(${serializeZodSchema(node.element)})`;
+}
+function serializeZodObject(node) {
+  if (node.properties.length === 0) {
+    return "z.object({})";
+  }
+  const props = node.properties.map((p) => serializeZodProperty(p)).join(`,
+`);
+  return `z.object({
+${props},
+})`;
+}
+function serializeZodProperty(node) {
+  const name = serializePropertyName2(node.name);
+  return `  ${name}: ${serializeZodSchema(node.schema)}`;
+}
+function serializeZodModified(node) {
+  let result = serializeZodSchema(node.schema);
+  for (const mod of node.modifiers) {
+    result += `.${mod}()`;
+  }
+  return result;
+}
+function serializeZodReference(node) {
+  return node.name;
+}
+function serializeZodCustom(node) {
+  return `z.custom<${node.typeReference}>()`;
+}
+function serializeZodDeclaration(node) {
+  switch (node.kind) {
+    case "zod-import":
+      return "import { z } from 'zod';";
+    case "zod-schema-declaration":
+      return serializeZodSchemaDeclaration(node);
+    case "zod-infer-export":
+      return serializeZodInferExport(node);
+  }
+}
+function serializeZodSchemaDeclaration(node) {
+  const exported = node.exported ? "export " : "";
+  return `${exported}const ${node.name} = ${serializeZodSchema(node.schema)};`;
+}
+function serializeZodInferExport(node) {
+  return `export type ${node.typeName} = z.infer<typeof ${node.schemaName}>;`;
+}
+function serializeZod(program2) {
+  return program2.declarations.map(serializeZodDeclaration).join(`
+
+`) + `
+`;
+}
+
 // src/cli.ts
 var program2 = new Command;
-program2.name("kysely-gen").description("Generate Kysely types from your database").version("0.1.0").option("-o, --out <path>", "Output file path", "./db.d.ts").option("-s, --schema <name>", "Schema to introspect (can be specified multiple times)", collect, []).option("--url <connection-string>", "Database connection string (overrides DATABASE_URL env)").option("-d, --dialect <name>", "Database dialect (postgres, mysql, sqlite). Auto-detected from URL if not specified").option("--camel-case", "Convert column and table names to camelCase (use with Kysely CamelCasePlugin)").option("--include-pattern <pattern>", "Only include tables matching glob pattern (schema.table format)", collect, []).option("--exclude-pattern <pattern>", "Exclude tables matching glob pattern (schema.table format)", collect, []).option("--print", "Output to stdout instead of writing to file").option("--verify", "Verify types match existing file (exit 1 if different)").action(async (options) => {
+program2.name("kysely-gen").description("Generate Kysely types from your database").version("0.1.0").option("-o, --out <path>", "Output file path", "./db.d.ts").option("-s, --schema <name>", "Schema to introspect (can be specified multiple times)", collect, []).option("--url <connection-string>", "Database connection string (overrides DATABASE_URL env)").option("-d, --dialect <name>", "Database dialect (postgres, mysql, sqlite). Auto-detected from URL if not specified").option("--camel-case", "Convert column and table names to camelCase (use with Kysely CamelCasePlugin)").option("--include-pattern <pattern>", "Only include tables matching glob pattern (schema.table format)", collect, []).option("--exclude-pattern <pattern>", "Exclude tables matching glob pattern (schema.table format)", collect, []).option("--print", "Output to stdout instead of writing to file").option("--verify", "Verify types match existing file (exit 1 if different)").option("--zod", "Generate Zod schemas with inferred types instead of TypeScript interfaces").action(async (options) => {
   try {
     await generate(options);
   } catch (error2) {
@@ -111176,7 +111571,8 @@ async function generate(options) {
     dialectName = detected;
   }
   const dialect = getDialect2(dialectName);
-  const outputPath = options.out;
+  const defaultOutputPath = options.zod ? "./db-schemas.ts" : "./db.d.ts";
+  const outputPath = options.out === "./db.d.ts" && options.zod ? defaultOutputPath : options.out;
   const defaultSchema = dialectName === "sqlite" ? "main" : dialectName === "mssql" ? "dbo" : "public";
   const schemas = options.schema.length > 0 ? options.schema : [defaultSchema];
   log("");
@@ -111212,14 +111608,25 @@ async function generate(options) {
     return;
   }
   spinner.succeed(`Found ${source_default.bold(tableCount)} tables and ${source_default.bold(enumCount)} enums`);
-  spinner.start("Generating TypeScript types...");
-  const { program: astProgram, warnings } = transformDatabase(metadata, {
-    dialectName,
-    camelCase: options.camelCase,
-    includePattern: options.includePattern.length > 0 ? options.includePattern : undefined,
-    excludePattern: options.excludePattern.length > 0 ? options.excludePattern : undefined
-  });
-  const code = serialize(astProgram);
+  let code;
+  let warnings = [];
+  if (options.zod) {
+    spinner.start("Generating Zod schemas...");
+    const zodProgram = transformDatabaseToZod(metadata, {
+      camelCase: options.camelCase
+    });
+    code = serializeZod(zodProgram);
+  } else {
+    spinner.start("Generating TypeScript types...");
+    const { program: astProgram, warnings: tsWarnings } = transformDatabase(metadata, {
+      dialectName,
+      camelCase: options.camelCase,
+      includePattern: options.includePattern.length > 0 ? options.includePattern : undefined,
+      excludePattern: options.excludePattern.length > 0 ? options.excludePattern : undefined
+    });
+    code = serialize(astProgram);
+    warnings = tsWarnings;
+  }
   if (options.verify) {
     const absolutePath = resolve(outputPath);
     const existing = await readFile(absolutePath, "utf-8").catch(() => null);
@@ -111240,13 +111647,14 @@ async function generate(options) {
     await db.destroy();
     process.exit(1);
   }
+  const outputLabel = options.zod ? "Zod schemas" : "Types";
   if (printMode) {
-    spinner.succeed("Types generated");
+    spinner.succeed(`${outputLabel} generated`);
     process.stdout.write(code);
   } else {
     const absolutePath = resolve(outputPath);
     await writeFile(absolutePath, code, "utf-8");
-    spinner.succeed(`Types written to ${source_default.cyan(absolutePath)}`);
+    spinner.succeed(`${outputLabel} written to ${source_default.cyan(absolutePath)}`);
   }
   if (warnings.length > 0) {
     log("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely-gen",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Database type generator for Kysely - Supports PostgreSQL, MySQL, SQLite, and MSSQL",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,9 @@
     "typegen",
     "type-generator",
     "database",
-    "sql"
+    "sql",
+    "zod",
+    "validation"
   ],
   "engines": {
     "node": ">=20.0.0",
@@ -73,7 +75,8 @@
     "mysql2": "^3.11.0",
     "tarn": "^3.0.2",
     "tedious": "^18.0.0",
-    "typescript": "^5.6.3"
+    "typescript": "^5.6.3",
+    "zod": "^4.3.5"
   },
   "peerDependencies": {
     "kysely": ">=0.27.0 <1.0.0",
@@ -81,7 +84,8 @@
     "mysql2": ">=3.0.0 <4.0.0",
     "better-sqlite3": ">=9.0.0 <13.0.0",
     "tedious": ">=16.0.0 <19.0.0",
-    "tarn": ">=3.0.0 <4.0.0"
+    "tarn": ">=3.0.0 <4.0.0",
+    "zod": ">=4.0.0 <5.0.0"
   },
   "peerDependenciesMeta": {
     "pg": {
@@ -98,6 +102,9 @@
     },
     "tarn": {
       "optional": true
+    },
+    "zod": {
+      "optional": true
     }
   }
 }