@danielfgray/pg-sourcerer 0.3.0 → 0.5.0

package/dist/plugins/kysely.js

@@ -1,55 +1,38 @@
 /**
- * Kysely Plugin - Generate Kysely-compatible types and query functions
+ * Kysely Plugin - Unified Kysely 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
+ * 1. Kysely-compatible type definitions (DB interface, table types with Generated<T>)
+ * 2. Type-safe CRUD query functions using Kysely's fluent API
  *
- * @example
- * ```typescript
- * import { kysely } from "pg-sourcerer"
- *
- * export default defineConfig({
- *   plugins: [
- *     kysely({
- *       outputDir: "db",
- *       generateQueries: true,
- *     }),
- *   ],
- * })
- * ```
+ * This plugin is incompatible with other type-generation plugins (types, zod, etc.)
+ * since it provides its own type definitions optimized for Kysely.
  */
-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;
+import { Effect } from "effect";
+import { Schema as S } from "effect";
+import { normalizeFileNaming } from "../runtime/file-assignment.js";
+import { IR } from "../services/ir.js";
+import { Inflection } from "../services/inflection.js";
+import { getTableEntities, getEnumEntities, getCompositeEntities, getCursorPaginationCandidates, } from "../ir/semantic-ir.js";
+import { conjure, cast } from "../conjure/index.js";
+const { fn, stmt, ts, param, str, exp, b, chain, arrExpr } = conjure;
+// ============================================================================
+// Configuration
+// ============================================================================
 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 }),
+    /** Generate query functions (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),
+    /** If true, db is passed as first parameter; if false, imported via dbImport */
+    dbAsParameter: S.optionalWith(S.Boolean, { default: () => false }),
+    /** Default limit for list queries (default: 50) */
     defaultLimit: S.optionalWith(S.Number, { default: () => 50 }),
 });
+// ============================================================================
+// Kysely Type Helpers (ported from kysely-codegen)
+// ============================================================================
+/**
+ * Helper type definitions to be emitted in the types file.
+ */
 const GENERATED_TYPE_DEF = `T extends ColumnType<infer S, infer I, infer U>
   ? ColumnType<S, I | undefined, U>
   : ColumnType<T, T | undefined, T>`;
