kysely-gen 0.4.0 → 0.5.1

package/dist/cli.js

@@ -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, []).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").action(async (options) => {
   try {
     await generate(options);
   } catch (error2) {
@@ -45891,6 +45929,8 @@ function collect(value, previous) {
   return previous.concat([value]);
 }
 async function generate(options) {
+  const printMode = options.print === true;
+  const log = printMode ? (...args) => console.error(...args) : (...args) => console.log(...args);
   const databaseUrl = options.url || process.env.DATABASE_URL;
   if (!databaseUrl) {
     console.error(source_default.red("Error: DATABASE_URL environment variable is required"));
@@ -45921,15 +45961,17 @@ async function generate(options) {
   const outputPath = options.out;
   const defaultSchema = dialectName === "sqlite" ? "main" : "public";
   const schemas = options.schema.length > 0 ? options.schema : [defaultSchema];
-  console.log("");
-  console.log(source_default.bold("kysely-gen") + source_default.dim(" v0.1.0"));
-  console.log("");
-  console.log(source_default.dim("Dialect:"), dialectName);
-  console.log(source_default.dim("Connection:"), maskPassword(databaseUrl));
-  console.log(source_default.dim("Schemas:"), schemas.join(", "));
-  console.log(source_default.dim("Output:"), resolve(outputPath));
-  console.log("");
-  const spinner = ora("Connecting to database...").start();
+  log("");
+  log(source_default.bold("kysely-gen") + source_default.dim(" v0.1.0"));
+  log("");
+  log(source_default.dim("Dialect:"), dialectName);
+  log(source_default.dim("Connection:"), maskPassword(databaseUrl));
+  log(source_default.dim("Schemas:"), schemas.join(", "));
+  if (!printMode) {
+    log(source_default.dim("Output:"), resolve(outputPath));
+  }
+  log("");
+  const spinner = ora({ text: "Connecting to database...", stream: printMode ? process.stderr : process.stdout }).start();
   let db;
   try {
     const kyselyDialect = await dialect.createKyselyDialect(databaseUrl);
@@ -45945,9 +45987,9 @@ async function generate(options) {
   const enumCount = metadata.enums.length;
   if (tableCount === 0 && enumCount === 0) {
     spinner.warn("No tables or enums found");
-    console.log("");
-    console.log(source_default.yellow("\u26A0 Warning: No tables or enums found in the specified schemas."));
-    console.log(source_default.dim("  Make sure the schema names are correct and contain tables."));
+    log("");
+    log(source_default.yellow("Warning: No tables or enums found in the specified schemas."));
+    log(source_default.dim("  Make sure the schema names are correct and contain tables."));
     await db.destroy();
     return;
   }
@@ -45960,20 +46002,27 @@ async function generate(options) {
     excludePattern: options.excludePattern.length > 0 ? options.excludePattern : undefined
   });
   const code = serialize(astProgram);
-  const absolutePath = resolve(outputPath);
-  await writeFile(absolutePath, code, "utf-8");
-  spinner.succeed(`Types written to ${source_default.cyan(absolutePath)}`);
+  if (printMode) {
+    spinner.succeed("Types 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)}`);
+  }
   if (warnings.length > 0) {
-    console.log("");
-    console.log(source_default.yellow("Warnings:"));
+    log("");
+    log(source_default.yellow("Warnings:"));
     for (const w of warnings) {
-      console.log(source_default.dim(`  Unknown type '${w.pgType}' mapped to 'unknown'`));
+      log(source_default.dim(`  Unknown type '${w.pgType}' mapped to 'unknown'`));
     }
   }
   await db.destroy();
-  console.log("");
-  console.log(source_default.green("Done!"));
-  console.log("");
+  if (!printMode) {
+    log("");
+    log(source_default.green("Done!"));
+    log("");
+  }
 }
 function maskPassword(connectionString) {
   try {

package/package.json

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