introspeql-kysely 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joseph Dvorak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+# IntrospeQL-Kysely
+
+IntrospeQL-Kysely reads information from your PostgreSQL database and generates 
+a type definition file that is compatible with Kysely. 
+
+## Example Usage
+
+```typescript
+// src/model/point.ts
+export interface Point {
+  latitude: number;
+  longitude: number;
+}
+```
+
+```typescript
+// src/scripts/gen-types.ts
+import 'dotenv/config'; // must have dotenv installed
+import path from 'node:path';
+import { 
+  introspeqlKysely, 
+  type IntrospeqlKyselyConfig 
+} from 'introspeql-kysely';
+
+const outFile = '/model/db.ts';
+
+const config: IntrospeqlKyselyConfig = {
+  schemas: ['public'], // Add other schemas as necessary
+  dbConnectionParams: { // These values should be declared in a .env file
+    host: process.env.DB_HOST,
+    port: +process.env.DB_PORT!,
+    database: process.env.DB_NAME,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+  },
+  writeToDisk: true,
+  outFile: path.join(__dirname, '..' + outFile),  
+  header:
+    "import type { Point } from './point';" 
+  types: {
+    'public.geography' : 'Point'
+  }
+};
+
+genTypes();
+
+async function genTypes() {
+  await introspeql(config);
+  console.log("Type definition file created at " + outFile);
+}
+```
+
+```typescript
+// src/main.ts
+import { Kysely, PostgresDialect } from 'kysely';
+import { Pool } from 'pg';
+import { pgFn, type DB } from './model/db';
+
+const dialect = new PostgresDialect({
+  pool: new Pool({
+    host: process.env.DB_HOST,
+    port: +process.env.DB_PORT!,
+    database: process.env.DB_NAME,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    max: 10,
+  })
+})
+
+const db = new Kysely<DB>({
+  dialect
+});
+
+const result = await db
+  .selectFrom('public.locations') // Assumes there is a table called locations
+  .select((eb) => [
+    pgFn('public.st_distance', [
+      eb.ref('coordinates'),
+      eb.val({
+        latitude: 39.95295623565238, 
+        longitude: -75.16348330361122
+      })
+    ]).as('distance_to_philadelphia')
+  ]).execute();
+```
+
+## Further Reading
+
+- Kysely: https://kysely.dev/
+- IntrospeQL: https://github.com/dvorakjt/introspeql
+- node-postgres: https://node-postgres.com/
+
+## License
+
+MIT License
+
+Copyright (c) 2026 Joseph Dvorak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { type IntrospeQLConfig } from "introspeql";
+export type IntrospeqlKyselyConfig = Omit<IntrospeQLConfig, "createTypeDefinitions">;
+export declare function introspeqlKysely(config: IntrospeqlKyselyConfig): Promise<string>;

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.introspeqlKysely = introspeqlKysely;
+var introspeql_1 = require("introspeql");
+var kysely_type_generator_1 = require("./kysely-type-generator");
+function introspeqlKysely(config) {
+    return (0, introspeql_1.introspeql)(__assign(__assign({}, config), { createTypeDefinitions: function (schemaDefinitions) {
+            return new kysely_type_generator_1.KyselyTypeGenerator(schemaDefinitions).genTypes();
+        } }));
+}

package/dist/kysely-type-generator.d.ts

@@ -0,0 +1,27 @@
+import { SchemaDefinition } from "introspeql";
+export declare class KyselyTypeGenerator {
+    private schemaDefinitions;
+    private static readonly KYSELY_GENERATED_TYPE;
+    private static readonly KYSELY_GENERATED_ALWAYS_TYPE;
+    private kyselyImports;
+    constructor(schemaDefinitions: SchemaDefinition[]);
+    genTypes(customHeader?: string): string;
+    private genDBInterfaceNode;
+    private createRelationProperty;
+    private createRelationColumnProperty;
+    private createColumnTypeNode;
+    private genFunctionTypeNodes;
+    private getOverloads;
+    private getOptionalParameterPermutations;
+    private countVariadicParams;
+    private buildConditionalChain;
+    private buildParamTypeNode;
+    private buildReturnTypeNode;
+    private createPgFn;
+    private genImportStatements;
+    private tsTypeToTypeNode;
+    private createEnumTypeNode;
+    private applyNullable;
+    private applyTSDocComment;
+    private formatOutput;
+}

package/dist/kysely-type-generator.js

