@fragno-dev/db 0.2.1 → 0.3.0

package/src/query/unit-of-work/unit-of-work.test.ts

@@ -4,6 +4,7 @@ import {
   type UOWCompiler,
   type UOWDecoder,
   createUnitOfWork,
+  UnitOfWork,
   type InferIdColumnName,
   type IndexColumns,
 } from "./unit-of-work";
@@ -38,7 +39,7 @@ function createMockDecoder(): UOWDecoder {
 
 describe("FindBuilder", () => {
   it("should support primary index", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) =>
         t
           .addColumn("id", idColumn())
@@ -59,7 +60,7 @@ describe("FindBuilder", () => {
   });
 
   it("should support custom indexes", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) =>
         t
           .addColumn("id", idColumn())
@@ -82,7 +83,7 @@ describe("FindBuilder", () => {
   });
 
   it("should support cursor-based pagination", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string")),
     );
 
@@ -102,7 +103,7 @@ describe("FindBuilder", () => {
   });
 
   it("should support backward cursor pagination", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string")),
     );
 
@@ -122,7 +123,7 @@ describe("FindBuilder", () => {
   });
 
   it("should throw RangeError for pageSize <= 0", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string")),
     );
 
@@ -142,7 +143,7 @@ describe("FindBuilder", () => {
   });
 
   it("should throw RangeError for non-integer pageSize", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string")),
     );
 
@@ -166,7 +167,7 @@ describe("FindBuilder", () => {
   });
 
   it("should throw if index doesn't exist", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string")),
     );
 
@@ -177,7 +178,7 @@ describe("FindBuilder", () => {
   });
 
   it("should throw if finalized without index", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string")),
     );
 
@@ -190,7 +191,7 @@ describe("FindBuilder", () => {
   });
 
   it("should support count operations", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) =>
         t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("age", "integer"),
       ),
@@ -205,7 +206,7 @@ describe("FindBuilder", () => {
   });
 
   it("should throw when using both select and selectCount", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string")),
     );
 
@@ -228,7 +229,7 @@ describe("FindBuilder", () => {
   });
 
   it("should support orderByIndex", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) =>
         t
           .addColumn("id", idColumn())
@@ -257,7 +258,7 @@ describe("FindBuilder", () => {
   });
 
   it("should support join operations", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string"))
         .addTable("posts", (t) =>
@@ -291,7 +292,7 @@ describe("FindBuilder", () => {
   });
 
   it("should support join operations without builder function", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string"))
         .addTable("posts", (t) =>
@@ -325,7 +326,7 @@ describe("FindBuilder", () => {
   });
 
   it("should support join with whereIndex", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) =>
           t
@@ -373,7 +374,7 @@ describe("FindBuilder", () => {
   });
 
   it("should support join with orderByIndex", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) =>
           t
@@ -418,7 +419,7 @@ describe("FindBuilder", () => {
   });
 
   it("should support join with pageSize", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string"))
         .addTable("posts", (t) =>
@@ -453,7 +454,7 @@ describe("FindBuilder", () => {
   });
 
   it("should throw RangeError for invalid pageSize in join", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string"))
         .addTable("posts", (t) =>
@@ -498,7 +499,7 @@ describe("FindBuilder", () => {
   });
 
   it("should support nested joins", () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string"))
         .addTable("posts", (t) =>
@@ -564,7 +565,7 @@ describe("FindBuilder", () => {
 });
 
 describe("IndexedConditionBuilder", () => {
-  const testSchema = schema((s) =>
+  const testSchema = schema("test", (s) =>
     s.addTable("users", (t) =>
       t
         .addColumn("id", idColumn())
@@ -585,7 +586,7 @@ describe("IndexedConditionBuilder", () => {
     const indexedColumns = new Set<string>();
     for (const index of Object.values(usersTable.indexes)) {
       for (const col of index.columns) {
-        indexedColumns.add(col.ormName);
+        indexedColumns.add(col.name);
       }
     }
 
@@ -712,7 +713,7 @@ describe("IndexedConditionBuilder", () => {
   describe("type safety", () => {
     it("should restrict to only indexed columns at type level", () => {
       // This schema has "bio" column that is NOT indexed
-      const typeTestSchema = schema((s) =>
+      const typeTestSchema = schema("typetest", (s) =>
         s.addTable("users", (t) =>
           t
             .addColumn("id", idColumn())
@@ -770,7 +771,7 @@ describe("IndexedConditionBuilder", () => {
 });
 
 describe("UpdateBuilder with string ID", () => {
-  const testSchema = schema((s) =>
+  const testSchema = schema("test", (s) =>
     s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string")),
   );
 
@@ -806,7 +807,7 @@ describe("UpdateBuilder with string ID", () => {
 });
 
 describe("DeleteBuilder with string ID", () => {
-  const testSchema = schema((s) =>
+  const testSchema = schema("test", (s) =>
     s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", "string")),
   );
 
@@ -838,8 +839,72 @@ describe("DeleteBuilder with string ID", () => {
   });
 });
 
+describe("generateId", () => {
+  const testSchema = schema("test", (s) =>
+    s.addTable("users", (t) =>
+      t.addColumn("id", idColumn()).addColumn("email", "string").addColumn("name", "string"),
+    ),
+  );
+
+  it("should generate a new FragnoId without creating a record", () => {
+    const uow = createUnitOfWork(createMockCompiler(), createMockExecutor(), createMockDecoder());
+
+    const id = uow.forSchema(testSchema).generateId("users");
+
+    expect(id).toBeInstanceOf(FragnoId);
+    expect(id.externalId).toBeDefined();
+    expect(typeof id.externalId).toBe("string");
+    expect(id.externalId.length).toBeGreaterThan(0);
+    expect(id.version).toBe(0);
+
+    // No mutation operations should be added
+    expect(uow.getMutationOperations()).toHaveLength(0);
+  });
+
+  it("should generate unique IDs on each call", () => {
+    const uow = createUnitOfWork(createMockCompiler(), createMockExecutor(), createMockDecoder());
+    const typedUow = uow.forSchema(testSchema);
+
+    const id1 = typedUow.generateId("users");
+    const id2 = typedUow.generateId("users");
+
+    expect(id1.externalId).not.toBe(id2.externalId);
+  });
+
+  it("should allow using generated ID in create", async () => {
+    const executor = {
+      executeRetrievalPhase: async () => [],
+      executeMutationPhase: async () => ({
+        success: true,
+        createdInternalIds: [1n],
+      }),
+    };
+
+    const uow = createUnitOfWork(createMockCompiler(), executor, createMockDecoder());
+    const typedUow = uow.forSchema(testSchema);
+
+    const id = typedUow.generateId("users");
+    typedUow.create("users", { id, email: "test@example.com", name: "Test" });
+
+    await uow.executeMutations();
+    const createdIds = uow.getCreatedIds();
+
+    expect(createdIds).toHaveLength(1);
+    expect(createdIds[0].externalId).toBe(id.externalId);
+  });
+
+  it("should throw for non-existent table", () => {
+    const uow = createUnitOfWork(createMockCompiler(), createMockExecutor(), createMockDecoder());
+
+    expect(() => {
+      // @ts-expect-error - testing runtime error for non-existent table
+      uow.forSchema(testSchema).generateId("nonexistent");
+    }).toThrow("Table nonexistent not found in schema");
+  });
+});
+
 describe("getCreatedIds", () => {
-  const testSchema = schema((s) =>
+  const testSchema = schema("test", (s) =>
     s.addTable("users", (t) =>
       t.addColumn("id", idColumn()).addColumn("email", "string").addColumn("name", "string"),
     ),
@@ -955,20 +1020,20 @@ describe("getCreatedIds", () => {
 describe("Phase promises with multiple views", () => {
   it("should return only operations added to the current view when using retrievalPhase promise", async () => {
     // Create two separate schemas
-    const schema1 = schema((s) =>
+    const schema1 = schema("schema1", (s) =>
       s.addTable("users", (t) =>
         t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("email", "string"),
       ),
     );
 
-    const schema2 = schema((s) =>
+    const schema2 = schema("schema2", (s) =>
       s.addTable("posts", (t) =>
         t.addColumn("id", idColumn()).addColumn("title", "string").addColumn("content", "string"),
       ),
     );
 
     // Create a schema namespace map
-    const schemaNamespaceMap = new WeakMap<typeof schema1 | typeof schema2, string>();
+    const schemaNamespaceMap = new WeakMap<typeof schema1 | typeof schema2, string | null>();
     schemaNamespaceMap.set(schema1, "namespace1");
     schemaNamespaceMap.set(schema2, "namespace2");
 
@@ -1025,7 +1090,7 @@ describe("Phase promises with multiple views", () => {
   });
 
   it("should isolate operations when getUnitOfWork is called multiple times with same schema", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) =>
         t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("email", "string"),
       ),
@@ -1071,19 +1136,19 @@ describe("Phase promises with multiple views", () => {
   });
 
   it("should show that getCreatedIds returns ALL created IDs regardless of which view created them", async () => {
-    const schema1 = schema((s) =>
+    const schema1 = schema("schema1", (s) =>
       s.addTable("users", (t) =>
         t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("email", "string"),
       ),
     );
 
-    const schema2 = schema((s) =>
+    const schema2 = schema("schema2", (s) =>
       s.addTable("posts", (t) =>
         t.addColumn("id", idColumn()).addColumn("title", "string").addColumn("content", "string"),
       ),
     );
 
-    const schemaNamespaceMap = new WeakMap<typeof schema1 | typeof schema2, string>();
+    const schemaNamespaceMap = new WeakMap<typeof schema1 | typeof schema2, string | null>();
     schemaNamespaceMap.set(schema1, "namespace1");
     schemaNamespaceMap.set(schema2, "namespace2");
 
@@ -1126,19 +1191,19 @@ describe("Phase promises with multiple views", () => {
   });
 
   it("should generate unique IDs when multiple views create items", async () => {
-    const schema1 = schema((s) =>
+    const schema1 = schema("schema1", (s) =>
       s.addTable("users", (t) =>
         t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("email", "string"),
       ),
     );
 
-    const schema2 = schema((s) =>
+    const schema2 = schema("schema2", (s) =>
       s.addTable("posts", (t) =>
         t.addColumn("id", idColumn()).addColumn("title", "string").addColumn("content", "string"),
       ),
     );
 
-    const schemaNamespaceMap = new WeakMap<typeof schema1 | typeof schema2, string>();
+    const schemaNamespaceMap = new WeakMap<typeof schema1 | typeof schema2, string | null>();
     schemaNamespaceMap.set(schema1, "namespace1");
     schemaNamespaceMap.set(schema2, "namespace2");
 
@@ -1193,8 +1258,138 @@ describe("Phase promises with multiple views", () => {
   });
 });
 
+describe("Instrumentation", () => {
+  const testSchema = schema("test", (s) =>
+    s.addTable("users", (t) =>
+      t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("email", "string"),
+    ),
+  );
+
+  it("should run instrumentation hooks around retrieve and mutate phases", async () => {
+    const calls: string[] = [];
+    const contexts: Array<{
+      phase: string;
+      idempotencyKey: string;
+      retrievalOpsCount: number;
+      mutationOpsCount: number;
+    }> = [];
+
+    const executor = {
+      executeRetrievalPhase: async () => [[]],
+      executeMutationPhase: async () => ({ success: true, createdInternalIds: [] }),
+    };
+
+    const uow = new UnitOfWork(createMockCompiler(), executor, createMockDecoder(), undefined, {
+      instrumentation: {
+        beforeRetrieve: (ctx) => {
+          calls.push("beforeRetrieve");
+          contexts.push({
+            phase: ctx.phase,
+            idempotencyKey: ctx.idempotencyKey,
+            retrievalOpsCount: ctx.retrievalOpsCount,
+            mutationOpsCount: ctx.mutationOpsCount,
+          });
+        },
+        afterRetrieve: (ctx) => {
+          calls.push("afterRetrieve");
+          contexts.push({
+            phase: ctx.phase,
+            idempotencyKey: ctx.idempotencyKey,
+            retrievalOpsCount: ctx.retrievalOpsCount,
+            mutationOpsCount: ctx.mutationOpsCount,
+          });
+        },
+        beforeMutate: (ctx) => {
+          calls.push("beforeMutate");
+          contexts.push({
+            phase: ctx.phase,
+            idempotencyKey: ctx.idempotencyKey,
+            retrievalOpsCount: ctx.retrievalOpsCount,
+            mutationOpsCount: ctx.mutationOpsCount,
+          });
+        },
+        afterMutate: (ctx) => {
+          calls.push("afterMutate");
+          contexts.push({
+            phase: ctx.phase,
+            idempotencyKey: ctx.idempotencyKey,
+            retrievalOpsCount: ctx.retrievalOpsCount,
+            mutationOpsCount: ctx.mutationOpsCount,
+          });
+        },
+      },
+    });
+
+    const typed = uow.forSchema(testSchema);
+    typed.find("users", (b) => b.whereIndex("primary"));
+    typed.create("users", { name: "Alice", email: "alice@example.com" });
+
+    await uow.executeRetrieve();
+    await uow.executeMutations();
+
+    expect(calls).toEqual(["beforeRetrieve", "afterRetrieve", "beforeMutate", "afterMutate"]);
+
+    for (const ctx of contexts) {
+      expect(ctx.idempotencyKey).toBeTypeOf("string");
+      expect(ctx.idempotencyKey.length).toBeGreaterThan(0);
+      expect(ctx.retrievalOpsCount).toBe(1);
+      expect(ctx.mutationOpsCount).toBe(1);
+    }
+  });
+
+  it("should short-circuit mutations on conflict injection", async () => {
+    let mutationExecuted = false;
+
+    const executor = {
+      executeRetrievalPhase: async () => [],
+      executeMutationPhase: async () => {
+        mutationExecuted = true;
+        return { success: true, createdInternalIds: [] };
+      },
+    };
+
+    const uow = new UnitOfWork(createMockCompiler(), executor, createMockDecoder(), undefined, {
+      instrumentation: {
+        beforeMutate: () => ({ type: "conflict", reason: "Injected conflict" }),
+        afterMutate: () => {
+          throw new Error("afterMutate should not run");
+        },
+      },
+    });
+
+    uow.forSchema(testSchema).create("users", { name: "Alice", email: "alice@example.com" });
+
+    const result = await uow.executeMutations();
+    expect(result.success).toBe(false);
+    expect(mutationExecuted).toBe(false);
+  });
+
+  it("should throw on error injection before retrieval", async () => {
+    let retrievalExecuted = false;
+
+    const executor = {
+      executeRetrievalPhase: async () => {
+        retrievalExecuted = true;
+        return [];
+      },
+      executeMutationPhase: async () => ({ success: true, createdInternalIds: [] }),
+    };
+
+    const uow = new UnitOfWork(createMockCompiler(), executor, createMockDecoder(), undefined, {
+      instrumentation: {
+        beforeRetrieve: () => ({ type: "error", error: new Error("Injected failure") }),
+      },
+    });
+
+    uow.forSchema(testSchema).find("users", (b) => b.whereIndex("primary"));
+
+    await expect(uow.executeRetrieve()).rejects.toThrow("Injected failure");
+    expect(retrievalExecuted).toBe(false);
+  });
+});
+
 describe("Error Handling", () => {
-  const testSchema = schema((s) =>
+  const testSchema = schema("test", (s) =>
     s.addTable("users", (t) =>
       t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("email", "string"),
     ),
@@ -1479,7 +1674,7 @@ describe("Error Handling", () => {
 });
 
 describe("findFirst convenience method", () => {
-  const testSchema = schema((s) =>
+  const testSchema = schema("test", (s) =>
     s
       .addTable("users", (t) =>
         t