@fragno-dev/db 0.2.1 → 0.3.0

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

@@ -59,7 +59,7 @@ function createMockDecoder(): UOWDecoder {
 
 describe("UOW Coordinator - Parent-Child Execution", () => {
   it("should allow child UOWs to add operations and parent to execute them", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("users", (t) =>
         t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("email", "string"),
       ),
@@ -102,7 +102,7 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
   });
 
   it("should handle nested service calls that await phase promises without deadlock", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) =>
           t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("email", "string"),
@@ -176,7 +176,7 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
   });
 
   it("should handle retrieval-to-mutation flow with service composition", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) =>
           t
@@ -303,7 +303,7 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
   });
 
   it("should handle deeply nested child UOWs (3+ levels)", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) =>
           t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("email", "string"),
@@ -416,7 +416,7 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
   });
 
   it("should handle sibling child UOWs at same nesting level", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) =>
           t
@@ -526,7 +526,7 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
   });
 
   it("should support transaction rollback pattern", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("accounts", (t) =>
           t
@@ -633,7 +633,7 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
   });
 
   it("should handle errors thrown by service methods without unhandled rejections", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s
         .addTable("users", (t) =>
           t
@@ -722,55 +722,55 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
     // If we got here without Node.js throwing an unhandled rejection, the test passes
   });
 
-  it("should inherit nonce from parent to children for idempotent operations", () => {
+  it("should inherit idempotencyKey from parent to children for idempotent operations", () => {
     const executor = createMockExecutor();
     const parentUow = createUnitOfWork(createCompiler(), executor, createMockDecoder());
 
-    // Parent UOW should have a nonce
-    const parentNonce = parentUow.nonce;
-    expect(parentNonce).toBeDefined();
-    expect(typeof parentNonce).toBe("string");
-    expect(parentNonce.length).toBeGreaterThan(0);
+    // Parent UOW should have an idempotencyKey
+    const parentIdempotencyKey = parentUow.idempotencyKey;
+    expect(parentIdempotencyKey).toBeDefined();
+    expect(typeof parentIdempotencyKey).toBe("string");
+    expect(parentIdempotencyKey.length).toBeGreaterThan(0);
 
     // Create first child
     const child1 = parentUow.restrict();
-    expect(child1.nonce).toBe(parentNonce);
+    expect(child1.idempotencyKey).toBe(parentIdempotencyKey);
 
     // Create second child (sibling to child1)
     const child2 = parentUow.restrict();
-    expect(child2.nonce).toBe(parentNonce);
+    expect(child2.idempotencyKey).toBe(parentIdempotencyKey);
 
     // Create nested child (child of child1)
     const grandchild = child1.restrict();
-    expect(grandchild.nonce).toBe(parentNonce);
+    expect(grandchild.idempotencyKey).toBe(parentIdempotencyKey);
 
-    // All UOWs in the hierarchy should share the same nonce
-    expect(parentUow.nonce).toBe(child1.nonce);
-    expect(child1.nonce).toBe(child2.nonce);
-    expect(child2.nonce).toBe(grandchild.nonce);
+    // All UOWs in the hierarchy should share the same idempotencyKey
+    expect(parentUow.idempotencyKey).toBe(child1.idempotencyKey);
+    expect(child1.idempotencyKey).toBe(child2.idempotencyKey);
+    expect(child2.idempotencyKey).toBe(grandchild.idempotencyKey);
   });
 
-  it("should generate different nonces for separate UOW hierarchies", () => {
+  it("should generate different idempotencyKeys for separate UOW hierarchies", () => {
     const executor = createMockExecutor();
 
     // Create two separate parent UOWs
     const parentUow1 = createUnitOfWork(createCompiler(), executor, createMockDecoder());
     const parentUow2 = createUnitOfWork(createCompiler(), executor, createMockDecoder());
 
-    // They should have different nonces
-    expect(parentUow1.nonce).not.toBe(parentUow2.nonce);
+    // They should have different idempotencyKeys
+    expect(parentUow1.idempotencyKey).not.toBe(parentUow2.idempotencyKey);
 
-    // But children within each hierarchy should inherit their parent's nonce
+    // But children within each hierarchy should inherit their parent's idempotencyKey
     const child1 = parentUow1.restrict();
     const child2 = parentUow2.restrict();
 
-    expect(child1.nonce).toBe(parentUow1.nonce);
-    expect(child2.nonce).toBe(parentUow2.nonce);
-    expect(child1.nonce).not.toBe(child2.nonce);
+    expect(child1.idempotencyKey).toBe(parentUow1.idempotencyKey);
+    expect(child2.idempotencyKey).toBe(parentUow2.idempotencyKey);
+    expect(child1.idempotencyKey).not.toBe(child2.idempotencyKey);
   });
 
   it("should not cause unhandled rejection when service method awaits retrievalPhase and executeRetrieve fails", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("settings", (t) =>
         t
           .addColumn("id", idColumn())
@@ -830,7 +830,7 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
   });
 
   it("should allow child UOW to call getCreatedIds() after parent executes mutations", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("products", (t) =>
         t.addColumn("id", idColumn()).addColumn("name", "string").addColumn("price", "integer"),
       ),
@@ -862,7 +862,7 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
   });
 
   it("should preserve internal IDs in child UOW when using two-phase pattern with mutationPhase await", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("orders", (t) =>
         t
           .addColumn("id", idColumn())
@@ -916,7 +916,7 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
   });
 
   it("should fail when handler executes mutations before service finishes scheduling them (anti-pattern)", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("totp_secret", (t) =>
         t
           .addColumn("id", idColumn())
@@ -997,7 +997,7 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
   });
 
   it("should succeed when handler awaits service promise between phases (correct pattern)", async () => {
-    const testSchema = schema((s) =>
+    const testSchema = schema("test", (s) =>
       s.addTable("totp_secret", (t) =>
         t
           .addColumn("id", idColumn())

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

@@ -23,7 +23,7 @@ type InferJoinOut<T> =
 type InferJoinOutPrettify<T> = RecursivePrettify<InferJoinOut<T>>;
 
 describe("UnitOfWork type tests", () => {
-  const testSchema = schema((s) => {
+  const testSchema = schema("test", (s) => {
     return s
       .addTable("users", (t) => {
         return t