@danielfgray/pg-sourcerer 0.2.1 → 0.2.2

package/dist/plugins/kysely.js

@@ -0,0 +1,906 @@
+/**
+ * Kysely Plugin - Generate Kysely-compatible types and query functions
+ *
+ * Consolidates types and queries generation into a single plugin with unified config.
+ * Generates:
+ * - Types: DB interface, table interfaces with Generated<T> wrappers, enum types
+ * - Queries: CRUD functions, index lookups, stored function wrappers
+ *
+ * @example
+ * ```typescript
+ * import { kysely } from "pg-sourcerer"
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     kysely({
+ *       outputDir: "db",
+ *       generateQueries: true,
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+import { Option, pipe, Schema as S } from "effect";
+import { definePlugin } from "../services/plugin.js";
+import { findEnumByPgName, findCompositeByPgName, PgTypeOid } from "../services/pg-types.js";
+import { getEnumEntities, getTableEntities, getCompositeEntities, } from "../ir/semantic-ir.js";
+import { conjure, cast } from "../lib/conjure.js";
+import { resolveFieldType, tsTypeToAst } from "../lib/field-utils.js";
+import { inflect } from "../services/inflection.js";
+import { isEnumType, getPgTypeName } from "../lib/field-utils.js";
+import { getExtensionTypeMapping } from "../services/pg-types.js";
+const { ts, exp, b, param, str } = conjure;
+const { toExpr } = cast;
+const KyselyConfigSchema = S.Struct({
+    outputDir: S.optionalWith(S.String, { default: () => "db" }),
+    dbTypeName: S.optionalWith(S.String, { default: () => "DB" }),
+    camelCase: S.optionalWith(S.Boolean, { default: () => true }),
+    runtimeEnums: S.optionalWith(S.Boolean, { default: () => false }),
+    typeOnlyImports: S.optionalWith(S.Boolean, { default: () => true }),
+    generateQueries: S.optionalWith(S.Boolean, { default: () => true }),
+    dbTypesPath: S.optionalWith(S.String, { default: () => "./db.js" }),
+    executeQueries: S.optionalWith(S.Boolean, { default: () => true }),
+    generateListMany: S.optionalWith(S.Boolean, { default: () => false }),
+    generateFunctions: S.optionalWith(S.Boolean, { default: () => true }),
+    functionsFile: S.optionalWith(S.String, { default: () => "functions.ts" }),
+    exportName: S.optional(S.Any),
+    exportStyle: S.optionalWith(S.Literal("flat", "namespace"), { default: () => "flat" }),
+    explicitColumns: S.optionalWith(S.Boolean, { default: () => true }),
+    dbAsParameter: S.optionalWith(S.Boolean, { default: () => true }),
+    header: S.optional(S.String),
+    defaultLimit: S.optionalWith(S.Number, { default: () => 50 }),
+});
+const GENERATED_TYPE_DEF = `T extends ColumnType<infer S, infer I, infer U>
+  ? ColumnType<S, I | undefined, U>
+  : ColumnType<T, T | undefined, T>`;
+const ARRAY_TYPE_DEF = `ArrayTypeImpl<T> extends (infer U)[]
+  ? U[]
+  : ArrayTypeImpl<T>`;
+const ARRAY_TYPE_IMPL_DEF = `T extends ColumnType<infer S, infer I, infer U>
+  ? ColumnType<S[], I[], U[]>
+  : T[]`;
+const SCALAR_TYPES = {
+    bool: ts.boolean,
+    int2: ts.number,
+    int4: ts.number,
+    float4: ts.number,
+    float8: ts.number,
+    oid: ts.number,
+    text: ts.string,
+    varchar: ts.string,
+    bpchar: ts.string,
+    char: ts.string,
+    name: ts.string,
+    bit: ts.string,
+    varbit: ts.string,
+    xml: ts.string,
+    uuid: ts.string,
+    inet: ts.string,
+    cidr: ts.string,
+    macaddr: ts.string,
+    macaddr8: ts.string,
+    line: ts.string,
+    lseg: ts.string,
+    box: ts.string,
+    path: ts.string,
+    polygon: ts.string,
+    time: ts.string,
+    timetz: ts.string,
+    tsvector: ts.string,
+    tsquery: ts.string,
+    txid_snapshot: ts.string,
+    money: ts.string,
+    bytea: () => ts.ref("Buffer"),
+};
+const COMPLEX_TYPES = {
+    int8: {
+        select: ts.string,
+        insert: () => ts.union(ts.string(), ts.number(), ts.bigint()),
+        update: () => ts.union(ts.string(), ts.number(), ts.bigint()),
+    },
+    numeric: {
+        select: ts.string,
+        insert: () => ts.union(ts.number(), ts.string()),
+        update: () => ts.union(ts.number(), ts.string()),
+    },
+    date: {
+        select: () => ts.ref("Date"),
+        insert: () => ts.union(ts.ref("Date"), ts.string()),
+        update: () => ts.union(ts.ref("Date"), ts.string()),
+    },
+    timestamp: {
+        select: () => ts.ref("Date"),
+        insert: () => ts.union(ts.ref("Date"), ts.string()),
+        update: () => ts.union(ts.ref("Date"), ts.string()),
+    },
+    timestamptz: {
+        select: () => ts.ref("Date"),
+        insert: () => ts.union(ts.ref("Date"), ts.string()),
+        update: () => ts.union(ts.ref("Date"), ts.string()),
+    },
+    interval: {
+        select: ts.string,
+        insert: () => ts.union(ts.string(), ts.number()),
+        update: () => ts.union(ts.string(), ts.number()),
+    },
+    json: {
+        select: () => ts.ref("JsonValue"),
+        insert: () => ts.ref("JsonValue"),
+        update: () => ts.ref("JsonValue"),
+    },
+    jsonb: {
+        select: () => ts.ref("JsonValue"),
+        insert: () => ts.ref("JsonValue"),
+        update: () => ts.ref("JsonValue"),
+    },
+    point: {
+        select: () => ts.objectType([
+            { name: "x", type: ts.number() },
+            { name: "y", type: ts.number() },
+        ]),
+        insert: () => ts.objectType([
+            { name: "x", type: ts.number() },
+            { name: "y", type: ts.number() },
+        ]),
+        update: () => ts.objectType([
+            { name: "x", type: ts.number() },
+            { name: "y", type: ts.number() },
+        ]),
+    },
+    circle: {
+        select: () => ts.objectType([
+            { name: "x", type: ts.number() },
+            { name: "y", type: ts.number() },
+            { name: "radius", type: ts.number() },
+        ]),
+        insert: () => ts.objectType([
+            { name: "x", type: ts.number() },
+            { name: "y", type: ts.number() },
+            { name: "radius", type: ts.number() },
+        ]),
+        update: () => ts.objectType([
+            { name: "x", type: ts.number() },
+            { name: "y", type: ts.number() },
+            { name: "radius", type: ts.number() },
+        ]),
+    },
+};
+// ============================================================================
+// Helper Functions (Types)
+// ============================================================================
+const buildFieldMatch = (field, ctx) => ({
+    schema: ctx.schemaName,
+    table: ctx.tableName,
+    column: field.columnName,
+    pgType: field.isArray && field.elementTypeName
+        ? field.elementTypeName
+        : field.pgAttribute.getType()?.typname ?? "",
+});
+function resolveFieldTypeForKysely(field, ctx) {
+    const pgType = field.pgAttribute.getType();
+    const typeName = pgType?.typname ?? "";
+    const fieldMatch = buildFieldMatch(field, ctx);
+    const tsTypeHint = ctx.typeHints.getHint(fieldMatch, "tsType");
+    if (Option.isSome(tsTypeHint)) {
+        const typeName = tsTypeHint.value;
+        const importPath = ctx.typeHints.getHint(fieldMatch, "import");
+        return {
+            selectType: ts.ref(typeName),
+            needsColumnType: false,
+            externalImport: pipe(importPath, Option.map(path => ({ name: typeName, from: path })), Option.getOrUndefined),
+        };
+    }
+    if (isEnumType(field)) {
+        const enumName = getPgTypeName(field);
+        if (enumName) {
+            const enumDef = findEnumByPgName(ctx.enums, enumName);
+            if (Option.isSome(enumDef)) {
+                return {
+                    selectType: ts.ref(enumDef.value.name),
+                    needsColumnType: false,
+                };
+            }
+        }
+    }
+    if (pgType?.typtype === "c") {
+        const compositeName = getPgTypeName(field);
+        if (compositeName) {
+            const compositeDef = findCompositeByPgName(ctx.composites, compositeName);
+            if (Option.isSome(compositeDef)) {
+                return {
+                    selectType: ts.ref(compositeDef.value.name),
+                    needsColumnType: false,
+                };
+            }
+        }
+    }
+    const complexType = COMPLEX_TYPES[typeName];
+    if (complexType) {
+        return {
+            selectType: complexType.select(),
+            insertType: complexType.insert(),
+            updateType: complexType.update(),
+            needsColumnType: true,
+            externalImport: complexType.import,
+        };
+    }
+    const scalarBuilder = SCALAR_TYPES[typeName];
+    if (scalarBuilder) {
+        return {
+            selectType: scalarBuilder(),
+            needsColumnType: false,
+        };
+    }
+    if (pgType) {
+        const extType = getExtensionTypeMapping(typeName, String(pgType.typnamespace), ctx.extensions);
+        if (Option.isSome(extType)) {
+            return {
+                selectType: ts.fromString(extType.value),
+                needsColumnType: false,
+            };
+        }
+    }
+    return {
+        selectType: ts.string(),
+        needsColumnType: false,
+    };
+}
+function buildFieldType(field, kyselyType, needsGenerated) {
+    let baseType;
+    if (kyselyType.needsColumnType && kyselyType.insertType && kyselyType.updateType) {
+        baseType = ts.ref("ColumnType", [
+            kyselyType.selectType,
+            kyselyType.insertType,
+            kyselyType.updateType,
+        ]);
+    }
+    else {
+        baseType = kyselyType.selectType;
+    }
+    if (field.isArray) {
+        if (kyselyType.needsColumnType) {
+            baseType = ts.ref("ArrayType", [baseType]);
+        }
+        else {
+            baseType = ts.array(baseType);
+        }
+    }
+    if (field.nullable) {
+        baseType = ts.nullable(baseType);
+    }
+    if (needsGenerated) {
+        baseType = ts.ref("Generated", [baseType]);
+    }
+    return baseType;
+}
+function isGeneratedField(field) {
+    // Identity and generated columns are always "generated" regardless of hasDefault
+    if (field.isIdentity)
+        return true;
+    if (field.isGenerated)
+        return true;
+    if (!field.hasDefault)
+        return false;
+    if (!field.permissions.canInsert)
+        return true;
+    const pgType = field.pgAttribute.getType();
+    if (!pgType)
+        return false;
+    const typeOid = Number(pgType._id);
+    const isIntegerType = typeOid === PgTypeOid.Int2
+        || typeOid === PgTypeOid.Int4
+        || typeOid === PgTypeOid.Int8;
+    if (isIntegerType && field.hasDefault) {
+        const constraints = field.pgAttribute.getClass()?.getConstraints() ?? [];
+        const isPrimaryKey = constraints.some(c => c.contype === "p" && c.conkey?.includes(field.pgAttribute.attnum));
+        if (isPrimaryKey)
+            return true;
+    }
+    return false;
+}
+// ============================================================================
+// Helper Functions (Queries)
+// ============================================================================
+const getTableTypeName = (entity) => entity.name;
+const getTableRef = (entity, defaultSchemas) => defaultSchemas.includes(entity.schemaName)
+    ? entity.pgName
+    : `${entity.schemaName}.${entity.pgName}`;
+const findRowField = (entity, columnName) => entity.shapes.row.fields.find(f => f.columnName === columnName);
+const getFieldTypeAst = (field, ctx) => {
+    if (!field)
+        return ts.string();
+    const resolved = resolveFieldType(field, ctx.enums, ctx.ir.extensions);
+    return resolved.enumDef ? ts.ref(resolved.enumDef.name) : tsTypeToAst(resolved.tsType);
+};
+const getFieldTypeString = (field, ctx) => {
+    if (!field)
+        return "string";
+    const resolved = resolveFieldType(field, ctx.enums, ctx.ir.extensions);
+    return resolved.enumDef ? resolved.enumDef.name : resolved.tsType;
+};
+const toPascalCase = (s) => inflect.pascalCase(s);
+const id = (name) => b.identifier(name);
+const call = (obj, method, args = []) => b.callExpression(b.memberExpression(toExpr(obj), id(method)), args.map(toExpr));
+const selectFrom = (tableRef) => call(id("db"), "selectFrom", [str(tableRef)]);
+const selectColumns = (base, entity, explicitColumns) => explicitColumns
+    ? call(base, "select", [b.arrayExpression(entity.shapes.row.fields.map(f => str(f.columnName)))])
+    : call(base, "selectAll");
+const insertInto = (tableRef) => call(id("db"), "insertInto", [str(tableRef)]);
+const updateTable = (tableRef) => call(id("db"), "updateTable", [str(tableRef)]);
+const deleteFrom = (tableRef) => call(id("db"), "deleteFrom", [str(tableRef)]);
+const chain = (expr, method, args = []) => call(expr, method, args);
+const arrowFn = (params, body) => {
+    const fn = b.arrowFunctionExpression(params.map(p => p), toExpr(body));
+    return fn;
+};
+const pgTypeNameToTs = (typeName) => {
+    const baseName = typeName.includes(".") ? typeName.split(".").pop() : typeName;
+    switch (baseName) {
+        case "bool":
+        case "boolean":
+            return "boolean";
+        case "int2":
+        case "smallint":
+        case "int4":
+        case "integer":
+        case "int":
+        case "oid":
+        case "float4":
+        case "real":
+        case "float8":
+        case "double precision":
+            return "number";
+        case "int8":
+        case "bigint":
+        case "numeric":
+        case "decimal":
+        case "money":
+            return "string";
+        case "text":
+        case "varchar":
+        case "character varying":
+        case "char":
+        case "character":
+        case "bpchar":
+        case "name":
+        case "xml":
+        case "bit":
+        case "varbit":
+        case "bit varying":
+        case "uuid":
+        case "inet":
+        case "cidr":
+        case "macaddr":
+        case "macaddr8":
+        case "time":
+        case "timetz":
+        case "time with time zone":
+        case "time without time zone":
+        case "interval":
+            return "string";
+        case "date":
+        case "timestamp":
+        case "timestamptz":
+        case "timestamp with time zone":
+        case "timestamp without time zone":
+            return "Date";
+        case "json":
+        case "jsonb":
+        case "jsonpath":
+            return "unknown";
+        case "bytea":
+            return "Buffer";
+        case "void":
+            return "void";
+        default:
+            return "unknown";
+    }
+};
+// ============================================================================
+// Query Method Generators
+// ============================================================================
+const generateFindById = (ctx) => {
+    const { entity, executeQueries, defaultSchemas, entityName, exportName, explicitColumns, dbAsParameter } = ctx;
+    if (!entity.primaryKey || !entity.permissions.canSelect)
+        return undefined;
+    const pkColName = entity.primaryKey.columns[0];
+    const pkField = findRowField(entity, pkColName);
+    if (!pkField)
+        return undefined;
+    const tableRef = getTableRef(entity, defaultSchemas);
+    const fieldName = pkField.name;
+    const fieldType = getFieldTypeAst(pkField, ctx);
+    let query = chain(selectColumns(selectFrom(tableRef), entity, explicitColumns), "where", [str(pkColName), str("="), id(fieldName)]);
+    if (executeQueries) {
+        query = chain(query, "executeTakeFirst");
+    }
+    const optionsParam = param.destructured([{ name: fieldName, type: fieldType }]);
+    const dbParam = param.typed("db", ts.ref("Kysely", [ts.ref("DB")]));
+    const params = dbAsParameter ? [optionsParam, dbParam] : [optionsParam];
+    const fn = arrowFn(params, query);
+    const name = exportName(entityName, "FindById");
+    const rowType = entity.shapes.row.name;
+    const meta = {
+        name,
+        kind: "read",
+        params: [{
+                name: fieldName,
+                type: getFieldTypeString(pkField, ctx),
+                required: true,
+                columnName: pkColName,
+                source: "pk",
+            }],
+        returns: { type: rowType, nullable: true, isArray: false },
+        callSignature: { style: "named" },
+    };
+    return { name, fn, meta };
+};
+const generateListMany = (ctx) => {
+    const { entity, executeQueries, defaultSchemas, entityName, exportName, explicitColumns, dbAsParameter, defaultLimit } = ctx;
+    if (!entity.permissions.canSelect)
+        return undefined;
+    const tableRef = getTableRef(entity, defaultSchemas);
+    let query = chain(chain(selectColumns(selectFrom(tableRef), entity, explicitColumns), "limit", [id("limit")]), "offset", [id("offset")]);
+    if (executeQueries) {
+        query = chain(query, "execute");
+    }
+    const optionsParam = param.destructured([
+        { name: "limit", type: ts.number(), optional: true, defaultValue: b.numericLiteral(defaultLimit) },
+        { name: "offset", type: ts.number(), optional: true, defaultValue: b.numericLiteral(0) },
+    ]);
+    const dbParam = param.typed("db", ts.ref("Kysely", [ts.ref("DB")]));
+    const params = dbAsParameter ? [optionsParam, dbParam] : [optionsParam];
+    const fn = arrowFn(params, query);
+    const name = exportName(entityName, "ListMany");
+    const rowType = entity.shapes.row.name;
+    const meta = {
+        name,
+        kind: "list",
+        params: [
+            { name: "limit", type: "number", required: false, source: "pagination" },
+            { name: "offset", type: "number", required: false, source: "pagination" },
+        ],
+        returns: { type: rowType, nullable: false, isArray: true },
+        callSignature: { style: "named" },
+    };
+    return { name, fn, meta };
+};
+const generateCreate = (ctx) => {
+    const { entity, executeQueries, defaultSchemas, entityName, exportName, dbAsParameter } = ctx;
+    if (!entity.permissions.canInsert)
+        return undefined;
+    const tableRef = getTableRef(entity, defaultSchemas);
+    const tableTypeName = getTableTypeName(entity);
+    let query = chain(chain(insertInto(tableRef), "values", [id("data")]), "returningAll");
+    if (executeQueries) {
+        query = chain(query, "executeTakeFirstOrThrow");
+    }
+    const optionsParam = param.destructured([
+        { name: "data", type: ts.ref("Insertable", [ts.ref(tableTypeName)]) },
+    ]);
+    const dbParam = param.typed("db", ts.ref("Kysely", [ts.ref("DB")]));
+    const params = dbAsParameter ? [optionsParam, dbParam] : [optionsParam];
+    const fn = arrowFn(params, query);
+    const name = exportName(entityName, "Create");
+    const rowType = entity.shapes.row.name;
+    const insertType = `Insertable<${tableTypeName}>`;
+    const meta = {
+        name,
+        kind: "create",
+        params: [{
+                name: "data",
+                type: insertType,
+                required: true,
+                source: "body",
+            }],
+        returns: { type: rowType, nullable: false, isArray: false },
+        callSignature: { style: "named", bodyStyle: "property" },
+    };
+    return { name, fn, meta };
+};
+const generateUpdate = (ctx) => {
+    const { entity, executeQueries, defaultSchemas, entityName, exportName, dbAsParameter } = ctx;
+    if (!entity.primaryKey || !entity.permissions.canUpdate)
+        return undefined;
+    const pkColName = entity.primaryKey.columns[0];
+    const pkField = findRowField(entity, pkColName);
+    if (!pkField)
+        return undefined;
+    const tableRef = getTableRef(entity, defaultSchemas);
+    const fieldName = pkField.name;
+    const fieldType = getFieldTypeAst(pkField, ctx);
+    const tableTypeName = getTableTypeName(entity);
+    let query = chain(chain(chain(updateTable(tableRef), "set", [id("data")]), "where", [
+        str(pkColName),
+        str("="),
+        id(fieldName),
+    ]), "returningAll");
+    if (executeQueries) {
+        query = chain(query, "executeTakeFirstOrThrow");
+    }
+    const optionsParam = param.destructured([
+        { name: fieldName, type: fieldType },
+        { name: "data", type: ts.ref("Updateable", [ts.ref(tableTypeName)]) },
+    ]);
+    const dbParam = param.typed("db", ts.ref("Kysely", [ts.ref("DB")]));
+    const params = dbAsParameter ? [optionsParam, dbParam] : [optionsParam];
+    const fn = arrowFn(params, query);
+    const name = exportName(entityName, "Update");
+    const rowType = entity.shapes.row.name;
+    const updateType = `Updateable<${tableTypeName}>`;
+    const meta = {
+        name,
+        kind: "update",
+        params: [
+            {
+                name: fieldName,
+                type: getFieldTypeString(pkField, ctx),
+                required: true,
+                columnName: pkColName,
+                source: "pk",
+            },
+            {
+                name: "data",
+                type: updateType,
+                required: true,
+                source: "body",
+            },
+        ],
+        returns: { type: rowType, nullable: false, isArray: false },
+        callSignature: { style: "named", bodyStyle: "property" },
+    };
+    return { name, fn, meta };
+};
+const generateDelete = (ctx) => {
+    const { entity, executeQueries, defaultSchemas, entityName, exportName, dbAsParameter } = ctx;
+    if (!entity.primaryKey || !entity.permissions.canDelete)
+        return undefined;
+    const pkColName = entity.primaryKey.columns[0];
+    const pkField = findRowField(entity, pkColName);
+    if (!pkField)
+        return undefined;
+    const tableRef = getTableRef(entity, defaultSchemas);
+    const fieldName = pkField.name;
+    const fieldType = getFieldTypeAst(pkField, ctx);
+    let query = chain(deleteFrom(tableRef), "where", [
+        str(pkColName),
+        str("="),
+        id(fieldName),
+    ]);
+    if (executeQueries) {
+        query = chain(query, "execute");
+    }
+    const optionsParam = param.destructured([{ name: fieldName, type: fieldType }]);
+    const dbParam = param.typed("db", ts.ref("Kysely", [ts.ref("DB")]));
+    const params = dbAsParameter ? [optionsParam, dbParam] : [optionsParam];
+    const fn = arrowFn(params, query);
+    const name = exportName(entityName, "Remove");
+    const meta = {
+        name,
+        kind: "delete",
+        params: [{
+                name: fieldName,
+                type: getFieldTypeString(pkField, ctx),
+                required: true,
+                columnName: pkColName,
+                source: "pk",
+            }],
+        returns: { type: "void", nullable: false, isArray: false },
+        callSignature: { style: "named" },
+    };
+    return { name, fn, meta };
+};
+const generateCrudMethods = (ctx) => [
+    generateFindById(ctx),
+    ctx.generateListMany ? generateListMany(ctx) : undefined,
+    generateCreate(ctx),
+    generateUpdate(ctx),
+    generateDelete(ctx),
+].filter((p) => p != null);
+const collectImports = (entities, composites, ctx) => {
+    const kyselyImports = new Set();
+    const externalImports = new Map();
+    let needsJsonTypes = false;
+    let needsArrayType = false;
+    let needsGenerated = false;
+    const processField = (field, schemaName, tableName, checkGenerated) => {
+        const kyselyType = resolveFieldTypeForKysely(field, {
+            ...ctx,
+            schemaName,
+            tableName,
+        });
+        if (kyselyType.needsColumnType) {
+            kyselyImports.add("ColumnType");
+        }
+        if (kyselyType.externalImport) {
+            const { name, from } = kyselyType.externalImport;
+            if (!externalImports.has(from)) {
+                externalImports.set(from, new Set());
+            }
+            externalImports.get(from).add(name);
+        }
+        // Note: Enum types are generated in the same file, no import needed
+        const pgType = field.pgAttribute.getType();
+        if (pgType?.typname === "json" || pgType?.typname === "jsonb") {
+            needsJsonTypes = true;
+        }
+        if (field.isArray && kyselyType.needsColumnType) {
+            needsArrayType = true;
+        }
+        if (checkGenerated && isGeneratedField(field)) {
+            needsGenerated = true;
+        }
+    };
+    for (const entity of entities) {
+        if (!entity.permissions.canSelect)
+            continue;
+        for (const field of entity.shapes.row.fields) {
+            if (!field.permissions.canSelect)
+                continue;
+            processField(field, entity.schemaName, entity.pgName, true);
+        }
+    }
+    for (const composite of composites) {
+        for (const field of composite.fields) {
+            processField(field, composite.schemaName, composite.pgName, false);
+        }
+    }
+    return {
+        kyselyImports,
+        externalImports,
+        needsJsonTypes,
+        needsArrayType,
+        needsGenerated,
+    };
+};
+// ============================================================================
+// Statement Generators (Types)
+// ============================================================================
+const generateEnumStatement = (enumEntity) => {
+    return exp.typeAlias(enumEntity.name, { capability: "types", entity: enumEntity.name }, ts.union(...enumEntity.values.map(v => ts.literal(v))));
+};
+const generateTableInterface = (entity, ctx) => {
+    const properties = [];
+    for (const field of entity.shapes.row.fields) {
+        if (!field.permissions.canSelect)
+            continue;
+        const kyselyType = resolveFieldTypeForKysely(field, ctx);
+        const needsGenerated = isGeneratedField(field);
+        const fieldType = buildFieldType(field, kyselyType, needsGenerated);
+        properties.push({
+            name: field.name,
+            type: fieldType,
+        });
+    }
+    return exp.interface(entity.name, { capability: "types", entity: entity.name }, properties);
+};
+const generateCompositeInterface = (composite, ctx) => {
+    const properties = [];
+    for (const field of composite.fields) {
+        const kyselyType = resolveFieldTypeForKysely(field, ctx);
+        const fieldType = buildFieldType(field, kyselyType, false);
+        properties.push({
+            name: field.name,
+            type: fieldType,
+        });
+    }
+    return exp.interface(composite.name, { capability: "types", entity: composite.name }, properties);
+};
+const generateDBInterface = (entities, defaultSchemas, dbTypeName) => {
+    const properties = [];
+    for (const entity of entities) {
+        if (!entity.permissions.canSelect)
+            continue;
+        const key = defaultSchemas.includes(entity.schemaName)
+            ? entity.pgName
+            : `${entity.schemaName}.${entity.pgName}`;
+        properties.push({
+            name: key,
+            type: ts.ref(entity.name),
+        });
+    }
+    properties.sort((a, b) => a.name.localeCompare(b.name));
+    return exp.interface(dbTypeName, { capability: "types", entity: dbTypeName }, properties);
+};
+// ============================================================================
+// Export Style Helpers (Queries)
+// ============================================================================
+const toFlatExports = (methods) => methods.map(m => conjure.export.const(m.name, m.fn));
+const toNamespaceExport = (entityName, methods) => {
+    const properties = methods.map(m => b.objectProperty(id(m.name), m.fn));
+    const obj = b.objectExpression(properties);
+    return conjure.export.const(entityName, obj);
+};
+const toStatements = (methods, exportStyle, entityName) => {
+    if (methods.length === 0)
+        return [];
+    return exportStyle === "namespace"
+        ? [toNamespaceExport(entityName, methods)]
+        : toFlatExports(methods);
+};
+// ============================================================================
+// Main Generation Function
+// ============================================================================
+export function kysely(config) {
+    const parsed = S.decodeUnknownSync(KyselyConfigSchema)(config);
+    const defaultExportName = (_entityName, methodName) => methodName.charAt(0).toLowerCase() + methodName.slice(1);
+    // Compute dbTypesPath from dbTypeName if not explicitly provided
+    // Both DB types and query files are in the same outputDir, so use "./" not "../"
+    const dbTypesPath = config.dbTypesPath ?? `./${parsed.dbTypeName}.js`;
+    const resolvedConfig = {
+        ...parsed,
+        dbTypesPath,
+        exportName: parsed.exportName ?? defaultExportName,
+    };
+    return definePlugin({
+        name: "kysely",
+        kind: "queries",
+        singleton: true,
+        canProvide: () => true,
+        provide: (_params, _deps, ctx) => {
+            const { ir, typeHints } = ctx;
+            const enumEntities = getEnumEntities(ir);
+            const compositeEntities = getCompositeEntities(ir).filter(e => e.tags.omit !== true);
+            const tableEntities = getTableEntities(ir).filter(e => e.tags.omit !== true);
+            const defaultSchemas = ir.schemas;
+            const dbTypeName = parsed.dbTypeName;
+            // ================================================================
+            // Generate Types (DB.ts)
+            // ================================================================
+            const fieldCtx = {
+                schemaName: "",
+                tableName: "",
+                enums: enumEntities,
+                composites: compositeEntities,
+                extensions: ir.extensions,
+                typeHints,
+                defaultSchemas,
+            };
+            const imports = collectImports(tableEntities, compositeEntities, fieldCtx);
+            const statements = [];
+            for (const enumEntity of enumEntities) {
+                if (enumEntity.tags.omit === true)
+                    continue;
+                statements.push(generateEnumStatement(enumEntity));
+            }
+            for (const composite of compositeEntities) {
+                statements.push(generateCompositeInterface(composite, {
+                    ...fieldCtx,
+                    schemaName: composite.schemaName,
+                    tableName: composite.pgName,
+                }));
+            }
+            for (const entity of tableEntities) {
+                statements.push(generateTableInterface(entity, {
+                    ...fieldCtx,
+                    schemaName: entity.schemaName,
+                    tableName: entity.pgName,
+                }));
+            }
+            statements.push(generateDBInterface(tableEntities, defaultSchemas, dbTypeName));
+            const dbFilePath = `${parsed.outputDir}/${dbTypeName}.ts`;
+            const dbFile = ctx.file(dbFilePath);
+            if (imports.kyselyImports.size > 0) {
+                dbFile.import({
+                    kind: "package",
+                    types: [...imports.kyselyImports],
+                    from: "kysely",
+                });
+            }
+            for (const [from, names] of imports.externalImports) {
+                dbFile.import({
+                    kind: "relative",
+                    types: [...names],
+                    from,
+                });
+            }
+            const helperTypes = [];
+            if (imports.needsGenerated) {
+                helperTypes.push(`export type Generated<T> = ${GENERATED_TYPE_DEF};`);
+            }
+            if (imports.needsArrayType) {
+                helperTypes.push(`export type ArrayType<T> = ${ARRAY_TYPE_DEF};`);
+                helperTypes.push(`export type ArrayTypeImpl<T> = ${ARRAY_TYPE_IMPL_DEF};`);
+            }
+            if (imports.needsJsonTypes) {
+                helperTypes.push(`export type JsonPrimitive = boolean | number | string | null;`);
+                helperTypes.push(`export type JsonObject = { [x: string]: JsonValue | undefined };`);
+                helperTypes.push(`export type JsonArray = JsonValue[];`);
+                helperTypes.push(`export type JsonValue = JsonArray | JsonObject | JsonPrimitive;`);
+            }
+            if (helperTypes.length > 0) {
+                dbFile.header(helperTypes.join("\n\n"));
+            }
+            dbFile.ast(conjure.symbolProgram(...statements)).emit();
+            // ================================================================
+            // Generate Queries
+            // ================================================================
+            if (!parsed.generateQueries) {
+                return;
+            }
+            const exportName = resolvedConfig.exportName;
+            const exportStyle = resolvedConfig.exportStyle;
+            for (const entity of tableEntities) {
+                const entityName = entity.name;
+                const filePath = `${parsed.outputDir}/${entityName}.ts`;
+                const file = ctx.file(filePath);
+                const genCtx = {
+                    entity,
+                    enums: enumEntities,
+                    ir,
+                    defaultSchemas,
+                    dbTypesPath: resolvedConfig.dbTypesPath,
+                    executeQueries: parsed.executeQueries,
+                    generateListMany: parsed.generateListMany,
+                    entityName,
+                    exportName,
+                    explicitColumns: parsed.explicitColumns,
+                    dbAsParameter: parsed.dbAsParameter,
+                    defaultLimit: parsed.defaultLimit,
+                };
+                const methods = generateCrudMethods(genCtx);
+                if (methods.length === 0) {
+                    continue;
+                }
+                if (parsed.header) {
+                    file.header(parsed.header);
+                }
+                // Build kysely imports based on what's actually used
+                const kyselyTypes = [];
+                if (parsed.dbAsParameter) {
+                    kyselyTypes.push("Kysely");
+                }
+                if (methods.some((m) => m.meta.kind === "create")) {
+                    kyselyTypes.push("Insertable");
+                }
+                if (methods.some((m) => m.meta.kind === "update")) {
+                    kyselyTypes.push("Updateable");
+                }
+                // Selectable would be used for explicit return types, but we use returningAll()
+                if (kyselyTypes.length > 0) {
+                    file.import({
+                        kind: "package",
+                        types: kyselyTypes,
+                        from: "kysely",
+                    });
+                }
+                // Only import DB if dbAsParameter is true
+                const dbImportTypes = parsed.dbAsParameter ? [dbTypeName, entityName] : [entityName];
+                file.import({
+                    kind: "relative",
+                    types: dbImportTypes,
+                    from: resolvedConfig.dbTypesPath,
+                });
+                const stmts = toStatements(methods, exportStyle, entityName);
+                file.ast(conjure.program(...stmts)).emit();
+                const pkType = entity.primaryKey
+                    ? getFieldTypeString(findRowField(entity, entity.primaryKey.columns[0]), genCtx)
+                    : "unknown";
+                ctx.symbols.registerEntityMethods({
+                    entity: entityName,
+                    importPath: filePath,
+                    pkType,
+                    hasCompositePk: (entity.primaryKey?.columns.length ?? 0) > 1,
+                    methods: methods.map(m => ({
+                        name: m.meta.name,
+                        file: filePath,
+                        entity: entityName,
+                        kind: m.meta.kind,
+                        params: m.meta.params.map(p => ({
+                            name: p.name,
+                            type: p.type,
+                            required: p.required,
+                            columnName: p.columnName,
+                            source: p.source,
+                        })),
+                        returns: m.meta.returns,
+                        lookupField: m.meta.lookupField,
+                        isUniqueLookup: m.meta.isUniqueLookup,
+                        callSignature: m.meta.callSignature,
+                    })),
+                }, "kysely");
+            }
+        },
+    });
+}
+//# sourceMappingURL=kysely.js.map