@typokit/db-raw 0.1.4

package/src/index.test.ts

@@ -0,0 +1,486 @@
+import { describe, it, expect } from "@rstest/core";
+import { RawSqlDatabaseAdapter, parseUnionValues } from "./index.js";
+import type { SchemaTypeMap } from "@typokit/types";
+import type { DatabaseState } from "@typokit/core";
+
+describe("RawSqlDatabaseAdapter", () => {
+  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 RawSqlDatabaseAdapter({ dialect: "postgresql" });
+
+    it("should generate SQL DDL 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);
+      // SQL file + types file
+      expect(outputs.length).toBeGreaterThanOrEqual(2);
+
+      const sqlOutput = outputs.find((o) => o.filePath.endsWith(".sql"));
+      expect(sqlOutput).toBeDefined();
+      expect(sqlOutput!.filePath).toBe("sql/users.sql");
+      expect(sqlOutput!.overwrite).toBe(true);
+
+      const content = sqlOutput!.content;
+
+      // Header
+      expect(content).toContain("-- AUTO-GENERATED by @typokit/db-raw");
+
+      // CREATE TYPE for enum
+      expect(content).toContain("CREATE TYPE user_status AS ENUM");
+      expect(content).toContain("'active', 'suspended', 'deleted'");
+
+      // CREATE TABLE
+      expect(content).toContain("CREATE TABLE users");
+
+      // Columns
+      expect(content).toContain(
+        "id UUID NOT NULL PRIMARY KEY DEFAULT gen_random_uuid()",
+      );
+      expect(content).toContain("email VARCHAR(255) NOT NULL UNIQUE");
+      expect(content).toContain("display_name VARCHAR(100) NOT NULL");
+      expect(content).toContain("user_status NOT NULL DEFAULT 'active'");
+      expect(content).toContain(
+        "created_at TIMESTAMPTZ NOT NULL DEFAULT now()",
+      );
+      expect(content).toContain(
+        "updated_at TIMESTAMPTZ NOT NULL DEFAULT now()",
+      );
+    });
+
+    it("should generate TypeScript interfaces", () => {
+      const types: SchemaTypeMap = {
+        User: {
+          name: "User",
+          jsdoc: { table: "users" },
+          properties: {
+            id: {
+              type: "string",
+              optional: false,
+              jsdoc: { id: "", generated: "uuid" },
+            },
+            email: { type: "string", optional: false },
+            displayName: { type: "string", optional: false },
+            bio: { type: "string", optional: true },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      const tsOutput = outputs.find((o) => o.filePath.endsWith(".ts"));
+      expect(tsOutput).toBeDefined();
+      expect(tsOutput!.filePath).toBe("sql/types.ts");
+
+      const content = tsOutput!.content;
+      expect(content).toContain("export interface User {");
+      expect(content).toContain("id: string;");
+      expect(content).toContain("email: string;");
+      expect(content).toContain("displayName: string;");
+      expect(content).toContain("bio?: string;");
+    });
+
+    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);
+      const sqlOutput = outputs.find((o) => o.filePath.endsWith(".sql"));
+      const content = sqlOutput!.content;
+
+      expect(content).toContain("id UUID");
+      expect(content).toContain("name TEXT NOT NULL");
+      expect(content).toContain("price INTEGER NOT NULL");
+      expect(content).toContain("stock BIGINT NOT NULL");
+      expect(content).toContain("active BOOLEAN NOT NULL");
+      expect(content).toContain("metadata JSONB");
+      expect(content).toContain("description TEXT");
+
+      // Optional fields do NOT have NOT NULL
+      expect(content).not.toMatch(/metadata JSONB NOT NULL/);
+      expect(content).not.toMatch(/description TEXT NOT 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);
+      const sqlOutput = outputs.find((o) => o.filePath.endsWith(".sql"));
+      expect(sqlOutput!.content).toContain("CREATE TABLE custom_accounts");
+      expect(sqlOutput!.filePath).toBe("sql/custom_accounts.sql");
+    });
+
+    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);
+      const sqlOutput = outputs.find((o) => o.filePath.endsWith(".sql"));
+      expect(sqlOutput!.content).toContain("CREATE TABLE categories");
+    });
+
+    it("should generate CREATE TYPE for string union types", () => {
+      const types: SchemaTypeMap = {
+        Order: {
+          name: "Order",
+          properties: {
+            status: {
+              type: '"pending" | "shipped" | "delivered"',
+              optional: false,
+            },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      const sqlOutput = outputs.find((o) => o.filePath.endsWith(".sql"));
+      const content = sqlOutput!.content;
+      expect(content).toContain("CREATE TYPE order_status AS ENUM");
+      expect(content).toContain("'pending', 'shipped', 'delivered'");
+    });
+
+    it("should handle @default with numeric values", () => {
+      const types: SchemaTypeMap = {
+        Config: {
+          name: "Config",
+          properties: {
+            retryCount: {
+              type: "number",
+              optional: false,
+              jsdoc: { default: "3" },
+            },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      const sqlOutput = outputs.find((o) => o.filePath.endsWith(".sql"));
+      expect(sqlOutput!.content).toContain("DEFAULT 3");
+    });
+  });
+
+  describe("generate() - SQLite", () => {
+    const adapter = new RawSqlDatabaseAdapter({ dialect: "sqlite" });
+
+    it("should generate SQLite DDL", () => {
+      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);
+      const sqlOutput = outputs.find((o) => o.filePath.endsWith(".sql"));
+      const content = sqlOutput!.content;
+
+      expect(content).toContain("CREATE TABLE users");
+      expect(content).toContain("id TEXT NOT NULL PRIMARY KEY");
+      expect(content).toContain("name TEXT NOT NULL");
+      expect(content).toContain("age INTEGER NOT NULL");
+      expect(content).toContain("active INTEGER NOT NULL");
+
+      // No CREATE TYPE in SQLite
+      expect(content).not.toContain("CREATE TYPE");
+    });
+
+    it("should handle enum unions as TEXT in SQLite", () => {
+      const types: SchemaTypeMap = {
+        Order: {
+          name: "Order",
+          properties: {
+            status: {
+              type: '"pending" | "shipped"',
+              optional: false,
+            },
+          },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      const sqlOutput = outputs.find((o) => o.filePath.endsWith(".sql"));
+      expect(sqlOutput!.content).toContain("status TEXT NOT NULL");
+    });
+  });
+
+  describe("diff()", () => {
+    const adapter = new RawSqlDatabaseAdapter({ 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 with DESTRUCTIVE comment", () => {
+      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);
+      expect(draft.sql).toContain("-- DESTRUCTIVE: requires review");
+      expect(draft.sql).toContain('DROP COLUMN "old_col"');
+    });
+
+    it("should detect removed tables with DESTRUCTIVE comment", () => {
+      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("-- DESTRUCTIVE: requires review");
+      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 with ALTER TABLE", () => {
+      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 RawSqlDatabaseAdapter({ outputDir: "db/schema" });
+      const types: SchemaTypeMap = {
+        Item: {
+          name: "Item",
+          properties: { id: { type: "string", optional: false } },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      expect(outputs[0].filePath).toContain("db/schema/");
+    });
+
+    it("should default to postgresql dialect", () => {
+      const adapter = new RawSqlDatabaseAdapter();
+      const types: SchemaTypeMap = {
+        Item: {
+          name: "Item",
+          properties: { id: { type: "string", optional: false } },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      const sqlOutput = outputs.find((o) => o.filePath.endsWith(".sql"));
+      expect(sqlOutput!.content).toContain("CREATE TABLE");
+      // PostgreSQL uses TEXT for bare strings
+      expect(sqlOutput!.content).toContain("TEXT");
+    });
+
+    it("should default to sql output directory", () => {
+      const adapter = new RawSqlDatabaseAdapter();
+      const types: SchemaTypeMap = {
+        Item: {
+          name: "Item",
+          properties: { id: { type: "string", optional: false } },
+        },
+      };
+
+      const outputs = adapter.generate(types);
+      expect(outputs[0].filePath).toContain("sql/");
+    });
+  });
+});