kysely-gen 0.1.0 → 0.3.0

package/dist/cli.js

@@ -9984,6 +9984,153 @@ var source_default = chalk;
 // node_modules/ora/index.js
 import process8 from "node:process";
 
+// node_modules/chalk/source/index.js
+var { stdout: stdoutColor2, stderr: stderrColor2 } = supports_color_default;
+var GENERATOR2 = Symbol("GENERATOR");
+var STYLER2 = Symbol("STYLER");
+var IS_EMPTY2 = Symbol("IS_EMPTY");
+var levelMapping2 = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles3 = Object.create(null);
+var applyOptions2 = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor2 ? stdoutColor2.level : 0;
+  object.level = options.level === undefined ? colorLevel : options.level;
+};
+var chalkFactory2 = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions2(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk2.prototype);
+  return chalk2;
+};
+function createChalk2(options) {
+  return chalkFactory2(options);
+}
+Object.setPrototypeOf(createChalk2.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles3[styleName] = {
+    get() {
+      const builder = createBuilder2(this, createStyler2(style.open, style.close, this[STYLER2]), this[IS_EMPTY2]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles3.visible = {
+  get() {
+    const builder = createBuilder2(this, this[STYLER2], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi2 = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi2("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels2 = ["rgb", "hex", "ansi256"];
+for (const model of usedModels2) {
+  styles3[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler2(getModelAnsi2(model, levelMapping2[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER2]);
+        return createBuilder2(this, styler, this[IS_EMPTY2]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles3[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler2(getModelAnsi2(model, levelMapping2[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER2]);
+        return createBuilder2(this, styler, this[IS_EMPTY2]);
+      };
+    }
+  };
+}
+var proto2 = Object.defineProperties(() => {}, {
+  ...styles3,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR2].level;
+    },
+    set(level) {
+      this[GENERATOR2].level = level;
+    }
+  }
+});
+var createStyler2 = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === undefined) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder2 = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle2(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto2);
+  builder[GENERATOR2] = self;
+  builder[STYLER2] = _styler;
+  builder[IS_EMPTY2] = _isEmpty;
+  return builder;
+};
+var applyStyle2 = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY2] ? "" : string;
+  }
+  let styler = self[STYLER2];
+  if (styler === undefined) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== undefined) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf(`
+`);
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk2.prototype, styles3);
+var chalk2 = createChalk2();
+var chalkStderr2 = createChalk2({ level: stderrColor2 ? stderrColor2.level : 0 });
+var source_default2 = chalk2;
+
 // node_modules/cli-cursor/index.js
 import process5 from "node:process";
 
@@ -12413,7 +12560,7 @@ class Ora {
     const { frames } = this.#spinner;
     let frame = frames[this.#frameIndex];
     if (this.color) {
-      frame = source_default[this.color](frame);
+      frame = source_default2[this.color](frame);
     }
     const fullPrefixText = this.#getFullPrefixText(this.#prefixText, " ");
     const fullText = typeof this.text === "string" ? " " + this.text : "";
@@ -12573,11 +12720,11 @@ function isPlainObject(obj) {
   if (Object.getPrototypeOf(obj) === null) {
     return true;
   }
-  let proto2 = obj;
-  while (Object.getPrototypeOf(proto2) !== null) {
-    proto2 = Object.getPrototypeOf(proto2);
+  let proto3 = obj;
+  while (Object.getPrototypeOf(proto3) !== null) {
+    proto3 = Object.getPrototypeOf(proto3);
   }
-  return Object.getPrototypeOf(obj) === proto2;
+  return Object.getPrototypeOf(obj) === proto3;
 }
 function getLast(arr) {
   return arr[arr.length - 1];
@@ -22330,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(", ");
@@ -22360,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 " : "";
@@ -22401,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,
@@ -22434,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,
@@ -22483,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
@@ -22495,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
@@ -22521,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);
     }
   }
@@ -22607,6 +22932,9 @@ async function introspectEnums(db, schemas) {
   }));
 }
 function isAutoIncrementColumn(column) {
+  if (column.is_identity === "YES") {
+    return true;
+  }
   if (!column.column_default) {
     return false;
   }
@@ -22622,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;
@@ -22684,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) => ({
@@ -22698,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) {
@@ -22750,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
@@ -22844,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":
@@ -22853,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) {
@@ -22864,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;
@@ -22883,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
@@ -22956,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
@@ -22965,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.1.0",
+  "version": "0.3.0",
   "description": "Modern PostgreSQL type generator for Kysely - Built with Bun and TDD",
   "type": "module",
   "license": "MIT",