@fragno-dev/db 0.2.2 → 0.4.1

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

@@ -1,14 +1,16 @@
 import { describe, it, expect, assert, expectTypeOf } from "vitest";
+
 import { column, schema, idColumn, FragnoId } from "../../schema/create";
+import { createIndexedBuilder } from "../condition-builder";
+import type { SimpleQueryInterface } from "../simple-query-interface";
 import {
   type UOWCompiler,
   type UOWDecoder,
   createUnitOfWork,
+  UnitOfWork,
   type InferIdColumnName,
   type IndexColumns,
 } from "./unit-of-work";
-import { createIndexedBuilder } from "../condition-builder";
-import type { SimpleQueryInterface } from "../simple-query-interface";
 
 // Mock compiler and executor for testing
 function createMockCompiler(): UOWCompiler<unknown> {
@@ -38,7 +40,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 +61,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 +84,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 +104,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 +124,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 +144,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 +168,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 +179,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 +192,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 +207,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 +230,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 +259,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 +293,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 +327,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 +375,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 +420,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 +455,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 +500,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 +566,7 @@ describe("FindBuilder", () => {
 });
 
 describe("IndexedConditionBuilder", () => {
-  const testSchema = schema((s) =>
+  const testSchema = schema("test", (s) =>
     s.addTable("users", (t) =>
       t
         .addColumn("id", idColumn())
@@ -585,7 +587,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 +714,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 +772,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 +808,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")),
   );
 
@@ -839,7 +841,7 @@ describe("DeleteBuilder with string ID", () => {
 });
 
 describe("generateId", () => {
-  const testSchema = schema((s) =>
+  const testSchema = schema("test", (s) =>
     s.addTable("users", (t) =>
       t.addColumn("id", idColumn()).addColumn("email", "string").addColumn("name", "string"),
     ),
@@ -903,7 +905,7 @@ describe("generateId", () => {
 });
 
 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"),
     ),
@@ -1019,20 +1021,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");
 
@@ -1089,7 +1091,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"),
       ),
@@ -1135,19 +1137,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");
 
@@ -1190,19 +1192,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");
 
@@ -1257,8 +1259,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"),
     ),
@@ -1543,7 +1675,7 @@ describe("Error Handling", () => {
 });
 
 describe("findFirst convenience method", () => {
-  const testSchema = schema((s) =>
+  const testSchema = schema("test", (s) =>
     s
       .addTable("users", (t) =>
         t
@@ -1778,3 +1910,28 @@ describe("findFirst convenience method", () => {
     expect(ops[0]?.indexName).toBe("_primary");
   });
 });
+
+describe("triggerHook namespace resolution", () => {
+  it("should fall back to schema name when namespace is null", () => {
+    const hooksSchema = schema("hooks_test", (s) =>
+      s.addTable("events", (t) => t.addColumn("id", idColumn())),
+    );
+    const uow = createUnitOfWork(createMockCompiler(), createMockExecutor(), createMockDecoder());
+    uow.registerSchema(hooksSchema, null);
+
+    const hooks = {
+      onTest: (_payload: { value: string }) => {},
+    };
+
+    const typedUow = uow.forSchema(hooksSchema, hooks);
+    typedUow.triggerHook("onTest", { value: "ok" });
+
+    const triggeredHooks = uow.getTriggeredHooks();
+    expect(triggeredHooks).toHaveLength(1);
+    expect(triggeredHooks[0]).toMatchObject({
+      namespace: hooksSchema.name,
+      hookName: "onTest",
+      payload: { value: "ok" },
+    });
+  });
+});