@@ -59,13 +42,21 @@ const ARRAY_TYPE_DEF = `ArrayTypeImpl<T> extends (infer U)[]
 const ARRAY_TYPE_IMPL_DEF = `T extends ColumnType<infer S, infer I, infer U>
   ? ColumnType<S[], I[], U[]>
   : T[]`;
+// ============================================================================
+// PostgreSQL Type Mappings
+// ============================================================================
+/** Simple scalar types: PG type → TS type builder */
 const SCALAR_TYPES = {
+    // Boolean
     bool: ts.boolean,
+    boolean: ts.boolean,
+    // Integers → number
     int2: ts.number,
     int4: ts.number,
     float4: ts.number,
     float8: ts.number,
     oid: ts.number,
+    // Text types → string
     text: ts.string,
     varchar: ts.string,
     bpchar: ts.string,
@@ -74,35 +65,46 @@ const SCALAR_TYPES = {
     bit: ts.string,
     varbit: ts.string,
     xml: ts.string,
+    citext: ts.string,
+    // UUID → string
     uuid: ts.string,
+    // Network types → string
     inet: ts.string,
     cidr: ts.string,
     macaddr: ts.string,
     macaddr8: ts.string,
+    // Geometric types → string
     line: ts.string,
     lseg: ts.string,
     box: ts.string,
     path: ts.string,
     polygon: ts.string,
+    // Time without date → string
     time: ts.string,
     timetz: ts.string,
+    // Full-text search → string
     tsvector: ts.string,
     tsquery: ts.string,
     txid_snapshot: ts.string,
+    // Money → string
     money: ts.string,
+    // Binary → Buffer
     bytea: () => ts.ref("Buffer"),
 };
 const COMPLEX_TYPES = {
+    // int8/bigint: returns string, accepts string|number|bigint
     int8: {
         select: ts.string,
         insert: () => ts.union(ts.string(), ts.number(), ts.bigint()),
         update: () => ts.union(ts.string(), ts.number(), ts.bigint()),
     },
+    // numeric/decimal: returns string, accepts number|string
     numeric: {
         select: ts.string,
         insert: () => ts.union(ts.number(), ts.string()),
         update: () => ts.union(ts.number(), ts.string()),
     },
+    // Timestamps: returns Date, accepts Date|string
     date: {
         select: () => ts.ref("Date"),
         insert: () => ts.union(ts.ref("Date"), ts.string()),
@@ -118,11 +120,13 @@ const COMPLEX_TYPES = {
         insert: () => ts.union(ts.ref("Date"), ts.string()),
         update: () => ts.union(ts.ref("Date"), ts.string()),
     },
+    // Interval: string for now
     interval: {
         select: ts.string,
         insert: () => ts.union(ts.string(), ts.number()),
         update: () => ts.union(ts.string(), ts.number()),
     },
+    // JSON: JsonValue
     json: {
         select: () => ts.ref("JsonValue"),
         insert: () => ts.ref("JsonValue"),
@@ -133,6 +137,7 @@ const COMPLEX_TYPES = {
         insert: () => ts.ref("JsonValue"),
         update: () => ts.ref("JsonValue"),
     },
+    // Point: object with x, y
     point: {
         select: () => ts.objectType([
             { name: "x", type: ts.number() },
@@ -147,73 +152,34 @@ const COMPLEX_TYPES = {
             { 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) {
+/**
+ * Resolve a field to its Kysely type.
+ */
+function resolveFieldType(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,
-                };
-            }
+    // Check if it's an enum
+    if (pgType?.typtype === "e") {
+        const enumDef = ctx.enums.find(e => e.pgType.typname === typeName);
+        if (enumDef) {
+            return {
+                selectType: ts.ref(enumDef.name),
+                needsColumnType: false,
+            };
         }
     }
+    // Check if it's a composite type
     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 compositeDef = ctx.composites.find(c => c.pgType.typname === typeName);
+        if (compositeDef) {
+            return {
+                selectType: ts.ref(compositeDef.name),
+                needsColumnType: false,
+            };
         }
     }
+    // Check complex types (need ColumnType wrapper)
     const complexType = COMPLEX_TYPES[typeName];
     if (complexType) {
         return {
@@ -221,9 +187,9 @@ function resolveFieldTypeForKysely(field, ctx) {
             insertType: complexType.insert(),
             updateType: complexType.update(),
             needsColumnType: true,
-            externalImport: complexType.import,
         };
     }
+    // Check simple scalar types
     const scalarBuilder = SCALAR_TYPES[typeName];
     if (scalarBuilder) {
         return {
@@ -231,32 +197,51 @@ function resolveFieldTypeForKysely(field, ctx) {
             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,
-            };
-        }
-    }
+    // Default to string
     return {
         selectType: ts.string(),
         needsColumnType: false,
     };
 }
+/**
+ * Determine if a field should be wrapped in Generated<T>.
+ *
+ * A field needs Generated<T> wrapper (making it optional in Insertable<T>) if:
+ * 1. The role cannot insert this field (permission-denied → treat as if generated)
+ * 2. The field has a database default and is an identity/generated column
+ * 3. The field has a default that will be used if not provided
+ *
+ * This ensures Kysely's Insertable<T> aligns with IR insert shapes which
+ * exclude fields the role cannot insert.
+ */
+function isGeneratedField(field) {
+    // If role can't insert this field, make it optional in Insertable<T>
+    // This matches IR behavior where such fields are excluded from insert shape
+    if (!field.permissions.canInsert)
+        return true;
+    // Fields with any kind of default are optional on insert
+    // (identity columns, generated columns, or any DEFAULT value)
+    if (field.hasDefault)
+        return true;
+    if (field.isIdentity)
+        return true;
+    if (field.isGenerated)
+        return true;
+    return false;
+}
+/**
+ * Build the final field type with array/nullable/Generated wrappers.
+ */
 function buildFieldType(field, kyselyType, needsGenerated) {
     let baseType;
+    // If complex type, wrap in ColumnType<S, I, U>
     if (kyselyType.needsColumnType && kyselyType.insertType && kyselyType.updateType) {
-        baseType = ts.ref("ColumnType", [
-            kyselyType.selectType,
-            kyselyType.insertType,
-            kyselyType.updateType,
-        ]);
+        baseType = ts.ref("ColumnType", [kyselyType.selectType, kyselyType.insertType, kyselyType.updateType]);
     }
     else {
         baseType = kyselyType.selectType;
     }
+    // Wrap in array if needed
     if (field.isArray) {
         if (kyselyType.needsColumnType) {
             baseType = ts.ref("ArrayType", [baseType]);
@@ -265,363 +250,81 @@ function buildFieldType(field, kyselyType, needsGenerated) {
             baseType = ts.array(baseType);
         }
     }
+    // Wrap in nullable if needed
     if (field.nullable) {
-        baseType = ts.nullable(baseType);
+        baseType = ts.union(baseType, ts.null());
     }
+    // Wrap in Generated<T> if field has default and is not insertable
     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)
+// Type Generation
 // ============================================================================
-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");
+/**
+ * Generate enum type alias: `export type Status = "active" | "inactive"`
+ */
+function generateEnumType(enumEntity) {
+    return exp.typeAlias(enumEntity.name, { capability: "types:kysely", entity: enumEntity.name }, ts.union(...enumEntity.values.map(v => ts.literal(v)))).node;
+}
+/**
+ * Generate composite type interface.
+ */
+function generateCompositeInterface(composite, ctx) {
+    const properties = [];
+    for (const field of composite.fields) {
+        const kyselyType = resolveFieldType(field, ctx);
+        const fieldType = buildFieldType(field, kyselyType, false);
+        properties.push({ name: field.name, type: fieldType });
     }
-    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");
+    return exp.interface(composite.name, { capability: "types:kysely", entity: composite.name }, properties).node;
+}
+/**
+ * Generate table interface with all column types.
+ */
+function generateTableInterface(entity, ctx) {
+    const properties = [];
+    for (const field of entity.shapes.row.fields) {
+        if (!field.permissions.canSelect)
+            continue;
+        const kyselyType = resolveFieldType(field, ctx);
+        const needsGenerated = isGeneratedField(field);
+        const fieldType = buildFieldType(field, kyselyType, needsGenerated);
+        properties.push({ name: field.name, type: fieldType });
     }
-    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");
+    return exp.interface(entity.name, { capability: "types:kysely", entity: entity.name }, properties).node;
+}
+/**
+ * Generate DB interface: `export interface DB { table_name: TableType }`
+ */
+function generateDBInterface(entities, defaultSchemas) {
+    const properties = [];
+    for (const entity of entities) {
+        if (!entity.permissions.canSelect)
+            continue;
+        // Use schema-qualified key if not in default schema
+        const key = defaultSchemas.includes(entity.schemaName) ? entity.pgName : `${entity.schemaName}.${entity.pgName}`;
+        properties.push({ name: key, type: ts.ref(entity.name) });
     }
-    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;
+    // Sort by key for stable output
+    properties.sort((a, b) => a.name.localeCompare(b.name));
+    return exp.interface("DB", { capability: "types:kysely", entity: "DB" }, properties).node;
+}
+function collectTypeImports(entities, composites, ctx) {
+    let needsColumnType = false;
     let needsGenerated = false;
-    const processField = (field, schemaName, tableName, checkGenerated) => {
-        const kyselyType = resolveFieldTypeForKysely(field, {
-            ...ctx,
-            schemaName,
-            tableName,
-        });
+    let needsArrayType = false;
+    let needsJsonTypes = false;
+    const processField = (field, checkGenerated) => {
+        const pgType = field.pgAttribute.getType();
+        const typeName = pgType?.typname ?? "";
+        const kyselyType = resolveFieldType(field, ctx);
         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);
+            needsColumnType = true;
         }
-        // Note: Enum types are generated in the same file, no import needed
-        const pgType = field.pgAttribute.getType();
-        if (pgType?.typname === "json" || pgType?.typname === "jsonb") {
+        if (typeName === "json" || typeName === "jsonb") {
             needsJsonTypes = true;
         }
         if (field.isArray && kyselyType.needsColumnType) {
@@ -637,270 +340,706 @@ const collectImports = (entities, composites, ctx) => {
         for (const field of entity.shapes.row.fields) {
             if (!field.permissions.canSelect)
                 continue;
-            processField(field, entity.schemaName, entity.pgName, true);
+            processField(field, true);
         }
     }
     for (const composite of composites) {
         for (const field of composite.fields) {
-            processField(field, composite.schemaName, composite.pgName, false);
+            processField(field, 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 { needsColumnType, needsGenerated, needsArrayType, needsJsonTypes };
+}
+/**
+ * Build the helper types header string.
+ */
+function buildTypesHeader(imports) {
+    const lines = [];
+    if (imports.needsGenerated) {
+        lines.push(`export type Generated<T> = ${GENERATED_TYPE_DEF};`);
     }
-    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,
-        });
+    if (imports.needsArrayType) {
+        lines.push(`export type ArrayType<T> = ${ARRAY_TYPE_DEF};`);
+        lines.push(`export type ArrayTypeImpl<T> = ${ARRAY_TYPE_IMPL_DEF};`);
     }
-    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),
-        });
+    if (imports.needsJsonTypes) {
+        lines.push(`export type JsonPrimitive = boolean | number | string | null;`);
+        lines.push(`export type JsonObject = { [x: string]: JsonValue | undefined };`);
+        lines.push(`export type JsonArray = JsonValue[];`);
+        lines.push(`export type JsonValue = JsonArray | JsonObject | JsonPrimitive;`);
     }
-    properties.sort((a, b) => a.name.localeCompare(b.name));
-    return exp.interface(dbTypeName, { capability: "types", entity: dbTypeName }, properties);
-};
+    return lines.join("\n\n");
+}
 // ============================================================================
-// Export Style Helpers (Queries)
+// Query Generation Helpers
 // ============================================================================
-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);
-};
+function buildColumnArray(fields) {
+    return conjure.arr(...fields.map(f => str(f.columnName))).build();
+}
+function buildQueryName(inflection, entityName, operation) {
+    return inflection.variableName(entityName, operation);
+}
+function buildFindByName(inflection, entityName, columnName) {
+    return inflection.variableName(entityName, `FindBy${inflection.pascalCase(columnName)}`);
+}
+function buildListByName(inflection, entityName, columnName) {
+    return inflection.variableName(entityName, `ListBy${inflection.pascalCase(columnName)}`);
+}
+function getPgType(field) {
+    const pgType = field.pgAttribute.getType();
+    return pgType?.typname ?? "unknown";
+}
+function pgTypeToTsType(pgType) {
+    const lower = pgType.toLowerCase();
+    if (["uuid", "text", "varchar", "char", "citext", "name"].includes(lower))
+        return "string";
+    if (["int2", "int4", "int8", "integer", "smallint", "bigint", "numeric", "decimal", "real", "float4", "float8"].includes(lower))
+        return "number";
+    if (["bool", "boolean"].includes(lower))
+        return "boolean";
+    if (["timestamp", "timestamptz", "date"].includes(lower))
+        return "Date";
+    if (["json", "jsonb"].includes(lower))
+        return "unknown";
+    return "string";
+}
+function buildPkParam(field) {
+    return {
+        name: field.name,
+        type: pgTypeToTsType(getPgType(field)),
+        required: true,
+        columnName: field.columnName,
+        source: "pk",
+    };
+}
+function buildLookupParam(field) {
+    return {
+        name: field.name,
+        type: pgTypeToTsType(getPgType(field)),
+        required: true,
+        columnName: field.columnName,
+        source: "lookup",
+    };
+}
+function buildBodyParam(entityName, shape) {
+    const wrapper = shape === "insert" ? "Insertable" : "Updateable";
+    return {
+        name: "data",
+        type: `${wrapper}<${entityName}>`,
+        wrapper,
+        entityType: entityName,
+        required: true,
+        source: "body",
+    };
+}
+function buildPaginationParams(defaultLimit) {
+    return [
+        { name: "limit", type: "number", required: false, defaultValue: defaultLimit, source: "pagination" },
+        { name: "offset", type: "number", required: false, defaultValue: 0, source: "pagination" },
+    ];
+}
+function buildReturnType(entityName, isArray, nullable) {
+    return {
+        type: entityName,
+        nullable,
+        isArray,
+    };
+}
+function isBodyParam(p) {
+    return "wrapper" in p;
+}
+function isPaginationParam(p) {
+    return "defaultValue" in p;
+}
+function buildParamType(p) {
+    if (isBodyParam(p)) {
+        return ts.ref(p.wrapper, [ts.ref(p.entityType)]);
+    }
+    return ts.ref(p.type);
+}
+function buildDestructuredParam(params) {
+    return param.destructured(params.map(p => ({
+        name: p.name,
+        type: buildParamType(p),
+        optional: "required" in p ? p.required === false : false,
+        defaultValue: isPaginationParam(p) ? conjure.num(p.defaultValue) : undefined,
+    })));
+}
 // ============================================================================
-// Main Generation Function
+// Plugin Definition
 // ============================================================================
+/**
+ * Kysely plugin - generates Kysely-compatible types and query functions.
+ *
+ * Capabilities provided:
+ * - `types:kysely:DB` - the DB interface
+ * - `types:kysely:EntityName` - table/composite interfaces
+ * - `queries:kysely:EntityName:operation` - CRUD query functions
+ */
 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`;
