@typokit/db-kysely 0.1.4

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import type { SchemaTypeMap, GeneratedOutput, MigrationDraft } from "@typokit/types";
+import type { DatabaseAdapter, DatabaseState } from "@typokit/core";
+export type KyselyDialect = "postgresql" | "sqlite";
+export interface KyselyAdapterOptions {
+    dialect?: KyselyDialect;
+    outputDir?: string;
+}
+/** Parse string union type like `"a" | "b" | "c"` into values */
+export declare function parseUnionValues(typeStr: string): string[] | null;
+export declare class KyselyDatabaseAdapter implements DatabaseAdapter {
+    private readonly dialect;
+    private readonly outputDir;
+    constructor(options?: KyselyAdapterOptions);
+    generate(types: SchemaTypeMap): GeneratedOutput[];
+    diff(types: SchemaTypeMap, currentState: DatabaseState): MigrationDraft;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EAEb,eAAe,EACf,cAAc,EAEf,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEpE,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,QAAQ,CAAC;AAEpD,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA4BD,iEAAiE;AACjE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAYjE;AAuQD,qBAAa,qBAAsB,YAAW,eAAe;IAC3D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEvB,OAAO,CAAC,EAAE,oBAAoB;IAK1C,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,eAAe,EAAE;IAMjD,IAAI,CAAC,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,GAAG,cAAc;CAgBxE"}

package/dist/index.js

@@ -0,0 +1,264 @@
+// ─── Helpers ─────────────────────────────────────────────────
+function toSnakeCase(str) {
+    return str
+        .replace(/([A-Z])/g, (_, letter, index) => index === 0 ? letter.toLowerCase() : `_${letter.toLowerCase()}`)
+        .replace(/__+/g, "_");
+}
+function pluralize(str) {
+    if (str.endsWith("s"))
+        return str;
+    if (str.endsWith("y") && !/[aeiou]y$/i.test(str))
+        return str.slice(0, -1) + "ies";
+    return str + "s";
+}
+function toTableName(typeName, jsdoc) {
+    if (jsdoc?.table)
+        return jsdoc.table;
+    return pluralize(toSnakeCase(typeName));
+}
+function toColumnName(propName) {
+    return toSnakeCase(propName);
+}
+/** Parse string union type like `"a" | "b" | "c"` into values */
+export function parseUnionValues(typeStr) {
+    const trimmed = typeStr.trim();
+    if (!trimmed.includes("|"))
+        return null;
+    const parts = trimmed.split("|").map((p) => p.trim());
+    const values = [];
+    for (const part of parts) {
+        const match = /^"([^"]*)"$/.exec(part);
+        if (!match)
+            return null;
+        values.push(match[1]);
+    }
+    return values.length > 0 ? values : null;
+}
+// ─── PostgreSQL Column Type Mapping ─────────────────────────
+function mapPgColumnType(prop) {
+    const jsdoc = prop.jsdoc ?? {};
+    const unionValues = parseUnionValues(prop.type);
+    let baseType;
+    if (unionValues) {
+        baseType = unionValues.map((v) => `"${v}"`).join(" | ");
+    }
+    else if (prop.type === "string") {
+        baseType = "string";
+    }
+    else if (prop.type === "number") {
+        baseType = "number";
+    }
+    else if (prop.type === "bigint") {
+        baseType = "number";
+    }
+    else if (prop.type === "boolean") {
+        baseType = "boolean";
+    }
+    else if (prop.type === "Date") {
+        baseType = "Date";
+    }
+    else {
+        // object, Record, unknown → unknown (JSON)
+        baseType = "unknown";
+    }
+    // Wrap with Generated<T> if auto-generated
+    const isGenerated = jsdoc.generated !== undefined;
+    const hasDefault = jsdoc.default !== undefined;
+    if (isGenerated || hasDefault) {
+        return `Generated<${baseType}>`;
+    }
+    return baseType;
+}
+// ─── SQLite Column Type Mapping ─────────────────────────────
+function mapSqliteColumnType(prop) {
+    const jsdoc = prop.jsdoc ?? {};
+    let baseType;
+    if (prop.type === "number" || prop.type === "bigint") {
+        baseType = "number";
+    }
+    else if (prop.type === "boolean") {
+        baseType = "number";
+    }
+    else if (prop.type === "Date") {
+        baseType = "string";
+    }
+    else if (prop.type === "object" ||
+        prop.type.startsWith("Record<") ||
+        parseUnionValues(prop.type)) {
+        baseType = "string";
+    }
+    else {
+        baseType = "string";
+    }
+    const isGenerated = jsdoc.generated !== undefined;
+    const hasDefault = jsdoc.default !== undefined;
+    if (isGenerated || hasDefault) {
+        return `Generated<${baseType}>`;
+    }
+    return baseType;
+}
+// ─── Code Generation ────────────────────────────────────────
+function generateTableInterface(typeName, meta, dialect) {
+    const mapFn = dialect === "postgresql" ? mapPgColumnType : mapSqliteColumnType;
+    let needsGenerated = false;
+    const columns = [];
+    for (const [propName, prop] of Object.entries(meta.properties)) {
+        const colName = toColumnName(propName);
+        const tsType = mapFn(prop);
+        if (tsType.startsWith("Generated<"))
+            needsGenerated = true;
+        columns.push({ colName, tsType, optional: prop.optional });
+    }
+    const interfaceName = `${typeName}Table`;
+    let code = `export interface ${interfaceName} {\n`;
+    for (const col of columns) {
+        const nullSuffix = col.optional ? " | null" : "";
+        code += `  ${col.colName}: ${col.tsType}${nullSuffix};\n`;
+    }
+    code += "}\n";
+    return { interfaceName, code, needsGenerated };
+}
+function generateFile(types, dialect) {
+    const tableInterfaces = [];
+    let needsGenerated = false;
+    for (const [typeName, meta] of Object.entries(types)) {
+        const tableName = toTableName(typeName, meta.jsdoc);
+        const result = generateTableInterface(typeName, meta, dialect);
+        if (result.needsGenerated)
+            needsGenerated = true;
+        tableInterfaces.push({
+            tableName,
+            interfaceName: result.interfaceName,
+            code: result.code,
+        });
+    }
+    let content = `// AUTO-GENERATED by @typokit/db-kysely\n`;
+    content += `// Do not edit manually — modify the source type instead\n\n`;
+    if (needsGenerated) {
+        content += `import type { Generated } from "kysely";\n\n`;
+    }
+    // Emit table interfaces
+    for (const ti of tableInterfaces) {
+        content += ti.code + "\n";
+    }
+    // Emit Database interface
+    content += `export interface Database {\n`;
+    for (const ti of tableInterfaces) {
+        content += `  ${ti.tableName}: ${ti.interfaceName};\n`;
+    }
+    content += "}\n";
+    return {
+        filePath: `database.ts`,
+        content,
+        overwrite: true,
+    };
+}
+// ─── Diff Logic ─────────────────────────────────────────────
+function diffTypes(types, currentState) {
+    const changes = [];
+    for (const [typeName, meta] of Object.entries(types)) {
+        const tableName = toTableName(typeName, meta.jsdoc);
+        const existing = currentState.tables[tableName];
+        if (!existing) {
+            changes.push({ type: "add", entity: tableName });
+            continue;
+        }
+        for (const [propName, prop] of Object.entries(meta.properties)) {
+            const colName = toColumnName(propName);
+            const existingCol = existing.columns[colName];
+            if (!existingCol) {
+                changes.push({
+                    type: "add",
+                    entity: tableName,
+                    field: colName,
+                    details: { tsType: prop.type },
+                });
+            }
+            else {
+                const nullable = prop.optional;
+                if (existingCol.nullable !== nullable) {
+                    changes.push({
+                        type: "modify",
+                        entity: tableName,
+                        field: colName,
+                        details: {
+                            nullableFrom: existingCol.nullable,
+                            nullableTo: nullable,
+                        },
+                    });
+                }
+            }
+        }
+        // Detect removed columns
+        for (const colName of Object.keys(existing.columns)) {
+            const hasProp = Object.keys(meta.properties).some((p) => toColumnName(p) === colName);
+            if (!hasProp) {
+                changes.push({ type: "remove", entity: tableName, field: colName });
+            }
+        }
+    }
+    // Detect removed tables
+    for (const tableName of Object.keys(currentState.tables)) {
+        const hasType = Object.entries(types).some(([name, meta]) => toTableName(name, meta.jsdoc) === tableName);
+        if (!hasType) {
+            changes.push({ type: "remove", entity: tableName });
+        }
+    }
+    return changes;
+}
+function generateMigrationSql(changes, dialect) {
+    const lines = [];
+    for (const change of changes) {
+        if (change.type === "add" && !change.field) {
+            lines.push(`-- TODO: CREATE TABLE "${change.entity}" (define columns)`);
+        }
+        else if (change.type === "add" && change.field) {
+            lines.push(`ALTER TABLE "${change.entity}" ADD COLUMN "${change.field}" TEXT;`);
+        }
+        else if (change.type === "remove" && !change.field) {
+            lines.push(`DROP TABLE IF EXISTS "${change.entity}";`);
+        }
+        else if (change.type === "remove" && change.field) {
+            if (dialect === "postgresql") {
+                lines.push(`ALTER TABLE "${change.entity}" DROP COLUMN "${change.field}";`);
+            }
+            else {
+                lines.push(`-- SQLite: cannot DROP COLUMN "${change.field}" from "${change.entity}" — recreate table`);
+            }
+        }
+        else if (change.type === "modify") {
+            lines.push(`-- TODO: ALTER TABLE "${change.entity}" modify column "${change.field}"`);
+        }
+    }
+    return lines.join("\n");
+}
+// ─── Adapter ────────────────────────────────────────────────
+export class KyselyDatabaseAdapter {
+    dialect;
+    outputDir;
+    constructor(options) {
+        this.dialect = options?.dialect ?? "postgresql";
+        this.outputDir = options?.outputDir ?? "kysely";
+    }
+    generate(types) {
+        const output = generateFile(types, this.dialect);
+        output.filePath = `${this.outputDir}/${output.filePath}`;
+        return [output];
+    }
+    diff(types, currentState) {
+        const changes = diffTypes(types, currentState);
+        const destructive = changes.some((c) => c.type === "remove");
+        const sql = generateMigrationSql(changes, this.dialect);
+        const timestamp = new Date()
+            .toISOString()
+            .replace(/[-:T]/g, "")
+            .slice(0, 14);
+        return {
+            name: `${timestamp}_schema_update`,
+            sql,
+            destructive,
+            changes,
+        };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@typokit/db-kysely",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "version": "0.1.4",
+  "type": "module",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@typokit/types": "0.1.4",
+    "@typokit/core": "0.1.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KyleBastien/typokit",
+    "directory": "packages/db-kysely"
+  },
+  "scripts": {
+    "test": "rstest run --passWithNoTests"
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,435 @@
+import { describe, it, expect } from "@rstest/core";
+import { KyselyDatabaseAdapter, parseUnionValues } from "./index.js";
+import type { SchemaTypeMap } from "@typokit/types";
+import type { DatabaseState } from "@typokit/core";
+
+describe("KyselyDatabaseAdapter", () => {
+  describe("parseUnionValues", () => {
+    it("should parse string union types", () => {
+      const values = parseUnionValues('"active" | "suspended" | "deleted"');
+      expect(values).toEqual(["active", "suspended", "deleted"]);
+    });
+
+    it("should return null for non-union types", () => {
+      expect(parseUnionValues("string")).toBeNull();
+      expect(parseUnionValues("number")).toBeNull();
+    });
+
+    it("should return null for mixed unions", () => {
+      expect(parseUnionValues('"a" | number')).toBeNull();
+    });
+  });
+
+  describe("generate() - PostgreSQL", () => {
+    const adapter = new KyselyDatabaseAdapter({ dialect: "postgresql" });
+
+    it("should generate Kysely types from User type", () => {
+      const types: SchemaTypeMap = {
+        User: {
+          name: "User",
+          jsdoc: { table: "users" },
+          properties: {
+            id: {
+              type: "string",
+              optional: false,
+              jsdoc: { id: "", generated: "uuid" },
+            },
+            email: {
+              type: "string",
+              optional: false,
+              jsdoc: { format: "email", unique: "" },
+            },
+            displayName: {
+              type: "string",
+              optional: false,
+              jsdoc: { maxLength: "100" },
+            },
+            status: {
+              type: '"active" | "suspended" | "deleted"',
+              optional: false,
+              jsdoc: { default: "active" },
+            },
+            createdAt: {
+              type: "Date",
+              optional: false,
+              jsdoc: { generated: "now" },
+            },
+            updatedAt: {
+              type: "Date",
+              optional: false,
+              jsdoc: { onUpdate: "now" },
+            },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      expect(outputs).toHaveLength(1);
+
+      const output = outputs[0];
+      expect(output.filePath).toBe("kysely/database.ts");
+      expect(output.overwrite).toBe(true);
+
+      const content = output.content;
+
+      // Header
+      expect(content).toContain("// AUTO-GENERATED by @typokit/db-kysely");
+
+      // Generated import
+      expect(content).toContain('import type { Generated } from "kysely"');
+
+      // Table interface
+      expect(content).toContain("export interface UserTable");
+
+      // Columns — id is Generated<string> (auto-generated uuid)
+      expect(content).toContain("id: Generated<string>");
+
+      // email is plain string
+      expect(content).toContain("email: string;");
+
+      // displayName → display_name is plain string
+      expect(content).toContain("display_name: string;");
+
+      // status is Generated<union> (has default)
+      expect(content).toContain(
+        'status: Generated<"active" | "suspended" | "deleted">',
+      );
+
+      // createdAt → created_at is Generated<Date>
+      expect(content).toContain("created_at: Generated<Date>");
+
+      // updatedAt → updated_at is plain Date (onUpdate is not a generation)
+      expect(content).toContain("updated_at: Date;");
+
+      // Database interface
+      expect(content).toContain("export interface Database");
+      expect(content).toContain("users: UserTable;");
+    });
+
+    it("should handle all supported column types", () => {
+      const types: SchemaTypeMap = {
+        Product: {
+          name: "Product",
+          properties: {
+            id: {
+              type: "string",
+              optional: false,
+              jsdoc: { id: "", generated: "uuid" },
+            },
+            name: { type: "string", optional: false },
+            price: { type: "number", optional: false },
+            stock: { type: "bigint", optional: false },
+            active: { type: "boolean", optional: false },
+            metadata: { type: "Record<string, unknown>", optional: true },
+            description: { type: "string", optional: true },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      expect(outputs).toHaveLength(1);
+      const content = outputs[0].content;
+
+      expect(content).toContain("id: Generated<string>");
+      expect(content).toContain("name: string;");
+      expect(content).toContain("price: number;");
+      expect(content).toContain("stock: number;");
+      expect(content).toContain("active: boolean;");
+      expect(content).toContain("metadata: unknown | null;");
+      expect(content).toContain("description: string | null;");
+    });
+
+    it("should use @table JSDoc tag for table name", () => {
+      const types: SchemaTypeMap = {
+        UserAccount: {
+          name: "UserAccount",
+          jsdoc: { table: "custom_accounts" },
+          properties: {
+            id: { type: "string", optional: false, jsdoc: { id: "" } },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      expect(outputs[0].content).toContain(
+        "custom_accounts: UserAccountTable;",
+      );
+    });
+
+    it("should pluralize table names from type names", () => {
+      const types: SchemaTypeMap = {
+        Category: {
+          name: "Category",
+          properties: {
+            id: { type: "string", optional: false, jsdoc: { id: "" } },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      expect(outputs[0].content).toContain("categories: CategoryTable;");
+    });
+
+    it("should handle string union types in PostgreSQL", () => {
+      const types: SchemaTypeMap = {
+        Order: {
+          name: "Order",
+          properties: {
+            status: {
+              type: '"pending" | "shipped" | "delivered"',
+              optional: false,
+            },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      const content = outputs[0].content;
+      expect(content).toContain('"pending" | "shipped" | "delivered"');
+    });
+
+    it("should handle @default with Generated wrapper", () => {
+      const types: SchemaTypeMap = {
+        Config: {
+          name: "Config",
+          properties: {
+            retryCount: {
+              type: "number",
+              optional: false,
+              jsdoc: { default: "3" },
+            },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      expect(outputs[0].content).toContain("retry_count: Generated<number>");
+    });
+  });
+
+  describe("generate() - SQLite", () => {
+    const adapter = new KyselyDatabaseAdapter({ dialect: "sqlite" });
+
+    it("should generate SQLite Kysely types", () => {
+      const types: SchemaTypeMap = {
+        User: {
+          name: "User",
+          jsdoc: { table: "users" },
+          properties: {
+            id: { type: "string", optional: false, jsdoc: { id: "" } },
+            name: { type: "string", optional: false },
+            age: { type: "number", optional: false },
+            active: { type: "boolean", optional: false },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      expect(outputs).toHaveLength(1);
+      const content = outputs[0].content;
+
+      // SQLite maps boolean → number, Date → string
+      expect(content).toContain("id: string;");
+      expect(content).toContain("name: string;");
+      expect(content).toContain("age: number;");
+      expect(content).toContain("active: number;");
+    });
+
+    it("should map Date to string in SQLite", () => {
+      const types: SchemaTypeMap = {
+        Event: {
+          name: "Event",
+          properties: {
+            createdAt: {
+              type: "Date",
+              optional: false,
+              jsdoc: { generated: "now" },
+            },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      expect(outputs[0].content).toContain("created_at: Generated<string>");
+    });
+  });
+
+  describe("diff()", () => {
+    const adapter = new KyselyDatabaseAdapter({ dialect: "postgresql" });
+
+    it("should detect new tables", () => {
+      const types: SchemaTypeMap = {
+        User: {
+          name: "User",
+          jsdoc: { table: "users" },
+          properties: {
+            id: { type: "string", optional: false },
+          },
+        },
+      };
+      const state: DatabaseState = { tables: {} };
+
+      const draft = adapter.diff(types, state);
+      expect(draft.changes).toHaveLength(1);
+      expect(draft.changes[0]).toEqual({ type: "add", entity: "users" });
+      expect(draft.destructive).toBe(false);
+    });
+
+    it("should detect new columns", () => {
+      const types: SchemaTypeMap = {
+        User: {
+          name: "User",
+          jsdoc: { table: "users" },
+          properties: {
+            id: { type: "string", optional: false },
+            email: { type: "string", optional: false },
+          },
+        },
+      };
+      const state: DatabaseState = {
+        tables: {
+          users: {
+            columns: {
+              id: { type: "text", nullable: false },
+            },
+          },
+        },
+      };
+
+      const draft = adapter.diff(types, state);
+      expect(draft.changes).toHaveLength(1);
+      expect(draft.changes[0].type).toBe("add");
+      expect(draft.changes[0].field).toBe("email");
+    });
+
+    it("should detect removed columns", () => {
+      const types: SchemaTypeMap = {
+        User: {
+          name: "User",
+          jsdoc: { table: "users" },
+          properties: {
+            id: { type: "string", optional: false },
+          },
+        },
+      };
+      const state: DatabaseState = {
+        tables: {
+          users: {
+            columns: {
+              id: { type: "text", nullable: false },
+              old_col: { type: "text", nullable: true },
+            },
+          },
+        },
+      };
+
+      const draft = adapter.diff(types, state);
+      expect(draft.changes).toHaveLength(1);
+      expect(draft.changes[0]).toEqual({
+        type: "remove",
+        entity: "users",
+        field: "old_col",
+      });
+      expect(draft.destructive).toBe(true);
+    });
+
+    it("should detect removed tables", () => {
+      const types: SchemaTypeMap = {};
+      const state: DatabaseState = {
+        tables: {
+          old_table: { columns: { id: { type: "text", nullable: false } } },
+        },
+      };
+
+      const draft = adapter.diff(types, state);
+      expect(draft.changes).toHaveLength(1);
+      expect(draft.changes[0]).toEqual({ type: "remove", entity: "old_table" });
+      expect(draft.destructive).toBe(true);
+      expect(draft.sql).toContain("DROP TABLE");
+    });
+
+    it("should detect nullable changes", () => {
+      const types: SchemaTypeMap = {
+        User: {
+          name: "User",
+          jsdoc: { table: "users" },
+          properties: {
+            email: { type: "string", optional: true },
+          },
+        },
+      };
+      const state: DatabaseState = {
+        tables: {
+          users: {
+            columns: {
+              email: { type: "text", nullable: false },
+            },
+          },
+        },
+      };
+
+      const draft = adapter.diff(types, state);
+      expect(draft.changes).toHaveLength(1);
+      expect(draft.changes[0].type).toBe("modify");
+    });
+
+    it("should generate migration SQL", () => {
+      const types: SchemaTypeMap = {
+        User: {
+          name: "User",
+          jsdoc: { table: "users" },
+          properties: {
+            id: { type: "string", optional: false },
+            newField: { type: "string", optional: false },
+          },
+        },
+      };
+      const state: DatabaseState = {
+        tables: {
+          users: {
+            columns: {
+              id: { type: "text", nullable: false },
+            },
+          },
+        },
+      };
+
+      const draft = adapter.diff(types, state);
+      expect(draft.sql).toContain(
+        'ALTER TABLE "users" ADD COLUMN "new_field" TEXT;',
+      );
+      expect(draft.name).toMatch(/^\d{14}_schema_update$/);
+    });
+  });
+
+  describe("constructor options", () => {
+    it("should use custom output directory", () => {
+      const adapter = new KyselyDatabaseAdapter({ outputDir: "db/types" });
+      const types: SchemaTypeMap = {
+        Item: {
+          name: "Item",
+          properties: { id: { type: "string", optional: false } },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      expect(outputs[0].filePath).toContain("db/types/");
+    });
+
+    it("should default to postgresql dialect", () => {
+      const adapter = new KyselyDatabaseAdapter();
+      const types: SchemaTypeMap = {
+        Item: {
+          name: "Item",
+          properties: {
+            active: { type: "boolean", optional: false },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      // PostgreSQL maps boolean to boolean, not number
+      expect(outputs[0].content).toContain("active: boolean;");
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,351 @@
+// @typokit/db-kysely — Kysely Type Generation
+import type {
+  SchemaTypeMap,
+  TypeMetadata,
+  GeneratedOutput,
+  MigrationDraft,
+  SchemaChange,
+} from "@typokit/types";
+import type { DatabaseAdapter, DatabaseState } from "@typokit/core";
+
+export type KyselyDialect = "postgresql" | "sqlite";
+
+export interface KyselyAdapterOptions {
+  dialect?: KyselyDialect;
+  outputDir?: string;
+}
+
+// ─── Helpers ─────────────────────────────────────────────────
+
+function toSnakeCase(str: string): string {
+  return str
+    .replace(/([A-Z])/g, (_, letter, index) =>
+      index === 0 ? letter.toLowerCase() : `_${letter.toLowerCase()}`,
+    )
+    .replace(/__+/g, "_");
+}
+
+function pluralize(str: string): string {
+  if (str.endsWith("s")) return str;
+  if (str.endsWith("y") && !/[aeiou]y$/i.test(str))
+    return str.slice(0, -1) + "ies";
+  return str + "s";
+}
+
+function toTableName(typeName: string, jsdoc?: Record<string, string>): string {
+  if (jsdoc?.table) return jsdoc.table;
+  return pluralize(toSnakeCase(typeName));
+}
+
+function toColumnName(propName: string): string {
+  return toSnakeCase(propName);
+}
+
+/** Parse string union type like `"a" | "b" | "c"` into values */
+export function parseUnionValues(typeStr: string): string[] | null {
+  const trimmed = typeStr.trim();
+  if (!trimmed.includes("|")) return null;
+
+  const parts = trimmed.split("|").map((p) => p.trim());
+  const values: string[] = [];
+  for (const part of parts) {
+    const match = /^"([^"]*)"$/.exec(part);
+    if (!match) return null;
+    values.push(match[1]);
+  }
+  return values.length > 0 ? values : null;
+}
+
+// ─── PostgreSQL Column Type Mapping ─────────────────────────
+
+function mapPgColumnType(prop: {
+  type: string;
+  optional: boolean;
+  jsdoc?: Record<string, string>;
+}): string {
+  const jsdoc = prop.jsdoc ?? {};
+  const unionValues = parseUnionValues(prop.type);
+
+  let baseType: string;
+
+  if (unionValues) {
+    baseType = unionValues.map((v) => `"${v}"`).join(" | ");
+  } else if (prop.type === "string") {
+    baseType = "string";
+  } else if (prop.type === "number") {
+    baseType = "number";
+  } else if (prop.type === "bigint") {
+    baseType = "number";
+  } else if (prop.type === "boolean") {
+    baseType = "boolean";
+  } else if (prop.type === "Date") {
+    baseType = "Date";
+  } else {
+    // object, Record, unknown → unknown (JSON)
+    baseType = "unknown";
+  }
+
+  // Wrap with Generated<T> if auto-generated
+  const isGenerated = jsdoc.generated !== undefined;
+  const hasDefault = jsdoc.default !== undefined;
+  if (isGenerated || hasDefault) {
+    return `Generated<${baseType}>`;
+  }
+
+  return baseType;
+}
+
+// ─── SQLite Column Type Mapping ─────────────────────────────
+
+function mapSqliteColumnType(prop: {
+  type: string;
+  optional: boolean;
+  jsdoc?: Record<string, string>;
+}): string {
+  const jsdoc = prop.jsdoc ?? {};
+
+  let baseType: string;
+
+  if (prop.type === "number" || prop.type === "bigint") {
+    baseType = "number";
+  } else if (prop.type === "boolean") {
+    baseType = "number";
+  } else if (prop.type === "Date") {
+    baseType = "string";
+  } else if (
+    prop.type === "object" ||
+    prop.type.startsWith("Record<") ||
+    parseUnionValues(prop.type)
+  ) {
+    baseType = "string";
+  } else {
+    baseType = "string";
+  }
+
+  const isGenerated = jsdoc.generated !== undefined;
+  const hasDefault = jsdoc.default !== undefined;
+  if (isGenerated || hasDefault) {
+    return `Generated<${baseType}>`;
+  }
+
+  return baseType;
+}
+
+// ─── Code Generation ────────────────────────────────────────
+
+function generateTableInterface(
+  typeName: string,
+  meta: TypeMetadata,
+  dialect: KyselyDialect,
+): { interfaceName: string; code: string; needsGenerated: boolean } {
+  const mapFn =
+    dialect === "postgresql" ? mapPgColumnType : mapSqliteColumnType;
+  let needsGenerated = false;
+
+  const columns: Array<{ colName: string; tsType: string; optional: boolean }> =
+    [];
+
+  for (const [propName, prop] of Object.entries(meta.properties)) {
+    const colName = toColumnName(propName);
+    const tsType = mapFn(prop);
+    if (tsType.startsWith("Generated<")) needsGenerated = true;
+    columns.push({ colName, tsType, optional: prop.optional });
+  }
+
+  const interfaceName = `${typeName}Table`;
+
+  let code = `export interface ${interfaceName} {\n`;
+  for (const col of columns) {
+    const nullSuffix = col.optional ? " | null" : "";
+    code += `  ${col.colName}: ${col.tsType}${nullSuffix};\n`;
+  }
+  code += "}\n";
+
+  return { interfaceName, code, needsGenerated };
+}
+
+function generateFile(
+  types: SchemaTypeMap,
+  dialect: KyselyDialect,
+): GeneratedOutput {
+  const tableInterfaces: Array<{
+    tableName: string;
+    interfaceName: string;
+    code: string;
+  }> = [];
+  let needsGenerated = false;
+
+  for (const [typeName, meta] of Object.entries(types)) {
+    const tableName = toTableName(typeName, meta.jsdoc);
+    const result = generateTableInterface(typeName, meta, dialect);
+    if (result.needsGenerated) needsGenerated = true;
+    tableInterfaces.push({
+      tableName,
+      interfaceName: result.interfaceName,
+      code: result.code,
+    });
+  }
+
+  let content = `// AUTO-GENERATED by @typokit/db-kysely\n`;
+  content += `// Do not edit manually — modify the source type instead\n\n`;
+
+  if (needsGenerated) {
+    content += `import type { Generated } from "kysely";\n\n`;
+  }
+
+  // Emit table interfaces
+  for (const ti of tableInterfaces) {
+    content += ti.code + "\n";
+  }
+
+  // Emit Database interface
+  content += `export interface Database {\n`;
+  for (const ti of tableInterfaces) {
+    content += `  ${ti.tableName}: ${ti.interfaceName};\n`;
+  }
+  content += "}\n";
+
+  return {
+    filePath: `database.ts`,
+    content,
+    overwrite: true,
+  };
+}
+
+// ─── Diff Logic ─────────────────────────────────────────────
+
+function diffTypes(
+  types: SchemaTypeMap,
+  currentState: DatabaseState,
+): SchemaChange[] {
+  const changes: SchemaChange[] = [];
+
+  for (const [typeName, meta] of Object.entries(types)) {
+    const tableName = toTableName(typeName, meta.jsdoc);
+    const existing = currentState.tables[tableName];
+
+    if (!existing) {
+      changes.push({ type: "add", entity: tableName });
+      continue;
+    }
+
+    for (const [propName, prop] of Object.entries(meta.properties)) {
+      const colName = toColumnName(propName);
+      const existingCol = existing.columns[colName];
+
+      if (!existingCol) {
+        changes.push({
+          type: "add",
+          entity: tableName,
+          field: colName,
+          details: { tsType: prop.type },
+        });
+      } else {
+        const nullable = prop.optional;
+        if (existingCol.nullable !== nullable) {
+          changes.push({
+            type: "modify",
+            entity: tableName,
+            field: colName,
+            details: {
+              nullableFrom: existingCol.nullable,
+              nullableTo: nullable,
+            },
+          });
+        }
+      }
+    }
+
+    // Detect removed columns
+    for (const colName of Object.keys(existing.columns)) {
+      const hasProp = Object.keys(meta.properties).some(
+        (p) => toColumnName(p) === colName,
+      );
+      if (!hasProp) {
+        changes.push({ type: "remove", entity: tableName, field: colName });
+      }
+    }
+  }
+
+  // Detect removed tables
+  for (const tableName of Object.keys(currentState.tables)) {
+    const hasType = Object.entries(types).some(
+      ([name, meta]) => toTableName(name, meta.jsdoc) === tableName,
+    );
+    if (!hasType) {
+      changes.push({ type: "remove", entity: tableName });
+    }
+  }
+
+  return changes;
+}
+
+function generateMigrationSql(
+  changes: SchemaChange[],
+  dialect: KyselyDialect,
+): string {
+  const lines: string[] = [];
+
+  for (const change of changes) {
+    if (change.type === "add" && !change.field) {
+      lines.push(`-- TODO: CREATE TABLE "${change.entity}" (define columns)`);
+    } else if (change.type === "add" && change.field) {
+      lines.push(
+        `ALTER TABLE "${change.entity}" ADD COLUMN "${change.field}" TEXT;`,
+      );
+    } else if (change.type === "remove" && !change.field) {
+      lines.push(`DROP TABLE IF EXISTS "${change.entity}";`);
+    } else if (change.type === "remove" && change.field) {
+      if (dialect === "postgresql") {
+        lines.push(
+          `ALTER TABLE "${change.entity}" DROP COLUMN "${change.field}";`,
+        );
+      } else {
+        lines.push(
+          `-- SQLite: cannot DROP COLUMN "${change.field}" from "${change.entity}" — recreate table`,
+        );
+      }
+    } else if (change.type === "modify") {
+      lines.push(
+        `-- TODO: ALTER TABLE "${change.entity}" modify column "${change.field}"`,
+      );
+    }
+  }
+
+  return lines.join("\n");
+}
+
+// ─── Adapter ────────────────────────────────────────────────
+
+export class KyselyDatabaseAdapter implements DatabaseAdapter {
+  private readonly dialect: KyselyDialect;
+  private readonly outputDir: string;
+
+  constructor(options?: KyselyAdapterOptions) {
+    this.dialect = options?.dialect ?? "postgresql";
+    this.outputDir = options?.outputDir ?? "kysely";
+  }
+
+  generate(types: SchemaTypeMap): GeneratedOutput[] {
+    const output = generateFile(types, this.dialect);
+    output.filePath = `${this.outputDir}/${output.filePath}`;
+    return [output];
+  }
+
+  diff(types: SchemaTypeMap, currentState: DatabaseState): MigrationDraft {
+    const changes = diffTypes(types, currentState);
+    const destructive = changes.some((c) => c.type === "remove");
+    const sql = generateMigrationSql(changes, this.dialect);
+    const timestamp = new Date()
+      .toISOString()
+      .replace(/[-:T]/g, "")
+      .slice(0, 14);
+
+    return {
+      name: `${timestamp}_schema_update`,
+      sql,
+      destructive,
+      changes,
+    };
+  }
+}