import { describe, it, expect } from "vitest"; import { generateDrizzleSchema, camelToSnake } from "../src/drizzle-codegen.js"; import { defineSchema, validateSchema } from "@datafn/core"; function readSchemaExports(output: string): string[] { const match = output.match(/export const schema = \{ ([^}]+) \};/); return match ? match[1].split(", ") : []; } function expectedSchemaExports(names: string[]): string[] { return [ "__datafn_changes", "__datafn_idempotency", "__datafn_meta", "__datafn_seed", "datafnTimezoneChange", "kv", ...names, ].sort(); } function readTableBlock(output: string, tableName: string): string { const start = output.indexOf(`"${tableName}"`); if (start < 0) return ""; const tail = output.slice(start); const nextTable = tail.indexOf("\n\nexport const ", 1); return nextTable < 0 ? tail : tail.slice(0, nextTable); } describe("Drizzle Schema Codegen", () => { describe("TV-DRZ-PG-001: Generate Drizzle Schema - Postgres Full Types", () => { it("should generate correct Postgres schema with all field types", () => { const schema = { namespaced: false, resources: [ { name: "task", version: 1, fields: [ { name: "id", type: "string", required: true, unique: true }, { name: "title", type: "string", required: true }, { name: "done", type: "boolean", required: false, default: false }, { name: "priority", type: "number", required: false }, { name: "createdAt", type: "date", required: true }, { name: "metadata", type: "object", required: false }, { name: "tags", type: "array", required: false }, { name: "avatar", type: "file", required: false }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain('// Generated by @datafn/cli. DO NOT EDIT.'); expect(result).toContain('// Database: postgres'); expect(result).toContain('import { bigint, boolean, index, integer, jsonb, numeric, pgTable, text } from "drizzle-orm/pg-core";'); expect(result).toContain('export const task = pgTable("task", {'); expect(result).toContain(' avatar: text("avatar"),'); expect(result).toContain(' createdAt: bigint("created_at", { mode: "number" }).notNull(),'); expect(result).toContain(' done: boolean("done").default(false),'); expect(result).toContain(' id: text("id").primaryKey(),'); expect(result).toContain(' metadata: jsonb("metadata"),'); expect(result).toContain(' priority: numeric("priority"),'); expect(result).toContain(' tags: jsonb("tags"),'); expect(result).toContain(' title: text("title").notNull(),'); // kv is always included as a built-in resource expect(result).toContain('export const kv = pgTable("kv", {'); expect(readSchemaExports(result)).toEqual(expectedSchemaExports(["task"])); // kv table (id, value) appears before task table (alphabetical order) const lines = readTableBlock(result, "task").split('\n'); const fieldLines = lines.filter(line => line.trim().match(/^\w+:/)); const fieldNames = fieldLines.map(line => line.trim().split(':')[0]); expect(fieldNames).toEqual(['avatar', 'createdAt', 'done', 'id', 'metadata', 'priority', 'tags', 'title']); }); }); describe("TV-DRZ-MY-001: Generate Drizzle Schema - MySQL", () => { it("should generate correct MySQL schema", () => { const schema = { namespaced: false, resources: [ { name: "item", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "count", type: "number", required: true }, { name: "active", type: "boolean", required: true }, { name: "data", type: "object", required: false }, { name: "scheduledAt", type: "date", required: false }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "mysql"); expect(result).toContain('// Database: mysql'); expect(result).toContain('import { bigint, boolean, index, int, json, mysqlTable, text } from "drizzle-orm/mysql-core";'); expect(result).toContain('export const item = mysqlTable("item", {'); expect(result).toContain(' active: boolean("active").notNull(),'); expect(result).toContain(' count: int("count").notNull(),'); expect(result).toContain(' data: json("data"),'); expect(result).toContain(' id: text("id").primaryKey(),'); expect(result).toContain(' scheduledAt: bigint("scheduled_at", { mode: "number" }),'); // kv is always included as a built-in resource expect(result).toContain('export const kv = mysqlTable("kv", {'); expect(readSchemaExports(result)).toEqual(expectedSchemaExports(["item"])); }); }); describe("TV-DRZ-SL-001: Generate Drizzle Schema - SQLite", () => { it("should generate correct SQLite schema", () => { const schema = { namespaced: false, resources: [ { name: "item", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "count", type: "number", required: true }, { name: "active", type: "boolean", required: true }, { name: "data", type: "object", required: false }, { name: "scheduledAt", type: "date", required: false }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "sqlite"); expect(result).toContain('// Database: sqlite'); expect(result).toContain('import { customType, index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";'); expect(result).toContain('export const item = sqliteTable("item", {'); // SQLite drivers cannot bind booleans or objects, so those columns map values. expect(result).toContain('const datafnBoolean = customType<'); expect(result).toContain(' active: datafnBoolean("active").notNull(),'); expect(result).toContain(' count: integer("count").notNull(),'); expect(result).toContain(' data: text("data", { mode: "json" }),'); expect(result).toContain(' id: text("id").primaryKey(),'); expect(result).toContain(' scheduledAt: integer("scheduled_at"),'); // kv is always included as a built-in resource (sqlite stores JSON values as text) expect(result).toContain('export const kv = sqliteTable("kv", {'); expect(readSchemaExports(result)).toEqual(expectedSchemaExports(["item"])); }); }); describe("TV-DRZ-MOD-001: Field Modifiers", () => { it("should apply required, unique, and default modifiers correctly", () => { const schema = { namespaced: false, resources: [ { name: "user", version: 1, fields: [ { name: "id", type: "string", required: true, unique: true }, { name: "email", type: "string", required: true, unique: true }, { name: "name", type: "string", required: true }, { name: "role", type: "string", required: false, default: "member" }, { name: "score", type: "number", required: false, default: 0 }, { name: "verified", type: "boolean", required: true, default: false }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain(' email: text("email").notNull().unique(),'); expect(result).toContain(' id: text("id").primaryKey(),'); expect(result).toContain(' name: text("name").notNull(),'); expect(result).toContain(' role: text("role").default("member"),'); expect(result).toContain(' score: numeric("score").default(0),'); expect(result).toContain(' verified: boolean("verified").notNull().default(false),'); }); }); describe("legacy relation aliases", () => { it("uses foreignKey when fkField is absent", () => { const result = generateDrizzleSchema({ namespaced: false, resources: [ { name: "project", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "task", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [ { from: "task", to: "project", type: "many-one", relation: "project", foreignKey: "legacyProjectId", }, ], }, "postgres"); const taskTable = readTableBlock(result, "task"); expect(taskTable).toContain('legacyProjectId: text("legacy_project_id")'); expect(taskTable).not.toContain('projectId: text("project_id")'); }); }); describe("TV-DRZ-IDX-001: Index Generation", () => { it("should generate indices from indices.base", () => { const schema = { namespaced: false, resources: [ { name: "event", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "type", type: "string", required: true }, { name: "createdAt", type: "date", required: true }, { name: "userId", type: "string", required: true }, ], indices: { base: ["type", "createdAt"], search: ["type"] }, }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); // kv adds jsonb to the imports expect(result).toContain('import { bigint, index, integer, jsonb, numeric, pgTable, text } from "drizzle-orm/pg-core";'); expect(result).toContain('}, (table) => ['); expect(result).toContain(' index("event_type_idx").on(table.type),'); expect(result).toContain(' index("event_created_at_idx").on(table.createdAt),'); expect(result).toContain(']);'); }); }); describe("TV-DRZ-JOIN-001: Join Table Generation - Many-Many", () => { it("should generate join table for many-many relations", () => { const schema = { namespaced: false, resources: [ { name: "todos", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "text", type: "string", required: true }, ], }, { name: "categories", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "name", type: "string", required: true }, ], }, ], relations: [ { from: "todos", to: "categories", type: "many-many", relation: "tags" }, ], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain('export const __datafn_join_todos_tags = pgTable("__datafn_join_todos_tags", {'); expect(result).toContain(' from: text("from").notNull(),'); expect(result).toContain(' id: text("id").primaryKey(),'); expect(result).toContain(' to: text("to").notNull(),'); expect(result).toContain('}, (table) => ['); expect(result).toContain(' uniqueIndex("__datafn_join_todos_tags_from_to_idx").on(table.from, table.to),'); expect(result).toContain(']);'); expect(result).toContain('uniqueIndex'); // kv is always included as a built-in resource expect(result).toContain('export const kv = pgTable("kv", {'); expect(readSchemaExports(result)).toEqual(expectedSchemaExports(["__datafn_join_todos_tags", "categories", "todos"])); }); }); describe("TV-DRZ-JOIN-002: Join Table with Metadata and Custom Names", () => { it("should generate join table with metadata and custom names", () => { const schema = { namespaced: false, resources: [ { name: "users", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "roles", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [ { from: "users", to: "roles", type: "many-many", relation: "assignments", joinTable: "user_roles", joinColumns: { from: "userId", to: "roleId" }, metadata: [ { name: "grantedAt", type: "date" }, { name: "grantedBy", type: "string" }, ], }, ], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain('export const user_roles = pgTable("user_roles", {'); expect(result).toContain(' grantedAt: bigint("granted_at", { mode: "number" }),'); expect(result).toContain(' grantedBy: text("granted_by"),'); expect(result).toContain(' id: text("id").primaryKey(),'); expect(result).toContain(' roleId: text("role_id").notNull(),'); expect(result).toContain(' userId: text("user_id").notNull(),'); expect(result).toContain('}, (table) => ['); expect(result).toContain(' uniqueIndex("user_roles_user_id_role_id_idx").on(table.userId, table.roleId),'); expect(result).toContain(']);'); }); }); describe("TV-DRZ-REL-INTEGRITY-001: Relation Integrity DDL", () => { it("keeps namespaced set-null policies in application code", () => { const schema = { namespaced: true, relationIntegrity: "database", resources: [ { name: "project", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "task", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "projectId", type: "string", required: false }, ], }, ], relations: [ { from: "task", to: "project", type: "many-one", relation: "project", fkField: "projectId", onDelete: { to: "setNull" }, }, ], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain("foreignKey"); expect(result).toContain(' index("task_project_id_rel_idx").on(table.__ns, table.projectId),'); expect(result).toContain( ' foreignKey({ columns: [table.__ns, table.projectId], foreignColumns: [project.__ns, project.id] }),', ); expect(result).not.toContain('.onDelete("set null")'); }); it("should generate discriminator columns for polymorphic many-many relations", () => { const schema = { namespaced: false, relationIntegrity: "database", resources: [ { name: "node", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "objective", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "collection", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "tag", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [ { from: ["node", "objective"], to: ["collection", "tag"], type: "many-many", relation: "items", joinTable: "resource_items", }, ], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain('export const resource_items = pgTable("resource_items", {'); expect(result).toContain(' fromResource: text("from_resource").notNull(),'); expect(result).toContain(' toResource: text("to_resource").notNull(),'); expect(result).toContain( ' uniqueIndex("resource_items_from_to_idx").on(table.fromResource, table.from, table.toResource, table.to),', ); expect(result).toContain( ' index("resource_items_from_idx").on(table.fromResource, table.from),', ); expect(result).toContain( ' index("resource_items_to_idx").on(table.toResource, table.to),', ); expect(readTableBlock(result, "resource_items")).not.toContain("foreignKey"); }); it("should not duplicate discriminator columns when metadata already declares them", () => { const schema = { namespaced: false, resources: [ { name: "node", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "objective", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [ { from: ["node", "objective"], to: ["node", "objective"], type: "many-many", relation: "links", joinTable: "record_links", joinColumns: { from: "in", to: "out" }, metadata: [ { name: "fromResource", type: "string" }, { name: "toResource", type: "string" }, ], }, ], }; const result = generateDrizzleSchema(schema, "postgres"); const block = readTableBlock(result, "record_links"); expect(block.match(/fromResource:/g)).toHaveLength(1); expect(block.match(/toResource:/g)).toHaveLength(1); }); }); describe("TV-DRZ-COL-001: Column Name Convention", () => { it("should convert camelCase to snake_case for column names", () => { const schema = { namespaced: false, resources: [ { name: "profile", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "firstName", type: "string", required: true }, { name: "lastName", type: "string", required: true }, { name: "dateOfBirth", type: "date", required: false }, { name: "isActive", type: "boolean", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain(' dateOfBirth: bigint("date_of_birth", { mode: "number" }),'); expect(result).toContain(' firstName: text("first_name").notNull(),'); expect(result).toContain(' id: text("id").primaryKey(),'); expect(result).toContain(' isActive: boolean("is_active").notNull(),'); expect(result).toContain(' lastName: text("last_name").notNull(),'); }); it("camelToSnake helper should convert correctly", () => { expect(camelToSnake("id")).toBe("id"); expect(camelToSnake("firstName")).toBe("first_name"); expect(camelToSnake("createdAt")).toBe("created_at"); expect(camelToSnake("dateOfBirth")).toBe("date_of_birth"); expect(camelToSnake("isActive")).toBe("is_active"); }); }); describe("TV-DRZ-IMP-001: Import Tree-Shaking", () => { it("should only import used column types", () => { const schema = { namespaced: false, resources: [ { name: "note", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "content", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); // kv, temporal, and Datafn internal tables add jsonb/numeric/index/integer. expect(result).toContain('import { index, integer, jsonb, numeric, pgTable, text } from "drizzle-orm/pg-core";'); expect(result).not.toContain('boolean'); expect(result).not.toContain('bigint'); }); }); describe("TV-DRZ-DET-001: Deterministic Output", () => { it("should produce deterministic output with sorted resources and fields", () => { const schema = { namespaced: false, resources: [ { name: "zebra", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "alpha", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "middle", version: 1, fields: [ { name: "zField", type: "string", required: true }, { name: "aField", type: "number", required: false }, { name: "id", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); const alphaIndex = result.indexOf('export const alpha'); const middleIndex = result.indexOf('export const middle'); const zebraIndex = result.indexOf('export const zebra'); expect(alphaIndex).toBeLessThan(middleIndex); expect(middleIndex).toBeLessThan(zebraIndex); // kv is always included as a built-in resource; internal Datafn tables sort first. expect(readSchemaExports(result)).toEqual(expectedSchemaExports(["alpha", "middle", "zebra"])); const result2 = generateDrizzleSchema(schema, "postgres"); expect(result).toBe(result2); }); }); describe("Edge Cases", () => { it("should handle resources without indices (single-tenant)", () => { const schema = { namespaced: false, resources: [ { name: "simple", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); const simpleBlock = readTableBlock(result, "simple"); expect(simpleBlock).toContain('});'); expect(simpleBlock).not.toContain('(table) =>'); }); it("should handle many-many relations without metadata", () => { const schema = { namespaced: false, resources: [ { name: "a", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "b", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [ { from: "a", to: "b", type: "many-many", relation: "links" }, ], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain('export const __datafn_join_a_links'); expect(result).toContain(' from: text("from").notNull(),'); expect(result).toContain(' id: text("id").primaryKey(),'); expect(result).toContain(' to: text("to").notNull(),'); expect(result).toContain(' uniqueIndex("__datafn_join_a_links_from_to_idx").on(table.from, table.to),'); }); it("should generate uniqueIndex only on (from, to) even when metadata columns exist", () => { const schema = { namespaced: false, resources: [ { name: "students", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "courses", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [ { from: "students", to: "courses", type: "many-many", relation: "enrollments", metadata: [ { name: "grade", type: "string" }, { name: "enrolledAt", type: "date" }, ], }, ], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain(' uniqueIndex("__datafn_join_students_enrollments_from_to_idx").on(table.from, table.to),'); // uniqueIndex should NOT include metadata columns expect(result).not.toContain('table.grade'); expect(result).not.toContain('table.enrolledAt'); }); it("should include identity metadata columns in many-many uniqueIndex", () => { const schema = { namespaced: false, resources: [ { name: "nodes", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "records", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [ { from: "nodes", to: "records", type: "many-many", relation: "links", metadata: [ { name: "linkType", type: "string" }, { name: "location", type: "string" }, ], identityMetadata: ["linkType"], }, ], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain( 'uniqueIndex("__datafn_join_nodes_links_from_to_idx").on(table.from, table.to, table.linkType),', ); expect(result).not.toContain("table.location),"); }); it("should handle one-many and many-one relations (no join tables)", () => { const schema = { namespaced: false, resources: [ { name: "parent", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "child", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [ { from: "parent", to: "child", type: "one-many", relation: "children" }, ], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).not.toContain('__datafn_join'); // kv is always included as a built-in resource expect(readSchemaExports(result)).toEqual(expectedSchemaExports(["child", "parent"])); }); it("should sanitize variable names with hyphens", () => { const schema = { namespaced: false, resources: [ { name: "my-resource", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain('export const my_resource = pgTable("my-resource", {'); // kv is always included as a built-in resource expect(readSchemaExports(result)).toEqual(expectedSchemaExports(["my_resource"])); }); }); describe("TV-DRZ-KV-001: Built-in KV Table Generation", () => { it("should include the built-in kv table for postgres even when schema has no explicit kv resource", () => { const schema = { namespaced: false, resources: [ { name: "task", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "title", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain('export const kv = pgTable("kv", {'); expect(result).toContain(' id: text("id").primaryKey(),'); expect(result).toContain(' value: jsonb("value"),'); expect(result).toContain('import { index, integer, jsonb, numeric, pgTable, text } from "drizzle-orm/pg-core";'); expect(readSchemaExports(result)).toEqual(expectedSchemaExports(["task"])); }); it("should include the built-in kv table for mysql", () => { const schema = { namespaced: false, resources: [ { name: "item", version: 1, fields: [ { name: "id", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "mysql"); expect(result).toContain('export const kv = mysqlTable("kv", {'); expect(result).toContain(' id: text("id").primaryKey(),'); expect(result).toContain(' value: json("value"),'); expect(result).toContain('import { index, int, json, mysqlTable, text } from "drizzle-orm/mysql-core";'); expect(readSchemaExports(result)).toEqual(expectedSchemaExports(["item"])); }); it("stores sqlite boolean values as 0/1 and keeps E2EE envelopes as JSON text", () => { const schema = { namespaced: false, resources: [ { name: "item", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "active", type: "boolean", required: false, default: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "sqlite"); expect(result).toContain(' active: datafnBoolean("active").default(true),'); expect(result.indexOf("const datafnBoolean")).toBeLessThan(result.indexOf("export const item")); const helper = result.slice(result.indexOf("const datafnBoolean"), result.indexOf("});") + 3); // Evaluate the emitted mappings with a stub customType to check both directions. const typeScriptOnly = /customType<[^>]*>>?\(/; const config = new Function("customType", `return ${helper.replace(/^const datafnBoolean = /, "").replace(typeScriptOnly, "customType(")}`)( (definition: unknown) => definition, ) as { dataType(): string; toDriver(value: unknown): unknown; fromDriver(value: unknown): unknown; }; const envelope = { __datafnE2ee: 1, alg: "AES-GCM", keyRef: "k1", iv: "aXY=", data: "Y2lwaGVy" }; expect(config.dataType()).toBe("integer"); expect([config.toDriver(true), config.toDriver(false)]).toEqual([1, 0]); expect([config.fromDriver(1), config.fromDriver(0), config.fromDriver(0n)]).toEqual([true, false, false]); expect(config.fromDriver(config.toDriver(envelope))).toEqual(envelope); }); it("names the sql and customType imports and the sqlite boolean helper apart from resource and join-table exports", () => { const boolField = (name: string) => ({ name, type: "boolean", required: false }); const schema = { namespaced: false, resources: [ { name: "datafnBoolean", version: 1, fields: [{ name: "id", type: "string", required: true }, boolField("on")] }, { name: "customType", version: 1, fields: [{ name: "id", type: "string", required: true }, boolField("on")] }, { name: "sql", version: 1, fields: [ { name: "id", type: "string", required: true }, boolField("on"), { name: "meta", type: "object", required: false, default: { a: 1 } }, ], }, ], relations: [ { from: "datafnBoolean", to: "customType", type: "many-many", relation: "links", joinTable: "datafnBoolean_2", metadata: [boolField("pinned")], }, ], }; const result = generateDrizzleSchema(schema, "sqlite"); expect(result).toContain('import { customType as customType_2, index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";'); expect(result).toContain('import { sql as sql_2 } from "drizzle-orm";'); expect(result).toContain("const datafnBoolean_3 = customType_2<"); expect(result).toContain('export const datafnBoolean = sqliteTable("datafnBoolean", {'); expect(result).toContain('export const customType = sqliteTable("customType", {'); expect(result).toContain('export const sql = sqliteTable("sql", {'); expect(result).toContain('export const datafnBoolean_2 = sqliteTable("datafnBoolean_2", {'); expect(result.match(/ {2}on: datafnBoolean_3\("on"\),/g)).toHaveLength(3); expect(result).toContain(' pinned: datafnBoolean_3("pinned"),'); expect(result).toContain(` meta: text("meta", { mode: "json" }).default(sql_2.raw("'{\\"a\\":1}'")),`); expect(result).not.toMatch(/\bdatafnBoolean(_2)?\("/); expect(result).not.toMatch(/\bsql\.raw\(|import \{ sql \}/); }); it("emits sqlite JSON defaults as JSON text SQL literals", () => { const schema = { namespaced: false, resources: [ { name: "item", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "label", type: "json", required: false, default: "it's" }, { name: "flag", type: "json", required: false, default: true }, { name: "size", type: "json", required: false, default: 5 }, { name: "tags", type: "array", required: false, default: ["a"] }, { name: "extra", type: "object", required: false, default: null }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "sqlite"); expect(result).toContain('import { sql } from "drizzle-orm";'); expect(result).toContain(` label: text("label", { mode: "json" }).default(sql.raw("'\\"it''s\\"'")),`); expect(result).toContain(` flag: text("flag", { mode: "json" }).default(sql.raw("'true'")),`); expect(result).toContain(` size: text("size", { mode: "json" }).default(sql.raw("'5'")),`); expect(result).toContain(` tags: text("tags", { mode: "json" }).default(sql.raw("'[\\"a\\"]'")),`); expect(result).toContain(' extra: text("extra", { mode: "json" }).default(null),'); expect(generateDrizzleSchema(schema, "postgres")).not.toContain("drizzle-orm\";"); }); it("should include the built-in kv table for sqlite with a JSON text value column", () => { const schema = { namespaced: false, resources: [ { name: "item", version: 1, fields: [ { name: "id", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "sqlite"); expect(result).toContain('export const kv = sqliteTable("kv", {'); expect(result).toContain(' id: text("id").primaryKey(),'); expect(result).toContain(' value: text("value", { mode: "json" }),'); expect(result).toContain('import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";'); expect(readSchemaExports(result)).toEqual(expectedSchemaExports(["item"])); }); it("should not duplicate kv table if schema already defines it", () => { const schema = { namespaced: false, resources: [ { name: "kv", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "value", type: "json", required: false }, ], indices: ["id"], permissions: { read: { fields: ["id", "value"] }, write: { fields: ["id", "value"] }, }, }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); const kvOccurrences = (result.match(/export const kv = pgTable/g) || []).length; expect(kvOccurrences).toBe(1); }); it("kv table should appear in sorted position within the schema export", () => { const schema = { namespaced: false, resources: [ { name: "todos", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "text", type: "string", required: true }, ], }, { name: "categories", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "name", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); // kv sorts between categories and todos after Datafn internal tables. expect(readSchemaExports(result)).toEqual(expectedSchemaExports(["categories", "todos"])); }); }); describe("TV-VAL: Index Field Validation", () => { it("TV-VAL-001: should reject invalid index field in indices.base (snake_case mismatch)", () => { const schema = { resources: [ { name: "todos", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "createdAt", type: "date", required: true }, ], indices: { base: ["created_at"] }, }, ], }; const result = validateSchema(schema); expect(result.ok).toBe(false); if (!result.ok) { expect(result.error.code).toBe("SCHEMA_INVALID"); expect(result.error.message).toContain('index field "created_at"'); expect(result.error.message).toContain("indices.base"); expect(result.error.message).toContain('"todos"'); expect(result.error.message).toContain("id, createdAt"); } }); it("TV-VAL-003: should accept valid index fields", () => { const schema = { resources: [ { name: "event", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "type", type: "string", required: true }, { name: "createdAt", type: "date", required: true }, ], indices: { base: ["type", "createdAt"] }, }, ], }; const result = validateSchema(schema); expect(result.ok).toBe(true); }); it("TV-VAL-004: should reject invalid field in indices.search", () => { const schema = { resources: [ { name: "posts", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "title", type: "string", required: true }, { name: "body", type: "string", required: true }, ], indices: { base: ["title"], search: ["content"] }, }, ], }; const result = validateSchema(schema); expect(result.ok).toBe(false); if (!result.ok) { expect(result.error.code).toBe("SCHEMA_INVALID"); expect(result.error.message).toContain('index field "content"'); expect(result.error.message).toContain("indices.search"); expect(result.error.message).toContain('"posts"'); } }); it("TV-VAL-005: should reject invalid field in indices.vector", () => { const schema = { resources: [ { name: "docs", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "embedding", type: "array", required: true }, ], indices: { vector: ["embeddings"] }, }, ], }; const result = validateSchema(schema); expect(result.ok).toBe(false); if (!result.ok) { expect(result.error.code).toBe("SCHEMA_INVALID"); expect(result.error.message).toContain('index field "embeddings"'); expect(result.error.message).toContain("indices.vector"); expect(result.error.message).toContain('"docs"'); } }); it("TV-VAL-006: should reject invalid field in shorthand indices array", () => { const schema = { resources: [ { name: "items", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "status", type: "string", required: true }, ], indices: ["invalid_field"], }, ], }; const result = validateSchema(schema); expect(result.ok).toBe(false); if (!result.ok) { expect(result.error.code).toBe("SCHEMA_INVALID"); expect(result.error.message).toContain('index field "invalid_field"'); expect(result.error.message).toContain("indices.base"); expect(result.error.message).toContain('"items"'); } }); it("TV-VAL-007: should accept schema with no indices", () => { const schema = { resources: [ { name: "simple", version: 1, fields: [ { name: "id", type: "string", required: true }, ], }, ], }; const result = validateSchema(schema); expect(result.ok).toBe(true); }); }); // ========================================================================= // namespaced codegen (SCH-001, SCH-002, SCH-003, SCH-004) // ========================================================================= describe("TV-SCH-002: namespaced __ns column generation", () => { it("should add __ns column to resource tables when namespaced: true", () => { const schema = { namespaced: true, resources: [ { name: "task", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "title", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); // __ns column present expect(result).toContain('__ns: text("__ns").notNull(),'); // __ns sorts before alpha fields (underscore < alpha) const taskBlock = result.split('pgTable("task"')[1]; const nsPos = taskBlock.indexOf("__ns:"); const idPos = taskBlock.indexOf("id:"); expect(nsPos).toBeLessThan(idPos); }); it("should add __ns by default when namespaced is not set (defaults to true)", () => { const schema = { resources: [ { name: "task", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "title", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain('__ns: text("__ns").notNull(),'); expect(result).toContain('index("idx_task___ns").on(table.__ns)'); }); it("should NOT add __ns when namespaced is explicitly false", () => { const schema = { namespaced: false, resources: [ { name: "task", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "title", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).not.toContain("__ns"); }); }); describe("TV-SCH-003: namespaced __ns index generation", () => { it("should add index on __ns for every resource table", () => { const schema = { namespaced: true, resources: [ { name: "task", version: 1, fields: [ { name: "id", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain('index("idx_task___ns").on(table.__ns)'); expect(result).toContain("import { index,"); }); it("should compose __ns index with existing base indices", () => { const schema = { namespaced: true, resources: [ { name: "task", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "status", type: "string", required: false }, ], indices: { base: ["status"] }, }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); // Both indices present expect(result).toContain('index("idx_task___ns").on(table.__ns)'); expect(result).toContain('index("task_status_idx").on(table.status)'); }); }); describe("TV-SCH-004: namespaced __ns on join tables", () => { it("should add __ns column and index to join tables when namespaced: true", () => { const schema = { namespaced: true, resources: [ { name: "task", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "tag", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [ { from: "task", to: "tag", type: "many-many", relation: "tags" }, ], }; const result = generateDrizzleSchema(schema, "postgres"); // Join table has __ns column const joinBlock = result.split('pgTable("__datafn_join_task_tags"')[1]; expect(joinBlock).toContain('__ns: text("__ns").notNull()'); // Join table has __ns index expect(result).toContain('index("idx___datafn_join_task_tags___ns").on(table.__ns)'); }); it("should NOT add __ns to join tables when namespaced is explicitly false", () => { const schema = { namespaced: false, resources: [ { name: "task", version: 1, fields: [{ name: "id", type: "string", required: true }], }, { name: "tag", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [ { from: "task", to: "tag", type: "many-many", relation: "tags" }, ], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).not.toContain("__ns"); }); }); describe("TV-SCH-001: namespaced schema flag accepted", () => { it("defineSchema accepts namespaced: true", () => { const schema = defineSchema({ namespaced: true, resources: [ { name: "task", version: 1, fields: [{ name: "title", type: "string", required: true }], }, ], }); expect(schema.namespaced).toBe(true); }); }); describe("TV-SCH-006: validateSchema accepts namespaced", () => { it("returns namespaced: true in validated output", () => { const result = validateSchema({ namespaced: true, resources: [ { name: "task", version: 1, fields: [{ name: "title", type: "string", required: true }], }, ], }); expect(result.ok).toBe(true); if (result.ok) { expect(result.result.namespaced).toBe(true); } }); it("defaults namespaced to true when not set", () => { const result = validateSchema({ resources: [ { name: "task", version: 1, fields: [{ name: "title", type: "string", required: true }], }, ], }); expect(result.ok).toBe(true); if (result.ok) { expect(result.result.namespaced).toBe(true); } }); it("returns namespaced: false when explicitly set to false", () => { const result = validateSchema({ namespaced: false, resources: [ { name: "task", version: 1, fields: [{ name: "title", type: "string", required: true }], }, ], }); expect(result.ok).toBe(true); if (result.ok) { expect(result.result.namespaced).toBe(false); } }); }); describe("namespaced codegen: SQLite dialect", () => { it("should generate __ns with text type for SQLite", () => { const schema = { namespaced: true, resources: [ { name: "task", version: 1, fields: [{ name: "id", type: "string", required: true }], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "sqlite"); expect(result).toContain('__ns: text("__ns").notNull()'); expect(result).toContain('index("idx_task___ns")'); }); }); // ========================================================================= // NS-016/017: namespaced field codegen // ========================================================================= describe("TV-NS-030: CLI codegen with namespaced: true", () => { it("should emit __ns column when namespaced: true", () => { const schema = { namespaced: true, resources: [ { name: "task", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "title", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).toContain('__ns: text("__ns").notNull(),'); expect(result).toContain('primaryKey({ columns: [table.__ns, table.id] })'); expect(result).toContain('index("idx_task___ns").on(table.__ns)'); }); }); describe("TV-NS-031: CLI codegen with namespaced: false", () => { it("should NOT emit __ns column when namespaced: false", () => { const schema = { namespaced: false, resources: [ { name: "task", version: 1, fields: [ { name: "id", type: "string", required: true }, { name: "title", type: "string", required: true }, ], }, ], relations: [], }; const result = generateDrizzleSchema(schema, "postgres"); expect(result).not.toContain("__ns"); expect(result).toContain('id: text("id").primaryKey()'); }); }); }); it.each(["postgres", "mysql", "sqlite"] as const)("%s keeps required nullable columns nullable", (dialect) => { const output = generateDrizzleSchema({ resources: [{ name: "item", version: 1, fields: [ { name: "requiredValue", type: "string", required: true }, { name: "nullableValue", type: "string", required: true, nullable: true }, ] }], relations: [] }, dialect); expect(output.split("\n").find((line) => line.includes("requiredValue:"))).toContain(".notNull()"); expect(output.split("\n").find((line) => line.includes("nullableValue:"))).not.toContain(".notNull()"); });