kysely-gen 0.2.2 → 0.3.0

package/dist/cli.js

@@ -22477,25 +22477,51 @@ function serializeType(node) {
       return serializeReference(node);
     case "raw":
       return serializeRaw(node);
+    case "tuple":
+      return serializeTuple(node);
+    case "conditional":
+      return serializeConditional(node);
+    case "keyof":
+      return serializeKeyof(node);
+    case "indexAccess":
+      return serializeIndexAccess(node);
+    case "infer":
+      return serializeInfer(node);
   }
 }
 function serializePrimitive(node) {
   return node.value;
 }
+function escapeString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
 function serializeLiteral(node) {
   if (typeof node.value === "string") {
-    return `'${node.value}'`;
+    return `'${escapeString(node.value)}'`;
   }
   return String(node.value);
 }
+function needsParens(node, context) {
+  if (context === "union" && node.kind === "intersection")
+    return true;
+  if (context === "intersection" && node.kind === "union")
+    return true;
+  if (context === "array" && (node.kind === "union" || node.kind === "intersection"))
+    return true;
+  return false;
+}
+function serializeWithParens(node, context) {
+  const serialized = serializeType(node);
+  return needsParens(node, context) ? `(${serialized})` : serialized;
+}
 function serializeUnion(node) {
-  return node.types.map(serializeType).join(" | ");
+  return node.types.map((t) => serializeWithParens(t, "union")).join(" | ");
 }
 function serializeIntersection(node) {
-  return node.types.map(serializeType).join(" & ");
+  return node.types.map((t) => serializeWithParens(t, "intersection")).join(" & ");
 }
 function serializeArray(node) {
-  return `${serializeType(node.elementType)}[]`;
+  return `${serializeWithParens(node.elementType, "array")}[]`;
 }
 function serializeGeneric(node) {
   const typeArgs = node.typeArguments.map(serializeType).join(", ");
@@ -22507,10 +22533,103 @@ function serializeReference(node) {
 function serializeRaw(node) {
   return node.value;
 }
+function serializeTuple(node) {
+  return `[${node.elements.map(serializeType).join(", ")}]`;
+}
+function serializeConditional(node) {
+  const check = serializeType(node.checkType);
+  const ext = serializeType(node.extendsType);
+  const trueType = serializeType(node.trueType);
+  const falseType = serializeType(node.falseType);
+  return `${check} extends ${ext} ? ${trueType} : ${falseType}`;
+}
+function serializeKeyof(node) {
+  return `keyof ${serializeType(node.type)}`;
+}
+function serializeIndexAccess(node) {
+  return `${serializeType(node.objectType)}[${serializeType(node.indexType)}]`;
+}
+function serializeInfer(node) {
+  return `infer ${node.name}`;
+}
+var RESERVED_WORDS = 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 needsQuotes(name) {
+  if (RESERVED_WORDS.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 serializePropertyName(name) {
+  return needsQuotes(name) ? `'${escapeString(name)}'` : name;
+}
 function serializeProperty(node, indent = "  ") {
   const optional = node.optional ? "?" : "";
   const readonly = node.readonly ? "readonly " : "";
-  return `${indent}${readonly}${node.name}${optional}: ${serializeType(node.type)};`;
+  const propName = serializePropertyName(node.name);
+  return `${indent}${readonly}${propName}${optional}: ${serializeType(node.type)};`;
 }
 function serializeInterface(node) {
   const exported = node.exported ? "export " : "";
@@ -22548,14 +22667,15 @@ function serialize(program2) {
 
 // src/introspect/postgres.ts
 async function introspectDatabase(db, options) {
-  const [domains, partitions, baseTables, materializedViews, enums] = await Promise.all([
+  const [domains, partitions, baseTables, regularViews, materializedViews, enums] = await Promise.all([
     introspectDomains(db),
     introspectPartitions(db),
     introspectTables(db, options.schemas),
+    introspectViews(db, options.schemas),
     introspectMaterializedViews(db, options.schemas),
     introspectEnums(db, options.schemas)
   ]);
-  const tables = [...baseTables, ...materializedViews].map((table) => {
+  const tables = [...baseTables, ...regularViews, ...materializedViews].map((table) => {
     const isPartition = partitions.some((partition) => partition.schema === table.schema && partition.name === table.name);
     return {
       ...table,
@@ -22581,6 +22701,7 @@ async function introspectTables(db, schemas) {
       c.udt_name,
       c.udt_schema,
       c.is_nullable,
+      c.is_identity,
       c.column_default,
       pg_catalog.col_description(
         (c.table_schema||'.'||c.table_name)::regclass::oid,
@@ -22630,6 +22751,67 @@ async function introspectTables(db, schemas) {
   }
   return Array.from(tableMap.values());
 }
+async function introspectViews(db, schemas) {
+  const rawColumns = await sql`
+    SELECT
+      c.table_schema,
+      c.table_name,
+      c.column_name,
+      c.data_type,
+      c.udt_name,
+      c.udt_schema,
+      c.is_nullable,
+      c.is_identity,
+      c.column_default,
+      pg_catalog.col_description(
+        (c.table_schema||'.'||c.table_name)::regclass::oid,
+        c.ordinal_position
+      ) as column_comment
+    FROM information_schema.columns c
+    INNER JOIN information_schema.tables t
+      ON c.table_schema = t.table_schema
+      AND c.table_name = t.table_name
+    WHERE t.table_type = 'VIEW'
+      AND c.table_schema = ANY(${schemas})
+    ORDER BY c.table_schema, c.table_name, c.ordinal_position
+  `.execute(db);
+  const tableMap = new Map;
+  for (const row of rawColumns.rows) {
+    const tableKey = `${row.table_schema}.${row.table_name}`;
+    if (!tableMap.has(tableKey)) {
+      tableMap.set(tableKey, {
+        schema: row.table_schema,
+        name: row.table_name,
+        columns: [],
+        isView: true
+      });
+    }
+    const table = tableMap.get(tableKey);
+    if (table) {
+      const isArray = row.data_type === "ARRAY";
+      let dataType = row.udt_name;
+      if (isArray && dataType.startsWith("_")) {
+        dataType = dataType.slice(1);
+      }
+      const columnMetadata = {
+        name: row.column_name,
+        dataType,
+        dataTypeSchema: row.udt_schema,
+        isNullable: row.is_nullable === "YES",
+        isAutoIncrement: false,
+        hasDefaultValue: row.column_default !== null
+      };
+      if (isArray) {
+        columnMetadata.isArray = true;
+      }
+      if (row.column_comment) {
+        columnMetadata.comment = row.column_comment;
+      }
+      table.columns.push(columnMetadata);
+    }
+  }
+  return Array.from(tableMap.values());
+}
 async function introspectMaterializedViews(db, schemas) {
   const rawColumns = await sql`
     SELECT
@@ -22642,12 +22824,15 @@ async function introspectMaterializedViews(db, schemas) {
       t.typname AS data_type,
       t.typname AS udt_name,
       tn.nspname AS udt_schema,
+      t.typcategory,
+      et.typname AS element_type,
       col_description(c.oid, a.attnum) AS column_comment
     FROM pg_class c
     JOIN pg_namespace n ON n.oid = c.relnamespace
     JOIN pg_attribute a ON a.attrelid = c.oid
     JOIN pg_type t ON t.oid = a.atttypid
     JOIN pg_namespace tn ON tn.oid = t.typnamespace
+    LEFT JOIN pg_type et ON t.typelem = et.oid AND t.typcategory = 'A'
     LEFT JOIN pg_attrdef ad ON ad.adrelid = c.oid AND ad.adnum = a.attnum
     WHERE c.relkind = 'm'
       AND a.attnum > 0
@@ -22668,25 +22853,18 @@ async function introspectMaterializedViews(db, schemas) {
     }
     const table = tableMap.get(tableKey);
     if (table) {
-      const isArray = row.data_type.startsWith("_");
-      let dataType = row.udt_name;
-      if (isArray) {
-        dataType = dataType.slice(1);
-      }
+      const isArray = row.typcategory === "A";
+      const dataType = isArray && row.element_type ? row.element_type : row.udt_name;
       const columnMetadata = {
         name: row.column_name,
         dataType,
         dataTypeSchema: row.udt_schema,
         isNullable: row.is_nullable === "YES",
         isAutoIncrement: row.column_default?.includes("nextval") ?? false,
-        hasDefaultValue: row.column_default !== null
+        hasDefaultValue: row.column_default !== null,
+        ...isArray && { isArray: true },
+        ...row.column_comment && { comment: row.column_comment }
       };
-      if (isArray) {
-        columnMetadata.isArray = true;
-      }
-      if (row.column_comment) {
-        columnMetadata.comment = row.column_comment;
-      }
       table.columns.push(columnMetadata);
     }
   }
@@ -22754,6 +22932,9 @@ async function introspectEnums(db, schemas) {
   }));
 }
 function isAutoIncrementColumn(column) {
+  if (column.is_identity === "YES") {
+    return true;
+  }
   if (!column.column_default) {
     return false;
   }
@@ -22769,51 +22950,8 @@ function parsePostgresArray(value) {
   return [value];
 }
 
-// src/transform.ts
+// src/transform/filter.ts
 var import_micromatch = __toESM(require_micromatch(), 1);
-
-// src/utils/case-converter.ts
-class CaseConverter extends CamelCasePlugin {
-  toCamelCase(str) {
-    return this.camelCase(str);
-  }
-}
-function toCamelCase(str) {
-  return new CaseConverter().toCamelCase(str);
-}
-
-// src/transform.ts
-function transformDatabase(metadata, options) {
-  const declarations = [];
-  declarations.push({
-    kind: "import",
-    imports: ["ColumnType"],
-    from: "kysely",
-    typeOnly: true
-  });
-  declarations.push({
-    kind: "typeAlias",
-    name: "Generated<T>",
-    type: {
-      kind: "raw",
-      value: `T extends ColumnType<infer S, infer I, infer U>
-  ? ColumnType<S, I | undefined, U>
-  : ColumnType<T, T | undefined, T>`
-    },
-    exported: true
-  });
-  for (const enumMetadata of metadata.enums) {
-    declarations.push(transformEnum(enumMetadata));
-  }
-  const filteredTables = filterTables(metadata.tables, options);
-  const tableInterfaces = [];
-  for (const table of filteredTables) {
-    tableInterfaces.push(transformTable(table, metadata.enums, options));
-  }
-  declarations.push(...tableInterfaces);
-  declarations.push(createDBInterface(filteredTables, options));
-  return { declarations };
-}
 function filterTables(tables, options) {
   if (!options || !options.includePattern && !options.excludePattern) {
     return tables;
@@ -22831,10 +22969,29 @@ function filterTables(tables, options) {
     return true;
   });
 }
-function transformEnum(enumMetadata) {
+
+// src/transform/utils.ts
+function toPascalCase(str) {
+  return str.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function singularize(str) {
+  if (str.endsWith("s")) {
+    return str.slice(0, -1);
+  }
+  return str;
+}
+
+// src/transform/enum.ts
+function getEnumTypeName(enumMeta, defaultSchema = "public") {
+  if (enumMeta.schema === defaultSchema) {
+    return toPascalCase(enumMeta.name);
+  }
+  return toPascalCase(enumMeta.schema) + toPascalCase(enumMeta.name);
+}
+function transformEnum(enumMetadata, defaultSchema = "public") {
   return {
     kind: "typeAlias",
-    name: toPascalCase(enumMetadata.name),
+    name: getEnumTypeName(enumMetadata, defaultSchema),
     type: {
       kind: "union",
       types: enumMetadata.values.map((value) => ({
@@ -22845,44 +23002,19 @@ function transformEnum(enumMetadata) {
     exported: true
   };
 }
-function transformTable(table, enums, options) {
-  const properties = table.columns.map((column) => transformColumn(column, enums, options));
-  return {
-    kind: "interface",
-    name: toPascalCase(singularize(table.name)),
-    properties,
-    exported: true
-  };
-}
-function transformColumn(column, enums, options) {
-  const matchingEnum = enums.find((e) => e.name === column.dataType);
-  let type;
-  if (matchingEnum) {
-    const enumTypeName = toPascalCase(matchingEnum.name);
-    type = { kind: "reference", name: enumTypeName };
-    if (column.isNullable) {
-      type = {
-        kind: "union",
-        types: [type, { kind: "primitive", value: "null" }]
-      };
-    }
-  } else {
-    type = mapPostgresType(column.dataType, column.isNullable, column.isArray);
-  }
-  if (column.isAutoIncrement) {
-    type = {
-      kind: "generic",
-      name: "Generated",
-      typeArguments: [type]
-    };
+
+// src/utils/case-converter.ts
+class CaseConverter extends CamelCasePlugin {
+  toCamelCase(str) {
+    return this.camelCase(str);
   }
-  const columnName = options?.camelCase ? toCamelCase(column.name) : column.name;
-  return {
-    name: columnName,
-    type,
-    optional: false
-  };
 }
+var caseConverter = new CaseConverter;
+function toCamelCase(str) {
+  return caseConverter.toCamelCase(str);
+}
+
+// src/transform/type-mapper.ts
 function createColumnType(selectType, insertType, updateType) {
   const typeArguments = [selectType];
   if (insertType) {
@@ -22897,10 +23029,10 @@ function createColumnType(selectType, insertType, updateType) {
     typeArguments
   };
 }
-function mapPostgresType(pgType, isNullable, isArray) {
+function mapPostgresType(pgType, isNullable, isArray, unknownTypes) {
   if (isArray || pgType.endsWith("[]")) {
     const baseTypeName = pgType.endsWith("[]") ? pgType.slice(0, -2) : pgType;
-    const elementType = mapPostgresType(baseTypeName, false, false);
+    const elementType = mapPostgresType(baseTypeName, false, false, unknownTypes);
     const arrayType = {
       kind: "array",
       elementType
@@ -22991,6 +23123,10 @@ function mapPostgresType(pgType, isNullable, isArray) {
       break;
     case "time":
     case "timetz":
+    case "interval":
+      baseType = { kind: "primitive", value: "string" };
+      break;
+    case "money":
       baseType = { kind: "primitive", value: "string" };
       break;
     case "json":
@@ -23000,7 +23136,18 @@ function mapPostgresType(pgType, isNullable, isArray) {
     case "bytea":
       baseType = { kind: "primitive", value: "Buffer" };
       break;
+    case "int4range":
+    case "int8range":
+    case "numrange":
+    case "daterange":
+    case "tsrange":
+    case "tstzrange":
+      baseType = { kind: "primitive", value: "string" };
+      break;
     default:
+      if (unknownTypes) {
+        unknownTypes.add(pgType);
+      }
       baseType = { kind: "primitive", value: "unknown" };
   }
   if (isNullable) {
@@ -23011,6 +23158,46 @@ function mapPostgresType(pgType, isNullable, isArray) {
   }
   return baseType;
 }
+
+// src/transform/table.ts
+function transformTable(table, enums, options, unknownTypes) {
+  const properties = table.columns.map((column) => transformColumn(column, enums, options, unknownTypes));
+  return {
+    kind: "interface",
+    name: toPascalCase(singularize(table.name)),
+    properties,
+    exported: true
+  };
+}
+function transformColumn(column, enums, options, unknownTypes) {
+  const matchingEnum = enums.find((e) => e.name === column.dataType && e.schema === (column.dataTypeSchema ?? "public"));
+  let type;
+  if (matchingEnum) {
+    const enumTypeName = getEnumTypeName(matchingEnum);
+    type = { kind: "reference", name: enumTypeName };
+    if (column.isNullable) {
+      type = {
+        kind: "union",
+        types: [type, { kind: "primitive", value: "null" }]
+      };
+    }
+  } else {
+    type = mapPostgresType(column.dataType, column.isNullable, column.isArray, unknownTypes);
+  }
+  if (column.isAutoIncrement) {
+    type = {
+      kind: "generic",
+      name: "Generated",
+      typeArguments: [type]
+    };
+  }
+  const columnName = options?.camelCase ? toCamelCase(column.name) : column.name;
+  return {
+    name: columnName,
+    type,
+    optional: false
+  };
+}
 function createDBInterface(tables, options) {
   const properties = tables.map((table) => {
     const tableName = options?.camelCase ? toCamelCase(table.name) : table.name;
@@ -23030,14 +23217,43 @@ function createDBInterface(tables, options) {
     exported: true
   };
 }
-function toPascalCase(str) {
-  return str.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
-}
-function singularize(str) {
-  if (str.endsWith("s")) {
-    return str.slice(0, -1);
+
+// src/transform/index.ts
+function transformDatabase(metadata, options) {
+  const declarations = [];
+  const unknownTypes = new Set;
+  declarations.push({
+    kind: "import",
+    imports: ["ColumnType"],
+    from: "kysely",
+    typeOnly: true
+  });
+  declarations.push({
+    kind: "typeAlias",
+    name: "Generated<T>",
+    type: {
+      kind: "raw",
+      value: `T extends ColumnType<infer S, infer I, infer U>
+  ? ColumnType<S, I | undefined, U>
+  : ColumnType<T, T | undefined, T>`
+    },
+    exported: true
+  });
+  for (const enumMetadata of metadata.enums) {
+    declarations.push(transformEnum(enumMetadata));
   }
-  return str;
+  const filteredTables = filterTables(metadata.tables, options);
+  const tableInterfaces = [];
+  for (const table of filteredTables) {
+    tableInterfaces.push(transformTable(table, metadata.enums, options, unknownTypes));
+  }
+  declarations.push(...tableInterfaces);
+  declarations.push(createDBInterface(filteredTables, options));
+  const warnings = Array.from(unknownTypes).map((pgType) => ({
+    type: "unknown_type",
+    pgType
+  }));
+  return { program: { declarations }, warnings };
 }
 
 // src/cli.ts
@@ -23103,7 +23319,7 @@ async function generate(options) {
   }
   spinner.succeed(`Found ${source_default.bold(tableCount)} tables and ${source_default.bold(enumCount)} enums`);
   spinner.start("Generating TypeScript types...");
-  const program3 = transformDatabase(metadata, {
+  const { program: program3, warnings } = transformDatabase(metadata, {
     camelCase: options.camelCase,
     includePattern: options.includePattern.length > 0 ? options.includePattern : undefined,
     excludePattern: options.excludePattern.length > 0 ? options.excludePattern : undefined
@@ -23112,9 +23328,16 @@ async function generate(options) {
   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:"));
+    for (const w of warnings) {
+      console.log(source_default.dim(`  Unknown type '${w.pgType}' mapped to 'unknown'`));
+    }
+  }
   await db.destroy();
   console.log("");
-  console.log(source_default.green("\u2713 Done!"));
+  console.log(source_default.green("Done!"));
   console.log("");
 }
 function maskPassword(url) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely-gen",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Modern PostgreSQL type generator for Kysely - Built with Bun and TDD",
   "type": "module",
   "license": "MIT",