@@ -0,0 +1,324 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KyselyTypeGenerator = void 0;
+var typescript_1 = __importStar(require("typescript"));
+var sync_1 = __importDefault(require("@prettier/sync"));
+var KyselyTypeGenerator = /** @class */ (function () {
+    function KyselyTypeGenerator(schemaDefinitions) {
+        this.schemaDefinitions = schemaDefinitions;
+        this.kyselyImports = [
+            {
+                value: "sql",
+                isTypeImport: false,
+            },
+            {
+                value: "Expression",
+                isTypeImport: true,
+            },
+            {
+                value: "RawBuilder",
+                isTypeImport: true,
+            },
+        ];
+    }
+    KyselyTypeGenerator.prototype.genTypes = function (customHeader) {
+        var db = this.genDBInterfaceNode();
+        var fnNodes = this.genFunctionTypeNodes();
+        var importStatements = this.genImportStatements();
+        var printer = typescript_1.default.createPrinter();
+        var kyselyImports = printer.printFile(typescript_1.default.factory.createSourceFile([importStatements], typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.EndOfFileToken), typescript_1.NodeFlags.None));
+        var statements = __spreadArray([db], fnNodes, true).map(function (statement) {
+            return printer.printFile(typescript_1.default.factory.createSourceFile([statement], typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.EndOfFileToken), typescript_1.NodeFlags.None));
+        });
+        var src = [kyselyImports];
+        if (customHeader) {
+            src.push(customHeader.trim());
+        }
+        src = __spreadArray(__spreadArray([], src, true), statements, true);
+        var output = src.join("\n\n");
+        return this.formatOutput(output);
+    };
+    KyselyTypeGenerator.prototype.genDBInterfaceNode = function () {
+        var _this = this;
+        var relationProperties = this.schemaDefinitions.flatMap(function (schemaDefinition) {
+            return __spreadArray(__spreadArray(__spreadArray([], schemaDefinition.tableDefinitions, true), schemaDefinition.viewDefinitions, true), schemaDefinition.materializedViewDefinitions, true).map(function (relationDefinition) {
+                return _this.createRelationProperty(schemaDefinition.pgName, relationDefinition);
+            });
+        });
+        var db = typescript_1.default.factory.createInterfaceDeclaration([typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword)], "DB", undefined, undefined, relationProperties);
+        return db;
+    };
+    KyselyTypeGenerator.prototype.createRelationProperty = function (schemaName, relationDefinition) {
+        var _this = this;
+        var relationSignature = typescript_1.default.factory.createPropertySignature(undefined, typescript_1.default.factory.createStringLiteral("".concat(schemaName, ".").concat(relationDefinition.pgName), true), undefined, typescript_1.default.factory.createTypeLiteralNode(relationDefinition.columns.map(function (col) {
+            return _this.createRelationColumnProperty(col);
+        })));
+        relationSignature = this.applyTSDocComment(relationSignature, relationDefinition.tsDocComment);
+        return relationSignature;
+    };
+    KyselyTypeGenerator.prototype.createRelationColumnProperty = function (columnDefinition) {
+        var columnSignature = typescript_1.default.factory.createPropertySignature(undefined, typescript_1.default.factory.createStringLiteral(columnDefinition.pgName, true), undefined, this.createColumnTypeNode(columnDefinition.typeDefinition));
+        columnSignature = this.applyTSDocComment(columnSignature, columnDefinition.tsDocComment);
+        return columnSignature;
+    };
+    KyselyTypeGenerator.prototype.createColumnTypeNode = function (columnTypeDefinition) {
+        var columnType = this.tsTypeToTypeNode(columnTypeDefinition.tsType);
+        for (var i = 0; i < columnTypeDefinition.numDimensions; i++) {
+            columnType = typescript_1.default.factory.createArrayTypeNode(columnType);
+        }
+        this.applyNullable(columnType, columnTypeDefinition.isNullable);
+        if (columnTypeDefinition.generated === "always") {
+            columnType = typescript_1.default.factory.createTypeReferenceNode(KyselyTypeGenerator.KYSELY_GENERATED_ALWAYS_TYPE, [columnType]);
+            if (!this.kyselyImports.some(function (i) { return i.value === KyselyTypeGenerator.KYSELY_GENERATED_ALWAYS_TYPE; })) {
+                this.kyselyImports.push({
+                    value: KyselyTypeGenerator.KYSELY_GENERATED_ALWAYS_TYPE,
+                    isTypeImport: true,
+                });
+            }
+        }
+        else if (columnTypeDefinition.generated === "by_default") {
+            columnType = typescript_1.default.factory.createTypeReferenceNode(KyselyTypeGenerator.KYSELY_GENERATED_TYPE, [columnType]);
+            if (!this.kyselyImports.some(function (i) { return i.value === KyselyTypeGenerator.KYSELY_GENERATED_TYPE; })) {
+                this.kyselyImports.push({
+                    value: KyselyTypeGenerator.KYSELY_GENERATED_TYPE,
+                    isTypeImport: true,
+                });
+            }
+        }
+        return columnType;
+    };
+    KyselyTypeGenerator.prototype.genFunctionTypeNodes = function () {
+        var _this = this;
+        var functionDefinitions = this.schemaDefinitions.flatMap(function (schema) {
+            return schema.functionDefinitions.map(function (fn) { return ({
+                pgName: "".concat(schema.pgName, ".").concat(fn.pgName),
+                overloads: _this.getOverloads(fn),
+            }); });
+        });
+        var pgFnNamesIdentifier = typescript_1.default.factory.createIdentifier("PgFnNames");
+        var pgFnNamesType = typescript_1.default.factory.createTypeAliasDeclaration(undefined, pgFnNamesIdentifier, undefined, functionDefinitions.length > 0
+            ? typescript_1.default.factory.createUnionTypeNode(functionDefinitions.map(function (_a) {
+                var pgName = _a.pgName;
+                return typescript_1.default.factory.createLiteralTypeNode(typescript_1.default.factory.createStringLiteral(pgName, true));
+            }))
+            : typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NeverKeyword));
+        var pgFnParamsType = typescript_1.default.factory.createTypeAliasDeclaration(undefined, typescript_1.default.factory.createIdentifier("PgFnParams"), [
+            typescript_1.default.factory.createTypeParameterDeclaration(undefined, typescript_1.default.factory.createIdentifier("T"), typescript_1.default.factory.createTypeReferenceNode(pgFnNamesIdentifier)),
+        ], this.buildConditionalChain(typescript_1.default.factory.createTypeReferenceNode("T"), functionDefinitions.map(function (_a) {
+            var pgName = _a.pgName, overloads = _a.overloads;
+            return ({
+                extendsType: typescript_1.default.factory.createLiteralTypeNode(typescript_1.default.factory.createStringLiteral(pgName, true)),
+                resultType: typescript_1.default.factory.createUnionTypeNode(overloads.map(function (_a) {
+                    var parameterDefinitions = _a.parameterDefinitions;
+                    return typescript_1.default.factory.createTupleTypeNode(parameterDefinitions.map(function (parameterDefinition) {
+                        return _this.buildParamTypeNode(parameterDefinition);
+                    }));
+                })),
+            });
+        })));
+        var pgFnReturnTypes = typescript_1.default.factory.createTypeAliasDeclaration(undefined, "PgFnReturnTypes", [
+            typescript_1.default.factory.createTypeParameterDeclaration(undefined, typescript_1.default.factory.createIdentifier("T"), typescript_1.default.factory.createTypeReferenceNode(pgFnNamesIdentifier)),
+            typescript_1.default.factory.createTypeParameterDeclaration(undefined, typescript_1.default.factory.createIdentifier("V"), typescript_1.default.factory.createTypeReferenceNode("PgFnParams", [
+                typescript_1.default.factory.createTypeReferenceNode("T"),
+            ])),
+        ], this.buildConditionalChain(typescript_1.default.factory.createTypeReferenceNode("T"), functionDefinitions.map(function (_a) {
+            var pgName = _a.pgName, overloads = _a.overloads;
+            return ({
+                extendsType: typescript_1.default.factory.createLiteralTypeNode(typescript_1.default.factory.createStringLiteral(pgName)),
+                resultType: _this.buildConditionalChain(typescript_1.default.factory.createTypeReferenceNode("V"), overloads.map(function (_a) {
+                    var parameterDefinitions = _a.parameterDefinitions, returnTypeDefinition = _a.returnTypeDefinition;
+                    return ({
+                        extendsType: typescript_1.default.factory.createTupleTypeNode(parameterDefinitions.map(function (parameterDefinition) {
+                            return _this.buildParamTypeNode(parameterDefinition);
+                        })),
+                        resultType: _this.buildReturnTypeNode(returnTypeDefinition),
+                    });
+                })),
+            });
+        })));
+        var pgFn = this.createPgFn();
+        return [pgFnNamesType, pgFnParamsType, pgFnReturnTypes, pgFn];
+    };
+    KyselyTypeGenerator.prototype.getOverloads = function (functionDefinition) {
+        var _this = this;
+        return functionDefinition.overloadDefinitions
+            .flatMap(function (overload) {
+            return _this.getOptionalParameterPermutations(overload.parameterDefinitions).map(function (permutation) { return ({
+                parameterDefinitions: permutation,
+                returnTypeDefinition: overload.returnTypeDefinition,
+            }); });
+        })
+            .toSorted(function (a, b) {
+            var paramCountDiff = a.parameterDefinitions.length - b.parameterDefinitions.length;
+            if (paramCountDiff !== 0)
+                return paramCountDiff;
+            return (_this.countVariadicParams(a.parameterDefinitions) -
+                _this.countVariadicParams(b.parameterDefinitions));
+        });
+    };
+    KyselyTypeGenerator.prototype.getOptionalParameterPermutations = function (params) {
+        var permutation = params.map(function (p) { return ({
+            tsType: p.tsType,
+            isNullable: p.isNullable,
+            isArray: p.isArray,
+            isVariadic: p.isVariadic,
+        }); });
+        var lastParam = params.at(-1);
+        var rest = (lastParam === null || lastParam === void 0 ? void 0 : lastParam.isOptional)
+            ? this.getOptionalParameterPermutations(params.slice(0, -1))
+            : [];
+        return __spreadArray([permutation], rest, true);
+    };
+    KyselyTypeGenerator.prototype.countVariadicParams = function (params) {
+        return params.filter(function (p) { return p.isVariadic; }).length;
+    };
+    KyselyTypeGenerator.prototype.buildConditionalChain = function (checkType, branches) {
+        return branches.reduceRight(function (falseType, _a) {
+            var extendsType = _a.extendsType, resultType = _a.resultType;
+            return typescript_1.default.factory.createConditionalTypeNode(checkType, extendsType, resultType, falseType);
+        }, typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NeverKeyword));
+    };
+    KyselyTypeGenerator.prototype.buildParamTypeNode = function (param) {
+        var type = this.tsTypeToTypeNode(param.tsType);
+        if (param.isArray && !param.isVariadic) {
+            type = typescript_1.default.factory.createArrayTypeNode(type);
+        }
+        type = this.applyNullable(type, param.isNullable);
+        type = typescript_1.default.factory.createTypeReferenceNode("Expression", [type]);
+        if (param.isVariadic) {
+            type = typescript_1.default.factory.createRestTypeNode(typescript_1.default.factory.createArrayTypeNode(type));
+        }
+        return type;
+    };
+    KyselyTypeGenerator.prototype.buildReturnTypeNode = function (returnType) {
+        var type = this.tsTypeToTypeNode(returnType.tsType);
+        if (returnType.isArray) {
+            type = typescript_1.default.factory.createArrayTypeNode(type);
+        }
+        type = this.applyNullable(type, returnType.isNullable);
+        return type;
+    };
+    KyselyTypeGenerator.prototype.createPgFn = function () {
+        return typescript_1.default.factory.createFunctionDeclaration([typescript_1.default.factory.createModifier(typescript_1.default.SyntaxKind.ExportKeyword)], undefined, "pgFn", [
+            typescript_1.default.factory.createTypeParameterDeclaration(undefined, typescript_1.default.factory.createIdentifier("T"), typescript_1.default.factory.createTypeReferenceNode("PgFnNames")),
+            typescript_1.default.factory.createTypeParameterDeclaration(undefined, typescript_1.default.factory.createIdentifier("V"), typescript_1.default.factory.createTypeReferenceNode("PgFnParams", [
+                typescript_1.default.factory.createTypeReferenceNode("T"),
+            ])),
+        ], [
+            typescript_1.default.factory.createParameterDeclaration(undefined, undefined, "fn", undefined, typescript_1.default.factory.createTypeReferenceNode("T")),
+            typescript_1.default.factory.createParameterDeclaration(undefined, undefined, "args", undefined, typescript_1.default.factory.createTypeReferenceNode("V")),
+        ], typescript_1.default.factory.createTypeReferenceNode("RawBuilder", [
+            typescript_1.default.factory.createTypeReferenceNode("PgFnReturnTypes", [
+                typescript_1.default.factory.createTypeReferenceNode("T"),
+                typescript_1.default.factory.createTypeReferenceNode("V"),
+            ]),
+        ]), typescript_1.default.factory.createBlock([
+            typescript_1.default.factory.createReturnStatement(typescript_1.default.factory.createTaggedTemplateExpression(typescript_1.default.factory.createIdentifier("sql"), [
+                typescript_1.default.factory.createTypeReferenceNode("PgFnReturnTypes", [
+                    typescript_1.default.factory.createTypeReferenceNode("T"),
+                    typescript_1.default.factory.createTypeReferenceNode("V"),
+                ]),
+            ], typescript_1.default.factory.createTemplateExpression(typescript_1.default.factory.createTemplateHead(""), [
+                typescript_1.default.factory.createTemplateSpan(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createIdentifier("sql"), "raw"), undefined, [typescript_1.default.factory.createIdentifier("fn")]), typescript_1.default.factory.createTemplateMiddle("(")),
+                typescript_1.default.factory.createTemplateSpan(typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createIdentifier("sql"), "join"), undefined, [typescript_1.default.factory.createIdentifier("args")]), typescript_1.default.factory.createTemplateTail(")")),
+            ]))),
+        ], true));
+    };
+    KyselyTypeGenerator.prototype.genImportStatements = function () {
+        return typescript_1.default.factory.createImportDeclaration(undefined, typescript_1.default.factory.createImportClause(false, undefined, typescript_1.default.factory.createNamedImports(this.kyselyImports.map(function (_a) {
+            var value = _a.value, isTypeImport = _a.isTypeImport;
+            return typescript_1.default.factory.createImportSpecifier(isTypeImport, undefined, typescript_1.default.factory.createIdentifier(value));
+        }))), typescript_1.default.factory.createStringLiteral("kysely", true));
+    };
+    KyselyTypeGenerator.prototype.tsTypeToTypeNode = function (tsType) {
+        return typeof tsType === "object"
+            ? this.createEnumTypeNode(tsType)
+            : typescript_1.default.factory.createTypeReferenceNode(tsType, undefined);
+    };
+    KyselyTypeGenerator.prototype.createEnumTypeNode = function (_a) {
+        var _b, _c, _d;
+        var enumSchema = _a.enumSchema, enumName = _a.enumName;
+        var values = (_d = (_c = (_b = this.schemaDefinitions
+            .find(function (schemaDefinition) { return schemaDefinition.pgName === enumSchema; })) === null || _b === void 0 ? void 0 : _b.enumDefinitions.find(function (enumDefinition) { return enumDefinition.pgName === enumName; })) === null || _c === void 0 ? void 0 : _c.values) !== null && _d !== void 0 ? _d : [];
+        return values.length > 0
+            ? typescript_1.default.factory.createUnionTypeNode(values.map(function (value) {
+                return typescript_1.default.factory.createLiteralTypeNode(typescript_1.default.factory.createStringLiteral(value));
+            }))
+            : typescript_1.default.factory.createKeywordTypeNode(typescript_1.default.SyntaxKind.NeverKeyword);
+    };
+    KyselyTypeGenerator.prototype.applyNullable = function (typeNode, isNullable) {
+        if (!isNullable)
+            return typeNode;
+        return typescript_1.default.factory.createUnionTypeNode([
+            typeNode,
+            typescript_1.default.factory.createLiteralTypeNode(typescript_1.default.factory.createNull()),
+        ]);
+    };
+    KyselyTypeGenerator.prototype.applyTSDocComment = function (propertySignature, tsDocComment) {
+        if (tsDocComment) {
+            tsDocComment = tsDocComment.slice(tsDocComment.indexOf("/*") + "/*".length, tsDocComment.lastIndexOf("*/"));
+            propertySignature = typescript_1.default.addSyntheticLeadingComment(propertySignature, typescript_1.default.SyntaxKind.MultiLineCommentTrivia, tsDocComment, true);
+        }
+        return propertySignature;
+    };
+    KyselyTypeGenerator.prototype.formatOutput = function (output) {
+        return sync_1.default
+            .format(output, {
+            parser: "typescript",
+            plugins: [require.resolve("prettier-plugin-jsdoc")],
+            printWidth: 80,
+            tsDoc: true,
+            jsdocPreferCodeFences: true,
+        })
+            .trim();
+    };
+    KyselyTypeGenerator.KYSELY_GENERATED_TYPE = "Generated";
+    KyselyTypeGenerator.KYSELY_GENERATED_ALWAYS_TYPE = "GeneratedAlways";
+    return KyselyTypeGenerator;
+}());
+exports.KyselyTypeGenerator = KyselyTypeGenerator;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "introspeql-kysely",
+  "version": "0.0.0",
+  "description": "Powered by IntrospeQL, IntrospeQL-Kysely reads types from your Postgres database and generates a type definitions file that is compatible with Kysely",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "Kysely",
+    "IntrospeQL",
+    "PostgreSQL",
+    "Postgres",
+    "TypeScript"
+  ],
+  "author": "Joseph Dvorak",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dvorakjt/introspeql-kysely.git"
+  },
+  "license": "MIT",
+  "type": "commonjs",
+  "dependencies": {
+    "@prettier/sync": "^0.6.1",
+    "introspeql": "^2.0.1",
+    "prettier-plugin-jsdoc": "^1.8.0",
+    "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.5"
+  }
+}