+    // Parse schema-validated options
+    const schemaConfig = S.decodeSync(KyselyConfigSchema)(config ?? {});
+    // Debug logging
+    // Resolve file naming
+    // typesFile is always a single static path (all types in one file)
+    // queriesFile can be dynamic per-entity
     const resolvedConfig = {
-        ...parsed,
-        dbTypesPath,
-        exportName: parsed.exportName ?? defaultExportName,
+        ...schemaConfig,
+        typesFile: config?.typesFile ?? "db.ts",
+        queriesFile: normalizeFileNaming(config?.queriesFile, "queries.ts"),
+        dbImport: config?.dbImport,
     };
-    return definePlugin({
+    return {
         name: "kysely",
-        kind: "queries",
-        singleton: true,
-        canProvide: () => true,
-        provide: (_params, _deps, ctx) => {
-            const { ir, typeHints } = ctx;
+        provides: ["queries"],
+        consumes: [],
+        fileDefaults: [
+            {
+                // All types go to a single file
+                pattern: "types:kysely:",
+                fileNaming: () => resolvedConfig.typesFile,
+            },
+            {
+                pattern: "queries:kysely:",
+                fileNaming: resolvedConfig.queriesFile,
+            },
+        ],
+        declare: Effect.gen(function* () {
+            const ir = yield* IR;
+            const inflection = yield* Inflection;
+            const declarations = [];
             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 = [];
+            // Declare types
             for (const enumEntity of enumEntities) {
                 if (enumEntity.tags.omit === true)
                     continue;
-                statements.push(generateEnumStatement(enumEntity));
+                declarations.push({
+                    name: enumEntity.name,
+                    capability: `types:kysely:${enumEntity.name}`,
+                });
             }
             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",
+                declarations.push({
+                    name: composite.name,
+                    capability: `types:kysely:${composite.name}`,
                 });
             }
-            for (const [from, names] of imports.externalImports) {
-                dbFile.import({
-                    kind: "relative",
-                    types: [...names],
-                    from,
+            for (const entity of tableEntities) {
+                declarations.push({
+                    name: entity.name,
+                    capability: `types:kysely:${entity.name}`,
                 });
             }
-            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};`);
+            declarations.push({
+                name: "DB",
+                capability: "types:kysely:DB",
+            });
+            // Declare queries if enabled
+            if (resolvedConfig.generateQueries) {
+                for (const entity of tableEntities) {
+                    const entityName = entity.name;
+                    let hasAnyMethods = false;
+                    if (entity.permissions.canSelect && entity.primaryKey && entity.primaryKey.columns.length > 0) {
+                        hasAnyMethods = true;
+                        declarations.push({
+                            name: buildQueryName(inflection, entityName, "FindById"),
+                            capability: `queries:kysely:${entityName}:findById`,
+                            dependsOn: [`types:kysely:${entityName}`],
+                        });
+                    }
+                    // listByCursor for indexed timestamptz columns
+                    const cursorCandidates = getCursorPaginationCandidates(entity);
+                    for (const candidate of cursorCandidates) {
+                        const listByName = buildListByName(inflection, entityName, candidate.cursorColumnName);
+                        const pascalColumn = inflection.pascalCase(candidate.cursorColumnName);
+                        hasAnyMethods = true;
+                        declarations.push({
+                            name: listByName,
+                            capability: `queries:kysely:${entityName}:listBy${pascalColumn}`,
+                            dependsOn: [`types:kysely:${entityName}`],
+                        });
+                    }
+                    if (entity.kind === "table" && entity.permissions.canInsert && entity.shapes.insert) {
+                        hasAnyMethods = true;
+                        declarations.push({
+                            name: buildQueryName(inflection, entityName, "Create"),
+                            capability: `queries:kysely:${entityName}:create`,
+                            dependsOn: [`types:kysely:${entityName}`],
+                        });
+                    }
+                    if (entity.kind === "table" &&
+                        entity.permissions.canUpdate &&
+                        entity.shapes.update &&
+                        entity.primaryKey &&
+                        entity.primaryKey.columns.length > 0) {
+                        hasAnyMethods = true;
+                        declarations.push({
+                            name: buildQueryName(inflection, entityName, "Update"),
+                            capability: `queries:kysely:${entityName}:update`,
+                            dependsOn: [`types:kysely:${entityName}`],
+                        });
+                    }
+                    if (entity.kind === "table" &&
+                        entity.permissions.canDelete &&
+                        entity.primaryKey &&
+                        entity.primaryKey.columns.length > 0) {
+                        hasAnyMethods = true;
+                        declarations.push({
+                            name: buildQueryName(inflection, entityName, "Delete"),
+                            capability: `queries:kysely:${entityName}:delete`,
+                            dependsOn: [`types:kysely:${entityName}`],
+                        });
+                    }
+                    // findBy queries for indexed columns
+                    if (entity.permissions.canSelect) {
+                        const pkColumns = new Set(entity.primaryKey?.columns ?? []);
+                        const processedColumns = new Set();
+                        for (const index of entity.indexes) {
+                            if (index.isPartial || index.hasExpressions || index.columns.length !== 1)
+                                continue;
+                            if (index.method === "gin" || index.method === "gist")
+                                continue;
+                            const columnName = index.columns[0];
+                            if (pkColumns.has(columnName))
+                                continue;
+                            if (processedColumns.has(columnName))
+                                continue;
+                            processedColumns.add(columnName);
+                            const findByName = buildFindByName(inflection, entityName, columnName);
+                            const pascalColumn = inflection.pascalCase(columnName);
+                            hasAnyMethods = true;
+                            declarations.push({
+                                name: findByName,
+                                capability: `queries:kysely:${entityName}:findBy${pascalColumn}`,
+                                dependsOn: [`types:kysely:${entityName}`],
+                            });
+                        }
+                    }
+                    if (hasAnyMethods) {
+                        declarations.push({
+                            name: `${entityName}Queries`,
+                            capability: `queries:kysely:${entityName}`,
+                        });
+                    }
+                }
             }
-            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;`);
+            return declarations;
+        }),
+        render: Effect.gen(function* () {
+            const ir = yield* IR;
+            const inflection = yield* Inflection;
+            const symbols = [];
+            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 typeCtx = {
+                enums: enumEntities,
+                composites: compositeEntities,
+            };
+            // Collect imports for types
+            const typeImports = collectTypeImports(tableEntities, compositeEntities, typeCtx);
+            // Build kysely imports for types file
+            const kyselyTypeImports = [];
+            if (typeImports.needsColumnType) {
+                kyselyTypeImports.push("ColumnType");
             }
-            if (helperTypes.length > 0) {
-                dbFile.header(helperTypes.join("\n\n"));
+            const typesHeader = buildTypesHeader(typeImports);
+            const typesExternalImports = kyselyTypeImports.length > 0 ? [{ from: "kysely", types: kyselyTypeImports }] : [];
+            // Generate enum types
+            for (const enumEntity of enumEntities) {
+                if (enumEntity.tags.omit === true)
+                    continue;
+                symbols.push({
+                    name: enumEntity.name,
+                    capability: `types:kysely:${enumEntity.name}`,
+                    node: generateEnumType(enumEntity),
+                    exports: "named",
+                    externalImports: typesExternalImports,
+                    fileHeader: typesHeader,
+                });
             }
-            dbFile.ast(conjure.symbolProgram(...statements)).emit();
-            // ================================================================
-            // Generate Queries
-            // ================================================================
-            if (!parsed.generateQueries) {
-                return;
+            // Generate composite interfaces
+            for (const composite of compositeEntities) {
+                symbols.push({
+                    name: composite.name,
+                    capability: `types:kysely:${composite.name}`,
+                    node: generateCompositeInterface(composite, typeCtx),
+                    exports: "named",
+                    externalImports: typesExternalImports,
+                    fileHeader: typesHeader,
+                });
             }
-            const exportName = resolvedConfig.exportName;
-            const exportStyle = resolvedConfig.exportStyle;
+            // Generate table interfaces
             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",
+                symbols.push({
+                    name: entity.name,
+                    capability: `types:kysely:${entity.name}`,
+                    node: generateTableInterface(entity, typeCtx),
+                    exports: "named",
+                    externalImports: typesExternalImports,
+                    fileHeader: typesHeader,
+                });
+            }
+            // Generate DB interface
+            symbols.push({
+                name: "DB",
+                capability: "types:kysely:DB",
+                node: generateDBInterface(tableEntities, defaultSchemas),
+                exports: "named",
+                externalImports: typesExternalImports,
+                fileHeader: typesHeader,
+            });
+            // Generate queries if enabled
+            if (resolvedConfig.generateQueries) {
+                // User module imports for db instance (only if not using dbAsParameter)
+                const queryUserImports = !resolvedConfig.dbAsParameter && resolvedConfig.dbImport
+                    ? [resolvedConfig.dbImport]
+                    : undefined;
+                for (const entity of tableEntities) {
+                    const entityName = entity.name;
+                    const tableName = ir.schemas.includes(entity.schemaName)
+                        ? entity.pgName
+                        : `${entity.schemaName}.${entity.pgName}`;
+                    const entityMethods = [];
+                    // findById
+                    if (entity.permissions.canSelect && entity.primaryKey && entity.primaryKey.columns.length > 0) {
+                        const pkColumn = entity.primaryKey.columns[0];
+                        const pkField = entity.shapes.row.fields.find(f => f.columnName === pkColumn);
+                        const pkParam = buildPkParam(pkField);
+                        const method = {
+                            name: buildQueryName(inflection, entityName, "FindById"),
+                            kind: "read",
+                            params: [pkParam],
+                            returns: buildReturnType(entityName, false, true),
+                            callSignature: { style: "named" },
+                        };
+                        entityMethods.push(method);
+                        const queryExpr = chain(b.identifier("db"))
+                            .method("selectFrom", [str(tableName)])
+                            .method("select", [buildColumnArray(entity.shapes.row.fields)])
+                            .method("where", [
+                            str(pkColumn),
+                            str("="),
+                            b.identifier(pkField.name),
+                        ])
+                            .build();
+                        const destructuredParam = buildDestructuredParam([pkParam]);
+                        let fnBuilder = fn();
+                        if (resolvedConfig.dbAsParameter) {
+                            fnBuilder = fnBuilder.param("db", ts.ref("Kysely"));
+                        }
+                        const fnExpr = fnBuilder.rawParam(destructuredParam).arrow().body(stmt.return(queryExpr)).build();
+                        symbols.push({
+                            name: method.name,
+                            capability: `queries:kysely:${entityName}:findById`,
+                            node: exp.const(method.name, { capability: "", entity: entityName }, fnExpr).node,
+                            exports: "named",
+                            externalImports: resolvedConfig.dbAsParameter ? [{ from: "kysely", names: ["Kysely"] }] : [],
+                            userImports: queryUserImports,
+                        });
+                    }
+                    // listByCursor for indexed timestamptz columns
+                    const cursorCandidates = getCursorPaginationCandidates(entity);
+                    for (const candidate of cursorCandidates) {
+                        const pascalColumn = inflection.pascalCase(candidate.cursorColumnName);
+                        const pkField = entity.shapes.row.fields.find(f => f.name === candidate.pkColumn);
+                        if (!pkField)
+                            continue;
+                        const cursorType = ts.objectType([
+                            { name: candidate.cursorColumn, type: ts.ref("Date") },
+                            { name: candidate.pkColumn, type: ts.ref(pgTypeToTsType(getPgType(pkField))) },
+                        ]);
+                        const method = {
+                            name: buildListByName(inflection, entityName, candidate.cursorColumnName),
+                            kind: "list",
+                            params: [],
+                            returns: buildReturnType(entityName, true, false),
+                            callSignature: { style: "named" },
+                        };
+                        entityMethods.push(method);
+                        const cursorParam = param.destructured([
+                            { name: "cursor", type: ts.union(cursorType, ts.undefined()), optional: true },
+                            { name: "limit", type: ts.number(), optional: true, defaultValue: conjure.num(resolvedConfig.defaultLimit) },
+                        ]);
+                        const cursorComparisonOp = candidate.desc ? "<" : ">";
+                        const orderDirection = candidate.desc ? "desc" : "asc";
+                        const cursorCondition = b.callExpression(b.identifier("eb"), [
+                            str(candidate.cursorColumnName),
+                            str(cursorComparisonOp),
+                            b.memberExpression(b.identifier("cursor"), b.identifier(candidate.cursorColumn)),
+                        ]);
+                        const pkCondition = b.callExpression(b.identifier("eb"), [
+                            str(candidate.pkColumnName),
+                            str(cursorComparisonOp),
+                            b.memberExpression(b.identifier("cursor"), b.identifier(candidate.pkColumn)),
+                        ]);
+                        const equalityCondition = b.callExpression(b.identifier("eb"), [
+                            str(candidate.cursorColumnName),
+                            str("="),
+                            b.memberExpression(b.identifier("cursor"), b.identifier(candidate.cursorColumn)),
+                        ]);
+                        const andClause = chain(b.identifier("eb"))
+                            .method("and", [
+                            arrExpr(equalityCondition, pkCondition),
+                        ])
+                            .build();
+                        const whereClause = chain(b.identifier("eb"))
+                            .method("or", [
+                            arrExpr(cursorCondition, andClause),
+                        ])
+                            .build();
+                        const queryExpr = chain(b.identifier("db"))
+                            .method("selectFrom", [str(tableName)])
+                            .method("select", [buildColumnArray(entity.shapes.row.fields)])
+                            .method("$if", [
+                            b.binaryExpression("!==", b.identifier("cursor"), b.identifier("undefined")),
+                            fn()
+                                .param("qb")
+                                .arrow()
+                                .body(stmt.return(chain(b.identifier("qb"))
+                                .method("where", [b.arrowFunctionExpression([b.identifier("eb")], cast.toExpr(whereClause))])
+                                .build()))
+                                .build(),
+                        ])
+                            .method("orderBy", [str(candidate.cursorColumnName), str(orderDirection)])
+                            .method("orderBy", [str(candidate.pkColumnName), str(orderDirection)])
+                            .method("limit", [b.identifier("limit")])
+                            .build();
+                        let fnBuilder = fn();
+                        if (resolvedConfig.dbAsParameter) {
+                            fnBuilder = fnBuilder.param("db", ts.ref("Kysely"));
+                        }
+                        const fnExpr = fnBuilder.rawParam(cursorParam).arrow().body(stmt.return(queryExpr)).build();
+                        symbols.push({
+                            name: method.name,
+                            capability: `queries:kysely:${entityName}:listBy${pascalColumn}`,
+                            node: exp.const(method.name, { capability: "", entity: entityName }, fnExpr).node,
+                            exports: "named",
+                            externalImports: resolvedConfig.dbAsParameter ? [{ from: "kysely", names: ["Kysely"] }] : [],
+                            userImports: queryUserImports,
+                        });
+                    }
+                    // create
+                    if (entity.kind === "table" && entity.permissions.canInsert && entity.shapes.insert) {
+                        const bodyParam = buildBodyParam(entityName, "insert");
+                        const method = {
+                            name: buildQueryName(inflection, entityName, "Create"),
+                            kind: "create",
+                            params: [bodyParam],
+                            returns: buildReturnType(entityName, false, false),
+                            callSignature: { style: "named", bodyStyle: "spread" },
+                        };
+                        entityMethods.push(method);
+                        const queryExpr = chain(b.identifier("db"))
+                            .method("insertInto", [str(tableName)])
+                            .method("values", [b.identifier("data")])
+                            .method("returningAll", [])
+                            .build();
+                        // Simple typed parameter: (data: Insertable<Entity>)
+                        let fnBuilder = fn();
+                        if (resolvedConfig.dbAsParameter) {
+                            fnBuilder = fnBuilder.param("db", ts.ref("Kysely"));
+                        }
+                        const fnExpr = fnBuilder
+                            .param("data", ts.ref("Insertable", [ts.ref(entityName)]))
+                            .arrow()
+                            .body(stmt.return(queryExpr))
+                            .build();
+                        symbols.push({
+                            name: method.name,
+                            capability: `queries:kysely:${entityName}:create`,
+                            node: exp.const(method.name, { capability: "", entity: entityName }, fnExpr).node,
+                            exports: "named",
+                            externalImports: [
+                                {
+                                    from: "kysely",
+                                    names: resolvedConfig.dbAsParameter ? ["Kysely"] : [],
+                                    types: ["Insertable"],
+                                },
+                                {
+                                    from: resolvedConfig.typesFile,
+                                    types: [entityName],
+                                },
+                            ],
+                            userImports: queryUserImports,
+                        });
+                    }
+                    // update
+                    if (entity.kind === "table" &&
+                        entity.permissions.canUpdate &&
+                        entity.shapes.update &&
+                        entity.primaryKey &&
+                        entity.primaryKey.columns.length > 0) {
+                        const pkColumn = entity.primaryKey.columns[0];
+                        const pkField = entity.shapes.row.fields.find(f => f.columnName === pkColumn);
+                        const pkParam = buildPkParam(pkField);
+                        const bodyParam = buildBodyParam(entityName, "update");
+                        const method = {
+                            name: buildQueryName(inflection, entityName, "Update"),
+                            kind: "update",
+                            params: [pkParam, bodyParam],
+                            returns: buildReturnType(entityName, false, true),
+                            callSignature: { style: "named", bodyStyle: "spread" },
+                        };
+                        entityMethods.push(method);
+                        const queryExpr = chain(b.identifier("db"))
+                            .method("updateTable", [str(tableName)])
+                            .method("set", [b.identifier("data")])
+                            .method("where", [
+                            str(pkColumn),
+                            str("="),
+                            b.identifier(pkField.name),
+                        ])
+                            .method("returningAll", [])
+                            .build();
+                        // Use param.withRest for flat destructuring: ({ id, ...data }: { id: string } & Omit<Updateable<Entity>, 'id'>)
+                        // Using Omit ensures `data` doesn't include the PK field
+                        const destructuredParam = param.withRest([{ name: pkField.name, type: ts.ref(pkParam.type) }], "data", ts.ref("Omit", [
+                            ts.ref("Updateable", [ts.ref(entityName)]),
+                            ts.literal(pkField.name),
+                        ]));
+                        let fnBuilder = fn();
+                        if (resolvedConfig.dbAsParameter) {
+                            fnBuilder = fnBuilder.param("db", ts.ref("Kysely"));
+                        }
+                        const fnExpr = fnBuilder.rawParam(destructuredParam).arrow().body(stmt.return(queryExpr)).build();
+                        symbols.push({
+                            name: method.name,
+                            capability: `queries:kysely:${entityName}:update`,
+                            node: exp.const(method.name, { capability: "", entity: entityName }, fnExpr).node,
+                            exports: "named",
+                            externalImports: [
+                                {
+                                    from: "kysely",
+                                    names: resolvedConfig.dbAsParameter ? ["Kysely"] : [],
+                                    types: ["Updateable"],
+                                },
+                                {
+                                    from: resolvedConfig.typesFile,
+                                    types: [entityName],
+                                },
+                            ],
+                            userImports: queryUserImports,
+                        });
+                    }
+                    // delete
+                    if (entity.kind === "table" &&
+                        entity.permissions.canDelete &&
+                        entity.primaryKey &&
+                        entity.primaryKey.columns.length > 0) {
+                        const pkColumn = entity.primaryKey.columns[0];
+                        const pkField = entity.shapes.row.fields.find(f => f.columnName === pkColumn);
+                        const pkParam = buildPkParam(pkField);
+                        const method = {
+                            name: buildQueryName(inflection, entityName, "Delete"),
+                            kind: "delete",
+                            params: [pkParam],
+                            returns: buildReturnType(entityName, false, false),
+                            callSignature: { style: "named" },
+                        };
+                        entityMethods.push(method);
+                        const queryExpr = chain(b.identifier("db"))
+                            .method("deleteFrom", [str(tableName)])
+                            .method("where", [
+                            str(pkColumn),
+                            str("="),
+                            b.identifier(pkField.name),
+                        ])
+                            .build();
+                        const destructuredParam = buildDestructuredParam([pkParam]);
+                        let fnBuilder = fn();
+                        if (resolvedConfig.dbAsParameter) {
+                            fnBuilder = fnBuilder.param("db", ts.ref("Kysely"));
+                        }
+                        const fnExpr = fnBuilder.rawParam(destructuredParam).arrow().body(stmt.return(queryExpr)).build();
+                        symbols.push({
+                            name: method.name,
+                            capability: `queries:kysely:${entityName}:delete`,
+                            node: exp.const(method.name, { capability: "", entity: entityName }, fnExpr).node,
+                            exports: "named",
+                            externalImports: resolvedConfig.dbAsParameter ? [{ from: "kysely", names: ["Kysely"] }] : [],
+                            userImports: queryUserImports,
+                        });
+                    }
+                    // findBy queries for indexed columns
+                    if (entity.permissions.canSelect) {
+                        const pkColumns = new Set(entity.primaryKey?.columns ?? []);
+                        const processedColumns = new Set();
+                        for (const index of entity.indexes) {
+                            if (index.isPartial || index.hasExpressions || index.columns.length !== 1)
+                                continue;
+                            if (index.method === "gin" || index.method === "gist")
+                                continue;
+                            const columnName = index.columns[0];
+                            if (pkColumns.has(columnName))
+                                continue;
+                            if (processedColumns.has(columnName))
+                                continue;
+                            processedColumns.add(columnName);
+                            const field = entity.shapes.row.fields.find(f => f.columnName === columnName);
+                            if (!field)
+                                continue;
+                            const pascalColumn = inflection.pascalCase(columnName);
+                            const isUnique = index.isUnique;
+                            const lookupParam = buildLookupParam(field);
+                            const method = {
+                                name: buildFindByName(inflection, entityName, columnName),
+                                kind: "lookup",
+                                params: [lookupParam],
+                                returns: buildReturnType(entityName, !isUnique, isUnique),
+                                lookupField: field.name,
+                                isUniqueLookup: isUnique,
+                                callSignature: { style: "named" },
+                            };
+                            entityMethods.push(method);
+                            const queryExpr = chain(b.identifier("db"))
+                                .method("selectFrom", [str(tableName)])
+                                .method("select", [buildColumnArray(entity.shapes.row.fields)])
+                                .method("where", [
+                                str(columnName),
+                                str("="),
+                                b.identifier(field.name),
+                            ])
+                                .build();
+                            const destructuredParam = buildDestructuredParam([lookupParam]);
+                            let fnBuilder = fn();
+                            if (resolvedConfig.dbAsParameter) {
+                                fnBuilder = fnBuilder.param("db", ts.ref("Kysely"));
+                            }
+                            const fnExpr = fnBuilder.rawParam(destructuredParam).arrow().body(stmt.return(queryExpr)).build();
+                            symbols.push({
+                                name: method.name,
+                                capability: `queries:kysely:${entityName}:findBy${pascalColumn}`,
+                                node: exp.const(method.name, { capability: "", entity: entityName }, fnExpr).node,
+                                exports: "named",
+                                externalImports: resolvedConfig.dbAsParameter ? [{ from: "kysely", names: ["Kysely"] }] : [],
+                                userImports: queryUserImports,
+                            });
+                        }
+                    }
+                    // Entity queries metadata (no importPath - emit phase handles file resolution)
+                    const pkField = entity.primaryKey?.columns[0]
+                        ? entity.shapes.row.fields.find(f => f.columnName === entity.primaryKey.columns[0])
+                        : undefined;
+                    const entityExtension = {
+                        methods: entityMethods,
+                        pkType: pkField ? pgTypeToTsType(getPgType(pkField)) : undefined,
+                        hasCompositePk: (entity.primaryKey?.columns.length ?? 0) > 1,
+                    };
+                    symbols.push({
+                        name: `${entityName}Queries`,
+                        capability: `queries:kysely:${entityName}`,
+                        node: b.stringLiteral(""),
+                        metadata: entityExtension,
+                        exports: false,
                     });
                 }
-                // 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");
             }
-        },
-    });
+            return symbols;
+        }),
+    };
 }
 //# sourceMappingURL=kysely.js.map