@fragno-dev/db 0.2.2 → 0.4.1

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

@@ -7,12 +7,13 @@
  * not the runtime behavior (which is covered by execute-unit-of-work.test.ts).
  */
 import { describe, expectTypeOf, it } from "vitest";
+
 import type { AnySchema } from "../../schema/create";
-import type { TypedUnitOfWork } from "./unit-of-work";
 import {
   ServiceTxBuilder,
   HandlerTxBuilder,
   type TxResult,
+  serviceCalls,
   type ServiceBuilderMutateContext,
   type HandlerBuilderMutateContext,
   type BuilderTransformContextWithMutate,
@@ -21,6 +22,7 @@ import {
   type ExtractServiceFinalResults,
   type AwaitedPromisesInObject,
 } from "./execute-unit-of-work";
+import type { TypedUnitOfWork } from "./unit-of-work";
 
 // =============================================================================
 // Helper types for extracting TxResult type parameters
@@ -552,6 +554,76 @@ describe("HandlerTxBuilder type inference", () => {
         readonly [{ user: { id: string } }]
       >();
     });
+
+    it("widens serviceIntermediateResult when serviceCalls is a non-tuple array", () => {
+      type Status = { status: string };
+      type HistoryPage = { runNumber: number };
+      type StatusCall = TxResult<Status, Status>;
+      type RunNumberCall = TxResult<number, number>;
+      type HistoryCall = TxResult<HistoryPage, HistoryPage>;
+
+      // When serviceCalls are built dynamically (e.g. Array.from + spread),
+      // the tuple shape is lost and results widen to a union array.
+      type ServiceCalls = readonly (StatusCall | RunNumberCall | HistoryCall)[];
+
+      type Builder = HandlerTxBuilder<
+        ServiceCalls,
+        [],
+        [],
+        unknown,
+        unknown,
+        false,
+        false,
+        true, // HasMutate
+        false,
+        {}
+      >;
+
+      type MutateParam = Parameters<Builder["mutate"]>[0];
+      type MutateCtx = Parameters<MutateParam>[0];
+
+      expectTypeOf<MutateCtx["serviceIntermediateResult"]>().toEqualTypeOf<
+        readonly (Status | number | HistoryPage)[]
+      >();
+    });
+
+    it("preserves tuple inference for dynamic serviceCalls when using helper", () => {
+      type Status = { status: string };
+      type HistoryPage = { runNumber: number };
+      type StatusCall = TxResult<Status, Status>;
+      type RunNumberCall = TxResult<number, number>;
+      type HistoryCall = TxResult<HistoryPage, HistoryPage>;
+
+      const statusCall = null as unknown as StatusCall;
+      const runNumberCall = null as unknown as RunNumberCall;
+      const historyCalls = [] as HistoryCall[];
+
+      const calls = serviceCalls(statusCall, runNumberCall, ...historyCalls);
+
+      expectTypeOf<typeof calls>().toEqualTypeOf<
+        readonly [StatusCall, RunNumberCall, ...HistoryCall[]]
+      >();
+
+      type Builder = HandlerTxBuilder<
+        typeof calls,
+        [],
+        [],
+        unknown,
+        unknown,
+        false,
+        false,
+        true, // HasMutate
+        false,
+        {}
+      >;
+
+      type MutateParam = Parameters<Builder["mutate"]>[0];
+      type MutateCtx = Parameters<MutateParam>[0];
+
+      expectTypeOf<MutateCtx["serviceIntermediateResult"]>().toEqualTypeOf<
+        readonly [Status, number, ...HistoryPage[]]
+      >();
+    });
   });
 
   describe("retrieve + transformRetrieve flow", () => {

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

@@ -1,5 +1,10 @@
 import { describe, it, expect } from "vitest";
+
+import { BetterSQLite3DriverConfig } from "../../adapters/generic-sql/driver-config";
+import { GenericSQLUOWOperationCompiler } from "../../adapters/generic-sql/query/generic-sql-uow-operation-compiler";
+import { createUOWCompilerFromOperationCompiler } from "../../adapters/shared/uow-operation-compiler";
 import { schema, idColumn, type FragnoId, referenceColumn } from "../../schema/create";
+import type { CompiledQuery } from "../../sql-driver/sql-driver";
 import {
   type UOWCompiler,
   type UOWDecoder,
@@ -7,10 +12,6 @@ import {
   type CompiledMutation,
   type UOWExecutor,
 } from "./unit-of-work";
-import { GenericSQLUOWOperationCompiler } from "../../adapters/generic-sql/query/generic-sql-uow-operation-compiler";
-import { BetterSQLite3DriverConfig } from "../../adapters/generic-sql/driver-config";
-import { createUOWCompilerFromOperationCompiler } from "../../adapters/shared/uow-operation-compiler";
-import type { CompiledQuery } from "../../sql-driver/sql-driver";
 
 // Create compiler using actual implementation
 function createCompiler(): UOWCompiler<CompiledQuery> {
@@ -59,7 +60,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 +103,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 +177,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 +304,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 +417,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 +527,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 +634,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
@@ -770,7 +771,7 @@ describe("UOW Coordinator - Parent-Child Execution", () => {
   });
 
   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 +831,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 +863,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 +917,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 +998,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

@@ -1,7 +1,8 @@
 import { describe, expectTypeOf, it } from "vitest";
+
 import { column, idColumn, referenceColumn, schema } from "../../schema/create";
-import { JoinFindBuilder, UnitOfWork } from "./unit-of-work";
 import type { FragnoId, FragnoReference } from "../../schema/create";
+import { JoinFindBuilder, UnitOfWork } from "./unit-of-work";
 
 type Prettify<T> = {
   [K in keyof T]: T[K];
@@ -23,7 +24,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
@@ -138,7 +139,6 @@ describe("UnitOfWork type tests", () => {
     const [_userResult] = await uow1.executeRetrieve();
     type UserResult = RecursivePrettify<(typeof _userResult)[number]>;
 
-    // @ts-expect-error assert type
     expectTypeOf<UserResult>().toEqualTypeOf<{
       id: FragnoId;
       name: string;
@@ -174,13 +174,8 @@ describe("UnitOfWork type tests", () => {
     type _JoinOutInviter = Prettify<_JoinOut["inviter"]>;
     //     ^?
 
-    // FIXME: There should not be a `{}` in the type
     expectTypeOf<_JoinOutInviter>().toEqualTypeOf<{
-      id: FragnoId;
       name: string;
-      email: string;
-      age: number | null;
-      invitedBy: FragnoReference | null;
     } | null>();
   });
 
@@ -194,14 +189,49 @@ describe("UnitOfWork type tests", () => {
     type _JoinOutPosts = Prettify<_JoinOut["posts"]>;
     //     ^?
 
-    // FIXME: There should not be a `{}` in the array
     expectTypeOf<_JoinOutPosts>().toEqualTypeOf<
       {
-        id: FragnoId;
         title: string;
-        content: string;
-        userId: FragnoReference;
       }[]
     >();
   });
+
+  it("preserves nested select narrowing in join builder", () => {
+    const builder = new JoinFindBuilder("users", testSchema.tables.users);
+
+    const _builderOut = builder.join((jb) =>
+      jb.posts((pb) => pb.select(["title"]).join((jb2) => jb2.author((ab) => ab.select(["name"])))),
+    );
+
+    type JoinOut = InferJoinOutPrettify<typeof _builderOut>;
+    type Post = Prettify<JoinOut["posts"][number]>;
+    type PostTitle = Post["title"];
+    type Author = Prettify<NonNullable<Post["author"]>>;
+
+    expectTypeOf<PostTitle>().toEqualTypeOf<string>();
+    expectTypeOf<Author>().toEqualTypeOf<{ name: string }>();
+  });
+
+  it("preserves nested select narrowing via UOW find", async () => {
+    const uow = createTestUOW();
+
+    const uow1 = uow.find("users", (b) =>
+      b
+        .whereIndex("primary")
+        .join((jb) =>
+          jb.posts((pb) =>
+            pb.select(["title"]).join((jb2) => jb2.author((ab) => ab.select(["name"]))),
+          ),
+        ),
+    );
+
+    const [_userResult] = await uow1.executeRetrieve();
+    type User = RecursivePrettify<(typeof _userResult)[number]>;
+    type Post = Prettify<User["posts"][number]>;
+    type PostTitle = Post["title"];
+    type Author = Prettify<NonNullable<Post["author"]>>;
+
+    expectTypeOf<PostTitle>().toEqualTypeOf<string>();
+    expectTypeOf<Author>().toEqualTypeOf<{ name: string }>();
+  });
 });