@fragno-dev/db 0.2.2 → 0.4.1

package/src/migration-engine/generation-engine.test.ts

@@ -1,25 +1,48 @@
 import { describe, it, expect, beforeAll, beforeEach, vi, afterEach } from "vitest";
+
 import { DummyDriver, MysqlAdapter, PostgresAdapter, SqliteAdapter } from "kysely";
-import {
-  postProcessMigrationFilenames,
-  type GenerationInternalResult,
-  generateMigrationsOrSchema,
-} from "./generation-engine";
-import { KyselyAdapter } from "../adapters/kysely/kysely-adapter";
-import { column, idColumn, schema, type AnySchema } from "../schema/create";
-import { FragnoDatabase } from "../mod";
+
 import {
   MySQL2DriverConfig,
   NodePostgresDriverConfig,
   SQLocalDriverConfig,
 } from "../adapters/generic-sql/driver-config";
+import { SqlAdapter } from "../adapters/generic-sql/generic-sql-adapter";
+import { FragnoDatabase } from "../mod";
+import { column, idColumn, schema, type AnySchema } from "../schema/create";
+import {
+  postProcessMigrationFilenames,
+  type GenerationInternalResult,
+  generateSchemaArtifacts,
+} from "./generation-engine";
 
-describe("generateMigrationsOrSchema - kysely", () => {
+const buildFile = (
+  overrides: Partial<GenerationInternalResult> &
+    Pick<GenerationInternalResult, "schema" | "namespace" | "fromVersion" | "toVersion">,
+): GenerationInternalResult => {
+  const namespace = overrides.namespace ?? null;
+  const schemaName = overrides.schemaName ?? "test";
+  const namespaceKey = overrides.namespaceKey ?? namespace ?? schemaName;
+  const isSettings = overrides.isSettings ?? false;
+
+  return {
+    schema: overrides.schema,
+    path: overrides.path ?? "placeholder.sql",
+    namespace,
+    namespaceKey,
+    schemaName,
+    isSettings,
+    fromVersion: overrides.fromVersion,
+    toVersion: overrides.toVersion,
+  };
+};
+
+describe("generateSchemaArtifacts - sql", () => {
   const mockDate = new Date("2025-10-24T12:00:00Z");
-  let adapter: KyselyAdapter;
+  let adapter: SqlAdapter;
 
   beforeAll(() => {
-    adapter = new KyselyAdapter({
+    adapter = new SqlAdapter({
       dialect: {
         createAdapter: () => new PostgresAdapter(),
         createDriver: () => new DummyDriver(),
@@ -48,7 +71,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
   });
 
   it("should generate migration for single database from version 0", async () => {
-    const testSchema: AnySchema = schema((s) => {
+    const testSchema: AnySchema = schema("test", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
@@ -60,10 +83,10 @@ describe("generateMigrationsOrSchema - kysely", () => {
       adapter,
     });
 
-    const results = await generateMigrationsOrSchema([fragnoDb]);
+    const results = await generateSchemaArtifacts([fragnoDb]);
 
     expect(results).toHaveLength(2); // Settings + test-db
-    expect(results[0].namespace).toBe(""); // Empty namespace for settings table
+    expect(results[0].namespace).toBeNull();
     expect(results[0].path).toMatch(/^20251024_001_f000_t00\d_fragno_db_settings.sql$/);
     expect(results[0].schema).toContain("create table");
     expect(results[0].schema).toContain("fragno_db_settings");
@@ -71,23 +94,23 @@ describe("generateMigrationsOrSchema - kysely", () => {
     expect(results[1].namespace).toBe("test-db");
     expect(results[1].path).toBe("20251024_002_f000_t001_test-db.sql");
     expect(results[1].schema).toContain("create table");
-    expect(results[1].schema).toContain("users_test-db");
+    expect(results[1].schema).toContain('"test-db"."users"');
   });
 
   it("should generate migrations for multiple databases in alphabetical order", async () => {
-    const schema1: AnySchema = schema((s) => {
+    const schema1: AnySchema = schema("schema1", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
     });
 
-    const schema2: AnySchema = schema((s) => {
+    const schema2: AnySchema = schema("schema2", (s) => {
       return s.addTable("posts", (t) => {
         return t.addColumn("id", idColumn()).addColumn("title", column("string"));
       });
     });
 
-    const schema3: AnySchema = schema((s) => {
+    const schema3: AnySchema = schema("schema3", (s) => {
       return s.addTable("comments", (t) => {
         return t.addColumn("id", idColumn()).addColumn("text", column("string"));
       });
@@ -111,27 +134,27 @@ describe("generateMigrationsOrSchema - kysely", () => {
       adapter,
     });
 
-    const results = await generateMigrationsOrSchema([fragnoDb1, fragnoDb2, fragnoDb3]);
+    const results = await generateSchemaArtifacts([fragnoDb1, fragnoDb2, fragnoDb3]);
 
     expect(results).toHaveLength(4); // Settings + 3 databases
-    expect(results[0].namespace).toBe(""); // Empty namespace for settings table
+    expect(results[0].namespace).toBeNull();
     expect(results[0].path).toMatch(/^20251024_001_f000_t00\d_fragno_db_settings.sql$/);
 
     expect(results[1].namespace).toBe("apple-db");
     expect(results[1].path).toBe("20251024_002_f000_t001_apple-db.sql");
-    expect(results[1].schema).toContain("posts_apple-db");
+    expect(results[1].schema).toContain('"apple-db"."posts"');
 
     expect(results[2].namespace).toBe("mango-db");
     expect(results[2].path).toBe("20251024_003_f000_t001_mango-db.sql");
-    expect(results[2].schema).toContain("comments_mango-db");
+    expect(results[2].schema).toContain('"mango-db"."comments"');
 
     expect(results[3].namespace).toBe("zebra-db");
     expect(results[3].path).toBe("20251024_004_f000_t001_zebra-db.sql");
-    expect(results[3].schema).toContain("users_zebra-db");
+    expect(results[3].schema).toContain('"zebra-db"."users"');
   });
 
   it("should handle existing settings version and generate both settings and fragment migrations", async () => {
-    const testSchema: AnySchema = schema((s) => {
+    const testSchema: AnySchema = schema("test", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -150,12 +173,12 @@ describe("generateMigrationsOrSchema - kysely", () => {
       adapter,
     });
 
-    const results = await generateMigrationsOrSchema([fragnoDb]);
+    const results = await generateSchemaArtifacts([fragnoDb]);
 
     // Settings table already at version 1, so no settings migration needed
     // But fragment migration is still generated
     expect(results).toHaveLength(2);
-    expect(results[0].namespace).toBe(""); // Empty namespace for settings table
+    expect(results[0].namespace).toBeNull();
     expect(results[1].namespace).toBe("test-db");
     expect(results[1].path).toBe("20251024_002_f000_t002_test-db.sql");
     expect(results[1].schema).toContain("create table");
@@ -163,7 +186,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
   });
 
   it("should generate settings migration even with no fragment changes", async () => {
-    const testSchema: AnySchema = schema((s) => {
+    const testSchema: AnySchema = schema("test", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
@@ -176,24 +199,26 @@ describe("generateMigrationsOrSchema - kysely", () => {
     });
 
     // Generate with toVersion = 0, fromVersion = 0 (no fragment changes)
-    const results = await generateMigrationsOrSchema([fragnoDb], {
+    const results = await generateSchemaArtifacts([fragnoDb], {
       toVersion: 0,
       fromVersion: 0,
     });
 
-    // Settings migration is generated, but no fragment migration (since toVersion=0)
-    expect(results).toHaveLength(1);
-    expect(results[0].namespace).toBe(""); // Empty namespace for settings table
+    // Settings migration is generated, and fragment migration creates schema (toVersion=0)
+    expect(results).toHaveLength(2);
+    expect(results[0].namespace).toBeNull();
+    expect(results[1].namespace).toBe("test-db");
+    expect(results[1].schema).toContain('CREATE SCHEMA IF NOT EXISTS "test-db"');
   });
 
   it("should throw error when no databases provided", async () => {
-    await expect(generateMigrationsOrSchema([])).rejects.toThrow(
+    await expect(generateSchemaArtifacts([])).rejects.toThrow(
       "No databases provided for schema generation",
     );
   });
 
   it("should throw error when database connection is unhealthy", async () => {
-    const testSchema: AnySchema = schema((s) => {
+    const testSchema: AnySchema = schema("test", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
@@ -208,13 +233,13 @@ describe("generateMigrationsOrSchema - kysely", () => {
       adapter,
     });
 
-    await expect(generateMigrationsOrSchema([fragnoDb])).rejects.toThrow(
+    await expect(generateSchemaArtifacts([fragnoDb])).rejects.toThrow(
       "Database connection is not healthy",
     );
   });
 
   it("should generate SQL with correct version tracking in settings", async () => {
-    const testSchema: AnySchema = schema((s) => {
+    const testSchema: AnySchema = schema("test", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
@@ -226,7 +251,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
       adapter,
     });
 
-    const results = await generateMigrationsOrSchema([fragnoDb]);
+    const results = await generateSchemaArtifacts([fragnoDb]);
 
     // Check settings migration includes version tracking
     expect(results[0].schema).toContain("fragno_db_settings");
@@ -239,7 +264,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
   });
 
   it("should generate INSERT for version 0->N and UPDATE for version N->M", async () => {
-    const testSchema: AnySchema = schema((s) => {
+    const testSchema: AnySchema = schema("test", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -257,7 +282,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
 
     // First migration: 0 -> 1 (should use INSERT)
     vi.spyOn(adapter, "getSchemaVersion").mockResolvedValueOnce(undefined);
-    const resultsV1 = await generateMigrationsOrSchema([fragnoDb], {
+    const resultsV1 = await generateSchemaArtifacts([fragnoDb], {
       fromVersion: 0,
       toVersion: 1,
     });
@@ -268,14 +293,16 @@ describe("generateMigrationsOrSchema - kysely", () => {
     expect(resultsV1[1].schema).toContain("test-db.schema_version");
     expect(resultsV1[1].schema).toContain("'1'");
     expect(resultsV1[1].schema).toMatchInlineSnapshot(`
-      "create table "users_test-db" ("id" varchar(30) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
+      "CREATE SCHEMA IF NOT EXISTS "test-db";
+
+      create table "test-db"."users" ("id" varchar(128) not null unique, "name" text not null, "_internalId" bigserial not null primary key, "_version" integer default 0 not null);
 
       insert into "fragno_db_settings" ("id", "key", "value") values ('6_U2SCfiaNG9VyYmQ_JwzQ', 'test-db.schema_version', '1');"
     `);
 
     // Second migration: 1 -> 2 (should use UPDATE)
     vi.spyOn(adapter, "getSchemaVersion").mockResolvedValueOnce("1");
-    const resultsV2 = await generateMigrationsOrSchema([fragnoDb], {
+    const resultsV2 = await generateSchemaArtifacts([fragnoDb], {
       fromVersion: 1,
       toVersion: 2,
     });
@@ -287,14 +314,16 @@ describe("generateMigrationsOrSchema - kysely", () => {
     expect(resultsV2[1].schema).toContain("test-db.schema_version");
     expect(resultsV2[1].schema).toContain("'2'");
     expect(resultsV2[1].schema).toMatchInlineSnapshot(`
-      "alter table "users_test-db" add column "email" text;
+      "CREATE SCHEMA IF NOT EXISTS "test-db";
+
+      alter table "test-db"."users" add column "email" text;
 
       update "fragno_db_settings" set "value" = '2' where "key" = 'test-db.schema_version';"
     `);
   });
 
   it("should include MySQL-specific foreign key checks in generated SQL", async () => {
-    const mysqlAdapter = new KyselyAdapter({
+    const mysqlAdapter = new SqlAdapter({
       dialect: {
         createAdapter: () => new MysqlAdapter(),
         createDriver: () => new DummyDriver(),
@@ -311,7 +340,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
     vi.spyOn(mysqlAdapter, "isConnectionHealthy").mockResolvedValue(true);
     vi.spyOn(mysqlAdapter, "getSchemaVersion").mockResolvedValue(undefined);
 
-    const testSchema: AnySchema = schema((s) => {
+    const testSchema: AnySchema = schema("test", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
@@ -323,7 +352,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
       adapter: mysqlAdapter,
     });
 
-    const results = await generateMigrationsOrSchema([fragnoDb]);
+    const results = await generateSchemaArtifacts([fragnoDb]);
 
     expect(results).toHaveLength(2);
     // Check that MySQL foreign key checks are included
@@ -339,7 +368,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
   });
 
   it("should include SQLite-specific pragma in generated SQL", async () => {
-    const sqliteAdapter = new KyselyAdapter({
+    const sqliteAdapter = new SqlAdapter({
       dialect: {
         createAdapter: () => new SqliteAdapter(),
         createDriver: () => new DummyDriver(),
@@ -356,7 +385,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
     vi.spyOn(sqliteAdapter, "isConnectionHealthy").mockResolvedValue(true);
     vi.spyOn(sqliteAdapter, "getSchemaVersion").mockResolvedValue(undefined);
 
-    const testSchema: AnySchema = schema((s) => {
+    const testSchema: AnySchema = schema("test", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
@@ -368,7 +397,7 @@ describe("generateMigrationsOrSchema - kysely", () => {
       adapter: sqliteAdapter,
     });
 
-    const results = await generateMigrationsOrSchema([fragnoDb]);
+    const results = await generateSchemaArtifacts([fragnoDb]);
 
     expect(results).toHaveLength(2);
     // Check that SQLite pragma is included
@@ -381,6 +410,166 @@ describe("generateMigrationsOrSchema - kysely", () => {
   });
 });
 
+describe("generateSchemaArtifacts - schema outputs", () => {
+  it("should generate drizzle schema without requiring a healthy connection", async () => {
+    const adapter = new SqlAdapter({
+      dialect: {
+        createAdapter: () => new PostgresAdapter(),
+        createDriver: () => new DummyDriver(),
+        createQueryCompiler: () => ({
+          compileQuery: () => ({
+            sql: "",
+            parameters: [],
+          }),
+        }),
+      },
+      driverConfig: new NodePostgresDriverConfig(),
+    });
+
+    const testSchema: AnySchema = schema("test", (s) => {
+      return s.addTable("users", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+      });
+    });
+
+    const fragnoDb = new FragnoDatabase({
+      namespace: "drizzle-db",
+      schema: testSchema,
+      adapter,
+    });
+
+    const healthSpy = vi.spyOn(adapter, "isConnectionHealthy").mockResolvedValue(false);
+    const [result] = await generateSchemaArtifacts([fragnoDb], { format: "drizzle" });
+
+    expect(result.path).toBe("fragno-schema.ts");
+    expect(result.schema).toContain("schemaVersion");
+    expect(healthSpy).not.toHaveBeenCalled();
+  });
+
+  it("should order drizzle schema fragments deterministically by schema name", async () => {
+    const adapter = new SqlAdapter({
+      dialect: {
+        createAdapter: () => new PostgresAdapter(),
+        createDriver: () => new DummyDriver(),
+        createQueryCompiler: () => ({
+          compileQuery: () => ({
+            sql: "",
+            parameters: [],
+          }),
+        }),
+      },
+      driverConfig: new NodePostgresDriverConfig(),
+    });
+
+    const schemaAlpha: AnySchema = schema("alpha", (s) => {
+      return s.addTable("alpha_table", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("name", column("string"));
+      });
+    });
+
+    const schemaBeta: AnySchema = schema("beta", (s) => {
+      return s.addTable("beta_table", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("title", column("string"));
+      });
+    });
+
+    const fragnoDbBeta = new FragnoDatabase({
+      namespace: "alpha",
+      schema: schemaBeta,
+      adapter,
+    });
+
+    const fragnoDbAlpha = new FragnoDatabase({
+      namespace: "zulu",
+      schema: schemaAlpha,
+      adapter,
+    });
+
+    const [result] = await generateSchemaArtifacts([fragnoDbBeta, fragnoDbAlpha], {
+      format: "drizzle",
+    });
+
+    const schemaOutput = result.schema;
+    const internalIndex = schemaOutput.indexOf("Fragment: (none)");
+    const alphaIndex = schemaOutput.indexOf("Fragment: zulu");
+    const betaIndex = schemaOutput.indexOf("Fragment: alpha");
+
+    expect(internalIndex).toBeGreaterThanOrEqual(0);
+    expect(alphaIndex).toBeGreaterThanOrEqual(0);
+    expect(betaIndex).toBeGreaterThanOrEqual(0);
+    expect(internalIndex).toBeLessThan(alphaIndex);
+    expect(alphaIndex).toBeLessThan(betaIndex);
+  });
+
+  it("should reject from/to versions for prisma output", async () => {
+    const adapter = new SqlAdapter({
+      dialect: {
+        createAdapter: () => new SqliteAdapter(),
+        createDriver: () => new DummyDriver(),
+        createQueryCompiler: () => ({
+          compileQuery: () => ({
+            sql: "",
+            parameters: [],
+          }),
+        }),
+      },
+      driverConfig: new SQLocalDriverConfig(),
+      sqliteProfile: "prisma",
+    });
+
+    const testSchema: AnySchema = schema("test", (s) => {
+      return s.addTable("events", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("createdAt", column("timestamp"));
+      });
+    });
+
+    const fragnoDb = new FragnoDatabase({
+      namespace: "prisma-db",
+      schema: testSchema,
+      adapter,
+    });
+
+    await expect(
+      generateSchemaArtifacts([fragnoDb], { format: "prisma", fromVersion: 0 }),
+    ).rejects.toThrow("--from and --to are only supported when generating SQL migrations.");
+  });
+
+  it("should honor sqlite prisma profile for schema output", async () => {
+    const adapter = new SqlAdapter({
+      dialect: {
+        createAdapter: () => new SqliteAdapter(),
+        createDriver: () => new DummyDriver(),
+        createQueryCompiler: () => ({
+          compileQuery: () => ({
+            sql: "",
+            parameters: [],
+          }),
+        }),
+      },
+      driverConfig: new SQLocalDriverConfig(),
+      sqliteProfile: "prisma",
+    });
+
+    const testSchema: AnySchema = schema("test", (s) => {
+      return s.addTable("events", (t) => {
+        return t.addColumn("id", idColumn()).addColumn("createdAt", column("timestamp"));
+      });
+    });
+
+    const fragnoDb = new FragnoDatabase({
+      namespace: "prisma-db",
+      schema: testSchema,
+      adapter,
+    });
+
+    const [result] = await generateSchemaArtifacts([fragnoDb], { format: "prisma" });
+
+    expect(result.path).toBe("fragno.prisma");
+    expect(result.schema).toContain("model Events_prisma_db");
+    expect(result.schema).toContain("DateTime");
+  });
+});
+
 describe("postProcessMigrationFilenames", () => {
   const mockDate = new Date("2025-10-24T12:00:00Z");
 
@@ -400,59 +589,56 @@ describe("postProcessMigrationFilenames", () => {
 
   it("should order settings namespace first", () => {
     const files: GenerationInternalResult[] = [
-      {
+      buildFile({
         schema: "schema1",
-        path: "placeholder.sql",
         namespace: "fragno-db-comment-db",
         fromVersion: 0,
         toVersion: 3,
-      },
-      {
+      }),
+      buildFile({
         schema: "schema2",
-        path: "placeholder.sql",
-        namespace: "", // Empty namespace for settings table
+        namespace: null,
+        namespaceKey: "fragno_db_settings",
+        schemaName: "fragno_internal",
+        isSettings: true,
         fromVersion: 0,
         toVersion: 1,
-      },
-      {
+      }),
+      buildFile({
         schema: "schema3",
-        path: "placeholder.sql",
         namespace: "fragno-db-rating-db",
         fromVersion: 0,
         toVersion: 2,
-      },
+      }),
     ];
 
     const result = postProcessMigrationFilenames(files);
 
     expect(result).toHaveLength(3);
-    expect(result[0].namespace).toBe(""); // Empty namespace for settings table
+    expect(result[0].namespace).toBeNull();
     expect(result[0].path).toBe("20251024_001_f000_t001_fragno_db_settings.sql");
   });
 
   it("should sort non-settings namespaces alphabetically", () => {
     const files: GenerationInternalResult[] = [
-      {
+      buildFile({
         schema: "schema1",
-        path: "placeholder.sql",
         namespace: "zebra-db",
         fromVersion: 0,
         toVersion: 1,
-      },
-      {
+      }),
+      buildFile({
         schema: "schema2",
-        path: "placeholder.sql",
         namespace: "apple-db",
         fromVersion: 0,
         toVersion: 1,
-      },
-      {
+      }),
+      buildFile({
         schema: "schema3",
-        path: "placeholder.sql",
         namespace: "mango-db",
         fromVersion: 0,
         toVersion: 1,
-      },
+      }),
     ];
 
     const result = postProcessMigrationFilenames(files);
@@ -465,20 +651,21 @@ describe("postProcessMigrationFilenames", () => {
 
   it("should format filename with correct ordering and version numbers", () => {
     const files: GenerationInternalResult[] = [
-      {
+      buildFile({
         schema: "CREATE TABLE users;",
-        path: "placeholder.sql",
-        namespace: "", // Empty namespace for settings table
+        namespace: null,
+        namespaceKey: "fragno_db_settings",
+        schemaName: "fragno_internal",
+        isSettings: true,
         fromVersion: 0,
         toVersion: 5,
-      },
-      {
+      }),
+      buildFile({
         schema: "CREATE TABLE comments;",
-        path: "placeholder.sql",
         namespace: "comment-db",
         fromVersion: 5,
         toVersion: 10,
-      },
+      }),
     ];
 
     const result = postProcessMigrationFilenames(files);
@@ -489,13 +676,12 @@ describe("postProcessMigrationFilenames", () => {
 
   it("should pad numbers to 3 digits", () => {
     const files: GenerationInternalResult[] = [
-      {
+      buildFile({
         schema: "schema",
-        path: "placeholder.sql",
         namespace: "test-db",
         fromVersion: 99,
         toVersion: 999,
-      },
+      }),
     ];
 
     const result = postProcessMigrationFilenames(files);
@@ -505,13 +691,12 @@ describe("postProcessMigrationFilenames", () => {
 
   it("should sanitize namespace with invalid characters", () => {
     const files: GenerationInternalResult[] = [
-      {
+      buildFile({
         schema: "schema",
-        path: "placeholder.sql",
         namespace: "test@db#special!chars",
         fromVersion: 0,
         toVersion: 1,
-      },
+      }),
     ];
 
     const result = postProcessMigrationFilenames(files);
@@ -521,13 +706,12 @@ describe("postProcessMigrationFilenames", () => {
 
   it("should preserve schema content", () => {
     const files: GenerationInternalResult[] = [
-      {
+      buildFile({
         schema: "CREATE TABLE users (id INT);",
-        path: "placeholder.sql",
         namespace: "user-db",
         fromVersion: 0,
         toVersion: 1,
-      },
+      }),
     ];
 
     const result = postProcessMigrationFilenames(files);
@@ -537,40 +721,39 @@ describe("postProcessMigrationFilenames", () => {
 
   it("should handle multiple files with settings first and others sorted", () => {
     const files: GenerationInternalResult[] = [
-      {
+      buildFile({
         schema: "schema1",
-        path: "placeholder.sql",
         namespace: "zoo-db",
         fromVersion: 1,
         toVersion: 2,
-      },
-      {
+      }),
+      buildFile({
         schema: "schema2",
-        path: "placeholder.sql",
-        namespace: "", // Empty namespace for settings table
+        namespace: null,
+        namespaceKey: "fragno_db_settings",
+        schemaName: "fragno_internal",
+        isSettings: true,
         fromVersion: 0,
         toVersion: 5,
-      },
-      {
+      }),
+      buildFile({
         schema: "schema3",
-        path: "placeholder.sql",
         namespace: "apple-db",
         fromVersion: 3,
         toVersion: 4,
-      },
-      {
+      }),
+      buildFile({
         schema: "schema4",
-        path: "placeholder.sql",
         namespace: "mango-db",
         fromVersion: 2,
         toVersion: 3,
-      },
+      }),
     ];
 
     const result = postProcessMigrationFilenames(files);
 
     expect(result).toHaveLength(4);
-    expect(result[0].namespace).toBe(""); // Empty namespace for settings table
+    expect(result[0].namespace).toBeNull();
     expect(result[0].path).toBe("20251024_001_f000_t005_fragno_db_settings.sql");
     expect(result[1].namespace).toBe("apple-db");
     expect(result[1].path).toBe("20251024_002_f003_t004_apple-db.sql");
@@ -581,13 +764,14 @@ describe("postProcessMigrationFilenames", () => {
   });
 
   it("should handle ordering numbers beyond 100", () => {
-    const files: GenerationInternalResult[] = Array.from({ length: 150 }, (_, i) => ({
-      schema: `schema${i}`,
-      path: "placeholder.sql",
-      namespace: `db-${String(i).padStart(3, "0")}`,
-      fromVersion: 0,
-      toVersion: 1,
-    }));
+    const files: GenerationInternalResult[] = Array.from({ length: 150 }, (_, i) =>
+      buildFile({
+        schema: `schema${i}`,
+        namespace: `db-${String(i).padStart(3, "0")}`,
+        fromVersion: 0,
+        toVersion: 1,
+      }),
+    );
 
     const result = postProcessMigrationFilenames(files);
 
@@ -598,13 +782,12 @@ describe("postProcessMigrationFilenames", () => {
 
   it("should preserve hyphens in namespace", () => {
     const files: GenerationInternalResult[] = [
-      {
+      buildFile({
         schema: "schema",
-        path: "placeholder.sql",
         namespace: "my-awesome-db-fragment",
         fromVersion: 0,
         toVersion: 1,
-      },
+      }),
     ];
 
     const result = postProcessMigrationFilenames(files);
@@ -614,13 +797,12 @@ describe("postProcessMigrationFilenames", () => {
 
   it("should use current date in YYYYMMDD format", () => {
     const files: GenerationInternalResult[] = [
-      {
+      buildFile({
         schema: "schema",
-        path: "placeholder.sql",
         namespace: "test-db",
         fromVersion: 0,
         toVersion: 1,
-      },
+      }),
     ];
 
     const result = postProcessMigrationFilenames(files);