@fragno-dev/db 0.1.13 → 0.1.14

package/src/mod.ts

@@ -131,6 +131,25 @@ export {
   DatabaseFragmentBuilder,
   type FragnoPublicConfigWithDatabase,
   type DatabaseFragmentContext,
+  type DatabaseRouteHandler,
 } from "./fragment";
 
 export { decodeCursor, type CursorData } from "./query/cursor";
+
+export {
+  createUnitOfWork,
+  UnitOfWork,
+  UnitOfWorkSchemaView,
+  type IUnitOfWorkBase,
+  type UOWCompiler,
+  type UOWExecutor,
+  type UOWDecoder,
+} from "./query/unit-of-work";
+
+export {
+  withUnitOfWork,
+  serviceContext,
+  uowStorage,
+  type DatabaseRequestThisContext,
+} from "./fragment";
+export { type BoundServices } from "./bind-services";

package/src/query/query.ts

@@ -82,7 +82,7 @@ export type OrderBy<Column = string> = [columnName: Column, "asc" | "desc"];
  * Extract Select type parameter from a FindBuilder type (handles Omit wrapper)
  * @internal
  */
-type ExtractSelect<T> =
+export type ExtractSelect<T> =
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   T extends FindBuilder<any, infer TSelect, any>
     ? TSelect
@@ -95,7 +95,7 @@ type ExtractSelect<T> =
  * Extract JoinOut type parameter from a FindBuilder type (handles Omit wrapper)
  * @internal
  */
-type ExtractJoinOut<T> =
+export type ExtractJoinOut<T> =
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   T extends FindBuilder<any, any, infer TJoinOut>
     ? TJoinOut

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

@@ -0,0 +1,64 @@
+import { describe, test } from "vitest";
+import { schema, column, idColumn, referenceColumn } from "../schema/create";
+import type { UOWCompiler, UOWExecutor, UOWDecoder } from "./unit-of-work";
+import { createUnitOfWork } from "./unit-of-work";
+
+// Test schemas
+const schema1 = schema((s) =>
+  s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", column("string"))),
+);
+
+const schema2 = schema((s) =>
+  s.addTable("posts", (t) =>
+    t
+      .addColumn("id", idColumn())
+      .addColumn("userId", referenceColumn())
+      .addColumn("title", column("string")),
+  ),
+);
+
+// Mock compiler, executor, and decoder
+const mockCompiler: UOWCompiler<string> = {
+  compileRetrievalOperation: (op) => `RETRIEVE-${op.type}-${op.table.name}-${op.indexName}`,
+  compileMutationOperation: (op) => ({
+    query: `MUTATE-${op.type}`,
+    expectedAffectedRows: null,
+  }),
+};
+
+const mockExecutor: UOWExecutor<string, string> = {
+  executeRetrievalPhase: async (queries) => queries.map((q) => `RESULT-${q}`),
+  executeMutationPhase: async () => ({ success: true, createdInternalIds: [] }),
+};
+
+const mockDecoder: UOWDecoder<string> = (rawResults) => rawResults.map((r) => ({ decoded: r }));
+
+describe("Multi-Schema Unit of Work", () => {
+  test("chained operations on view accumulate result types", async () => {
+    const uow = createUnitOfWork(schema1, mockCompiler, mockExecutor, mockDecoder);
+
+    // Chain multiple finds on same view
+    const _view1 = uow
+      .forSchema(schema1)
+      .find("users", (b) => b.whereIndex("primary").select(["id"]))
+      .find("users", (b) => b.whereIndex("primary").select(["name"]));
+
+    const _view2 = uow
+      .forSchema(schema2)
+      .find("posts", (b) => b.whereIndex("primary").select(["title"]));
+
+    await uow.executeRetrieve();
+
+    // const [[users1, users2], [posts]] = await Promise.all([view1.retrievalPhase, view2.retrievalPhase]);
+
+    // const [users1, users2] = await view1.retrievalPhase;
+
+    // // expect(users1)
+
+    // // expectTypeOf(users1).toMatchObjectType<{ id: FragnoId; name: string }[]>();
+    // console.log({ users1, users2 });
+
+    // const [posts] = await view2.retrievalPhase;
+    // console.log({ posts });
+  });
+});

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

@@ -114,6 +114,19 @@ describe("UnitOfWork type tests", () => {
     }>();
   });
 
+  it("should type find with select clause correctly", async () => {
+    const uow = createTestUOW();
+
+    const uow1 = uow.find("users", (b) => b.whereIndex("primary").select(["id", "name"]));
+    const [_userResult] = await uow1.executeRetrieve();
+    type UserResult = RecursivePrettify<(typeof _userResult)[number]>;
+
+    expectTypeOf<UserResult>().toEqualTypeOf<{
+      id: FragnoId;
+      name: string;
+    }>();
+  });
+
   it("should type find with joins correctly", async () => {
     const uow = createTestUOW();
 

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

@@ -9,14 +9,10 @@ import {
   type IndexColumns,
 } from "./unit-of-work";
 import { createIndexedBuilder } from "./condition-builder";
-import type { AnySchema } from "../schema/create";
 import type { AbstractQuery } from "./query";
 
 // Mock compiler and executor for testing
-function createMockCompiler<TSchema extends AnySchema = AnySchema>(): UOWCompiler<
-  TSchema,
-  unknown
-> {
+function createMockCompiler(): UOWCompiler<unknown> {
   return {
     compileRetrievalOperation: () => null,
     compileMutationOperation: () => null,
@@ -30,7 +26,7 @@ function createMockExecutor() {
   };
 }
 
-function createMockDecoder<TSchema extends AnySchema = AnySchema>(): UOWDecoder<TSchema> {
+function createMockDecoder(): UOWDecoder {
   return (rawResults, operations) => {
     if (rawResults.length !== operations.length) {
       throw new Error("rawResults and operations must have the same length");
@@ -706,16 +702,16 @@ describe("IndexedConditionBuilder", () => {
 
       const uow = createUnitOfWork(
         typeTestSchema,
-        createMockCompiler<typeof typeTestSchema>(),
+        createMockCompiler(),
         createMockExecutor(),
-        createMockDecoder<typeof typeTestSchema>(),
+        createMockDecoder(),
       );
       expectTypeOf(uow.schema).toEqualTypeOf(typeTestSchema);
       expectTypeOf<keyof typeof typeTestSchema.tables>().toEqualTypeOf<"users">();
       type _Query = AbstractQuery<typeof typeTestSchema>;
       expectTypeOf<Parameters<_Query["create"]>[0]>().toEqualTypeOf<"users">();
 
-      expectTypeOf(uow.find).parameter(0).toEqualTypeOf<"users">();
+      expectTypeOf<Parameters<typeof uow.find>[0]>().toEqualTypeOf<"users">();
 
       uow.find("users", (b) =>
         b.whereIndex("primary", (eb) => {