kysely-gen 0.5.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));

package/package.json

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