kysely-gen 0.5.0 → 0.6.0

package/dist/cli.js

@@ -44402,7 +44402,7 @@ function canMap(obj, opt) {
 }
 
 // src/cli.ts
-import { writeFile } from "fs/promises";
+import { readFile, writeFile } from "fs/promises";
 import { resolve } from "path";
 
 // src/ast/serialize.ts
@@ -44644,16 +44644,53 @@ function singularize(str) {
 }
 
 // src/transform/enum.ts
-function getEnumTypeName(enumMeta, defaultSchema = "public") {
+function getEnumKey(enumMeta) {
+  return `${enumMeta.schema}.${enumMeta.name}`;
+}
+function getBaseName(enumMeta, defaultSchema = "public") {
   if (enumMeta.schema === defaultSchema) {
     return toPascalCase(enumMeta.name);
   }
   return toPascalCase(enumMeta.schema) + toPascalCase(enumMeta.name);
 }
-function transformEnum(enumMetadata, defaultSchema = "public") {
+function getFullName(enumMeta) {
+  return toPascalCase(enumMeta.schema) + toPascalCase(enumMeta.name);
+}
+
+class EnumNameResolver {
+  nameMap;
+  constructor(enums, defaultSchema = "public") {
+    this.nameMap = new Map;
+    const baseNames = new Map;
+    for (const enumMeta of enums) {
+      const baseName = getBaseName(enumMeta, defaultSchema);
+      const existing = baseNames.get(baseName) ?? [];
+      existing.push(enumMeta);
+      baseNames.set(baseName, existing);
+    }
+    for (const [, enumsWithSameName] of baseNames) {
+      if (enumsWithSameName.length === 1) {
+        const enumMeta = enumsWithSameName[0];
+        this.nameMap.set(getEnumKey(enumMeta), getBaseName(enumMeta, defaultSchema));
+      } else {
+        for (const enumMeta of enumsWithSameName) {
+          this.nameMap.set(getEnumKey(enumMeta), getFullName(enumMeta));
+        }
+      }
+    }
+  }
+  getName(enumMeta) {
+    return this.nameMap.get(getEnumKey(enumMeta));
+  }
+}
+function getEnumTypeName(enumMeta, defaultSchema = "public") {
+  return getBaseName(enumMeta, defaultSchema);
+}
+function transformEnum(enumMetadata, resolver) {
+  const name = resolver ? resolver.getName(enumMetadata) : getEnumTypeName(enumMetadata);
   return {
     kind: "typeAlias",
-    name: getEnumTypeName(enumMetadata, defaultSchema),
+    name,
     type: {
       kind: "union",
       types: enumMetadata.values.map((value) => ({
@@ -44677,8 +44714,8 @@ function toCamelCase(str) {
 }
 
 // src/transform/table.ts
-function transformTable(table, enums, mapType, options, unknownTypes) {
-  const properties = table.columns.map((column) => transformColumn(column, enums, mapType, options, unknownTypes));
+function transformTable(table, enums, enumResolver, mapType, options, unknownTypes) {
+  const properties = table.columns.map((column) => transformColumn(column, enums, enumResolver, mapType, options, unknownTypes));
   return {
     kind: "interface",
     name: toPascalCase(singularize(table.name)),
@@ -44686,11 +44723,11 @@ function transformTable(table, enums, mapType, options, unknownTypes) {
     exported: true
   };
 }
-function transformColumn(column, enums, mapType, options, unknownTypes) {
+function transformColumn(column, enums, enumResolver, mapType, options, unknownTypes) {
   const matchingEnum = enums.find((e) => e.name === column.dataType && e.schema === (column.dataTypeSchema ?? "public"));
   let type;
   if (matchingEnum) {
-    const enumTypeName = getEnumTypeName(matchingEnum);
+    const enumTypeName = enumResolver.getName(matchingEnum);
     type = { kind: "reference", name: enumTypeName };
     if (column.isNullable) {
       type = {
@@ -45820,13 +45857,14 @@ function transformDatabase(metadata, options) {
       exported: true
     });
   }
+  const enumResolver = new EnumNameResolver(metadata.enums);
   for (const enumMetadata of metadata.enums) {
-    declarations.push(transformEnum(enumMetadata));
+    declarations.push(transformEnum(enumMetadata, enumResolver));
   }
   const filteredTables = filterTables(metadata.tables, options);
   const tableInterfaces = [];
   for (const table of filteredTables) {
-    tableInterfaces.push(transformTable(table, metadata.enums, mapType, options, unknownTypes));
+    tableInterfaces.push(transformTable(table, metadata.enums, enumResolver, mapType, options, unknownTypes));
   }
   declarations.push(...tableInterfaces);
   declarations.push(createDBInterface(filteredTables, options));
@@ -45874,7 +45912,7 @@ function detectDialect(connectionString) {
 
 // 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").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)").action(async (options) => {
   try {
     await generate(options);
   } catch (error2) {
@@ -45893,6 +45931,10 @@ function collect(value, previous) {
 async function generate(options) {
   const printMode = options.print === true;
   const log = printMode ? (...args) => console.error(...args) : (...args) => console.log(...args);
+  if (options.verify && options.print) {
+    console.error(source_default.red("Error: Cannot use --verify with --print"));
+    process.exit(1);
+  }
   const databaseUrl = options.url || process.env.DATABASE_URL;
   if (!databaseUrl) {
     console.error(source_default.red("Error: DATABASE_URL environment variable is required"));
@@ -45964,6 +46006,26 @@ async function generate(options) {
     excludePattern: options.excludePattern.length > 0 ? options.excludePattern : undefined
   });
   const code = serialize(astProgram);
+  if (options.verify) {
+    const absolutePath = resolve(outputPath);
+    const existing = await readFile(absolutePath, "utf-8").catch(() => null);
+    if (existing === null) {
+      spinner.fail(`File not found: ${source_default.cyan(absolutePath)}`);
+      await db.destroy();
+      process.exit(1);
+    }
+    if (existing === code) {
+      spinner.succeed("Types are up-to-date");
+      await db.destroy();
+      process.exit(0);
+    }
+    spinner.fail("Types are out of date");
+    log("");
+    log(source_default.yellow("Generated types differ from existing file."));
+    log(source_default.dim("Run kysely-gen to update."));
+    await db.destroy();
+    process.exit(1);
+  }
   if (printMode) {
     spinner.succeed("Types generated");
     process.stdout.write(code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely-gen",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Database type generator for Kysely - Supports PostgreSQL, MySQL, and SQLite",
   "type": "module",
   "license": "MIT",