kysely-gen 0.7.0 → 0.9.0

package/dist/cli.js

@@ -110411,8 +110411,8 @@ function toCamelCase(str) {
 }
 
 // src/transform/table.ts
-function transformTable(table, enums, enumResolver, mapType, options, unknownTypes) {
-  const properties = table.columns.map((column) => transformColumn(column, enums, enumResolver, mapType, options, unknownTypes));
+function transformTable(table, enums, enumResolver, mapType, options, unknownTypes, usedHelpers) {
+  const properties = table.columns.map((column) => transformColumn(column, enums, enumResolver, mapType, options, unknownTypes, usedHelpers));
   return {
     kind: "interface",
     name: toPascalCase(singularize(table.name)),
@@ -110420,7 +110420,7 @@ function transformTable(table, enums, enumResolver, mapType, options, unknownTyp
     exported: true
   };
 }
-function transformColumn(column, enums, enumResolver, mapType, options, unknownTypes) {
+function transformColumn(column, enums, enumResolver, mapType, options, unknownTypes, usedHelpers) {
   const matchingEnum = enums.find((e) => e.name === column.dataType && e.schema === (column.dataTypeSchema ?? "public"));
   let type;
   if (matchingEnum) {
@@ -110436,10 +110436,11 @@ function transformColumn(column, enums, enumResolver, mapType, options, unknownT
     type = mapType(column.dataType, {
       isNullable: column.isNullable,
       isArray: column.isArray,
-      unknownTypes
+      unknownTypes,
+      usedHelpers
     });
   }
-  if (column.isAutoIncrement) {
+  if (column.isAutoIncrement || column.hasDefaultValue) {
     type = {
       kind: "generic",
       name: "Generated",
@@ -110773,25 +110774,15 @@ function parsePostgresArray(value) {
 }
 
 // src/dialects/postgres/type-mapper.ts
-function createColumnType(selectType, insertType, updateType) {
-  const typeArguments = [selectType];
-  if (insertType) {
-    typeArguments.push(insertType);
-    if (updateType) {
-      typeArguments.push(updateType);
-    }
-  }
-  return {
-    kind: "generic",
-    name: "ColumnType",
-    typeArguments
-  };
+function helper(name, options) {
+  options.usedHelpers?.add(name);
+  return { kind: "reference", name };
 }
 function mapPostgresType(dataType, options) {
   const { isNullable, isArray, unknownTypes } = options;
   if (isArray || dataType.endsWith("[]")) {
     const baseTypeName = dataType.endsWith("[]") ? dataType.slice(0, -2) : dataType;
-    const elementType = mapPostgresType(baseTypeName, { isNullable: false, isArray: false, unknownTypes });
+    const elementType = mapPostgresType(baseTypeName, { isNullable: false, isArray: false, unknownTypes, usedHelpers: options.usedHelpers });
     const isSimple = elementType.kind === "primitive" && ["boolean", "number", "string"].includes(elementType.value);
     let arrayType;
     if (isSimple) {
@@ -110817,21 +110808,7 @@ function mapPostgresType(dataType, options) {
       break;
     case "int8":
     case "bigint":
-      baseType = createColumnType({ kind: "primitive", value: "string" }, {
-        kind: "union",
-        types: [
-          { kind: "primitive", value: "string" },
-          { kind: "primitive", value: "number" },
-          { kind: "primitive", value: "bigint" }
-        ]
-      }, {
-        kind: "union",
-        types: [
-          { kind: "primitive", value: "string" },
-          { kind: "primitive", value: "number" },
-          { kind: "primitive", value: "bigint" }
-        ]
-      });
+      baseType = helper("Int8", options);
       break;
     case "float4":
     case "float8":
@@ -110841,19 +110818,7 @@ function mapPostgresType(dataType, options) {
       break;
     case "numeric":
     case "decimal":
-      baseType = createColumnType({ kind: "primitive", value: "string" }, {
-        kind: "union",
-        types: [
-          { kind: "primitive", value: "number" },
-          { kind: "primitive", value: "string" }
-        ]
-      }, {
-        kind: "union",
-        types: [
-          { kind: "primitive", value: "number" },
-          { kind: "primitive", value: "string" }
-        ]
-      });
+      baseType = helper("Numeric", options);
       break;
     case "varchar":
     case "char":
@@ -110869,38 +110834,14 @@ function mapPostgresType(dataType, options) {
     case "timestamp":
     case "timestamptz":
     case "date":
-      baseType = createColumnType({ kind: "primitive", value: "Date" }, {
-        kind: "union",
-        types: [
-          { kind: "primitive", value: "Date" },
-          { kind: "primitive", value: "string" }
-        ]
-      }, {
-        kind: "union",
-        types: [
-          { kind: "primitive", value: "Date" },
-          { kind: "primitive", value: "string" }
-        ]
-      });
+      baseType = helper("Timestamp", options);
       break;
     case "time":
     case "timetz":
       baseType = { kind: "primitive", value: "string" };
       break;
     case "interval":
-      baseType = createColumnType({ kind: "reference", name: "IPostgresInterval" }, {
-        kind: "union",
-        types: [
-          { kind: "reference", name: "IPostgresInterval" },
-          { kind: "primitive", value: "string" }
-        ]
-      }, {
-        kind: "union",
-        types: [
-          { kind: "reference", name: "IPostgresInterval" },
-          { kind: "primitive", value: "string" }
-        ]
-      });
+      baseType = helper("Interval", options);
       break;
     case "money":
       baseType = { kind: "primitive", value: "string" };
@@ -110912,6 +110853,12 @@ function mapPostgresType(dataType, options) {
     case "bytea":
       baseType = { kind: "primitive", value: "Buffer" };
       break;
+    case "point":
+      baseType = helper("Point", options);
+      break;
+    case "circle":
+      baseType = helper("Circle", options);
+      break;
     case "int4range":
     case "int8range":
     case "numrange":
@@ -111119,7 +111066,7 @@ function extractEnums(tables) {
 }
 
 // src/dialects/mysql/type-mapper.ts
-function createColumnType2(selectType, insertType, updateType) {
+function createColumnType(selectType, insertType, updateType) {
   const typeArguments = [selectType];
   if (insertType) {
     typeArguments.push(insertType);
@@ -111147,7 +111094,7 @@ function mapMysqlType(dataType, options) {
       baseType = { kind: "primitive", value: "number" };
       break;
     case "bigint":
-      baseType = createColumnType2({ kind: "primitive", value: "string" }, {
+      baseType = createColumnType({ kind: "primitive", value: "string" }, {
         kind: "union",
         types: [
           { kind: "primitive", value: "string" },
@@ -111170,7 +111117,7 @@ function mapMysqlType(dataType, options) {
       break;
     case "decimal":
     case "numeric":
-      baseType = createColumnType2({ kind: "primitive", value: "string" }, {
+      baseType = createColumnType({ kind: "primitive", value: "string" }, {
         kind: "union",
         types: [
           { kind: "primitive", value: "number" },
@@ -111206,7 +111153,7 @@ function mapMysqlType(dataType, options) {
     case "date":
     case "datetime":
     case "timestamp":
-      baseType = createColumnType2({ kind: "primitive", value: "Date" }, {
+      baseType = createColumnType({ kind: "primitive", value: "Date" }, {
         kind: "union",
         types: [
           { kind: "primitive", value: "Date" },
@@ -111668,10 +111615,71 @@ function getDialect(name) {
   }
 }
 
+// src/dialects/postgres/helpers.ts
+function createColumnType2(selectType, insertType, updateType) {
+  return {
+    kind: "generic",
+    name: "ColumnType",
+    typeArguments: [selectType, insertType, updateType]
+  };
+}
+function createUnion(...types2) {
+  return { kind: "union", types: types2 };
+}
+function primitive(value) {
+  if (value === "Date") {
+    return { kind: "reference", name: "Date" };
+  }
+  return { kind: "primitive", value };
+}
+function ref(name) {
+  return { kind: "reference", name };
+}
+var HELPER_DEFINITIONS = {
+  Timestamp: {
+    kind: "typeAlias",
+    name: "Timestamp",
+    exported: true,
+    type: createColumnType2(primitive("Date"), createUnion(primitive("Date"), primitive("string")), createUnion(primitive("Date"), primitive("string")))
+  },
+  Int8: {
+    kind: "typeAlias",
+    name: "Int8",
+    exported: true,
+    type: createColumnType2(primitive("string"), createUnion(primitive("string"), primitive("number"), primitive("bigint")), createUnion(primitive("string"), primitive("number"), primitive("bigint")))
+  },
+  Numeric: {
+    kind: "typeAlias",
+    name: "Numeric",
+    exported: true,
+    type: createColumnType2(primitive("string"), createUnion(primitive("number"), primitive("string")), createUnion(primitive("number"), primitive("string")))
+  },
+  Interval: {
+    kind: "typeAlias",
+    name: "Interval",
+    exported: true,
+    type: createColumnType2(ref("IPostgresInterval"), createUnion(ref("IPostgresInterval"), primitive("string")), createUnion(ref("IPostgresInterval"), primitive("string")))
+  },
+  Point: {
+    kind: "typeAlias",
+    name: "Point",
+    exported: true,
+    type: { kind: "raw", value: "{ x: number; y: number }" }
+  },
+  Circle: {
+    kind: "typeAlias",
+    name: "Circle",
+    exported: true,
+    type: { kind: "raw", value: "{ x: number; y: number; radius: number }" }
+  }
+};
+var HELPER_NAMES = Object.keys(HELPER_DEFINITIONS);
+
 // src/transform/index.ts
 function transformDatabase(metadata, options) {
   const declarations = [];
   const unknownTypes = new Set;
+  const usedHelpers = new Set;
   const dialectName = options?.dialectName ?? "postgres";
   const dialect = getDialect(dialectName);
   const mapType = options?.mapType ?? ((dataType, opts) => dialect.mapType(dataType, opts));
@@ -111759,22 +111767,6 @@ function transformDatabase(metadata, options) {
     },
     exported: true
   });
-  if (dialectName === "postgres") {
-    declarations.push({
-      kind: "interface",
-      name: "IPostgresInterval",
-      properties: [
-        { name: "years", type: { kind: "primitive", value: "number" }, optional: true },
-        { name: "months", type: { kind: "primitive", value: "number" }, optional: true },
-        { name: "days", type: { kind: "primitive", value: "number" }, optional: true },
-        { name: "hours", type: { kind: "primitive", value: "number" }, optional: true },
-        { name: "minutes", type: { kind: "primitive", value: "number" }, optional: true },
-        { name: "seconds", type: { kind: "primitive", value: "number" }, optional: true },
-        { name: "milliseconds", type: { kind: "primitive", value: "number" }, optional: true }
-      ],
-      exported: true
-    });
-  }
   if (dialectName === "mysql") {
     declarations.push({
       kind: "interface",
@@ -111818,7 +111810,31 @@ function transformDatabase(metadata, options) {
   const filteredTables = filterTables(metadata.tables, options);
   const tableInterfaces = [];
   for (const table of filteredTables) {
-    tableInterfaces.push(transformTable(table, metadata.enums, enumResolver, mapType, options, unknownTypes));
+    tableInterfaces.push(transformTable(table, metadata.enums, enumResolver, mapType, options, unknownTypes, usedHelpers));
+  }
+  if (dialectName === "postgres") {
+    if (usedHelpers.has("Interval")) {
+      declarations.push({
+        kind: "interface",
+        name: "IPostgresInterval",
+        properties: [
+          { name: "years", type: { kind: "primitive", value: "number" }, optional: true },
+          { name: "months", type: { kind: "primitive", value: "number" }, optional: true },
+          { name: "days", type: { kind: "primitive", value: "number" }, optional: true },
+          { name: "hours", type: { kind: "primitive", value: "number" }, optional: true },
+          { name: "minutes", type: { kind: "primitive", value: "number" }, optional: true },
+          { name: "seconds", type: { kind: "primitive", value: "number" }, optional: true },
+          { name: "milliseconds", type: { kind: "primitive", value: "number" }, optional: true }
+        ],
+        exported: true
+      });
+    }
+    const helperOrder = ["Timestamp", "Int8", "Numeric", "Interval", "Point", "Circle"];
+    for (const name of helperOrder) {
+      if (usedHelpers.has(name)) {
+        declarations.push(HELPER_DEFINITIONS[name]);
+      }
+    }
   }
   declarations.push(...tableInterfaces);
   declarations.push(createDBInterface(filteredTables, options));

package/package.json

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