@fragno-dev/db 0.3.0 → 0.4.1

package/src/adapters/in-memory/in-memory-adapter.ts

@@ -1,30 +1,44 @@
 import { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
+
+import { getOutboxConfigForAdapter } from "../../internal/outbox-state";
+import {
+  createNamingResolver,
+  suffixNamingStrategy,
+  type SqlNamingStrategy,
+} from "../../naming/sql-naming";
+import type { CursorResult } from "../../query/cursor";
+import { dbInterval, dbNow, type DbIntervalInput, type DbInterval } from "../../query/db-now";
+import type {
+  SimpleQueryInterface,
+  TableToUpdateValues,
+  SelectResult,
+  ExtractJoinOut,
+  ExtractSelect,
+  SelectClause,
+} from "../../query/simple-query-interface";
+import {
+  UnitOfWork,
+  type UnitOfWorkConfig,
+  type FindBuilder,
+} from "../../query/unit-of-work/unit-of-work";
+import type { AnySchema, AnyTable, FragnoId } from "../../schema/create";
 import {
   fragnoDatabaseAdapterNameFakeSymbol,
   fragnoDatabaseAdapterVersionFakeSymbol,
   type DatabaseAdapter,
   type DatabaseContextStorage,
 } from "../adapters";
-import type { AnySchema, AnyTable, FragnoId } from "../../schema/create";
-import type { SimpleQueryInterface, TableToUpdateValues } from "../../query/simple-query-interface";
-import {
-  resolveInMemoryAdapterOptions,
-  type InMemoryAdapterOptions,
-  type ResolvedInMemoryAdapterOptions,
-} from "./options";
-import { createInMemoryStore, ensureNamespaceStore } from "./store";
 import {
   createInMemoryUowCompiler,
   createInMemoryUowExecutor,
   InMemoryUowDecoder,
 } from "./in-memory-uow";
-import { UnitOfWork, type UnitOfWorkConfig } from "../../query/unit-of-work/unit-of-work";
-import type { CursorResult } from "../../query/cursor";
 import {
-  createNamingResolver,
-  suffixNamingStrategy,
-  type SqlNamingStrategy,
-} from "../../naming/sql-naming";
+  resolveInMemoryAdapterOptions,
+  type InMemoryAdapterOptions,
+  type ResolvedInMemoryAdapterOptions,
+} from "./options";
+import { createInMemoryStore, ensureNamespaceStore } from "./store";
 
 class UpdateManySpecialBuilder<TTable extends AnyTable> {
   #indexName?: string;
@@ -42,6 +56,14 @@ class UpdateManySpecialBuilder<TTable extends AnyTable> {
     return this;
   }
 
+  now() {
+    return dbNow();
+  }
+
+  interval(input: DbIntervalInput): DbInterval {
+    return dbInterval(input);
+  }
+
   getConfig() {
     return {
       indexName: this.#indexName,
@@ -69,6 +91,7 @@ export class InMemoryAdapter implements DatabaseAdapter<InMemoryUowConfig> {
     this.options = resolveInMemoryAdapterOptions(options);
     this.namingStrategy = options.namingStrategy ?? suffixNamingStrategy;
     this.#contextStorage = new RequestContextStorage();
+    this.options.outbox = getOutboxConfigForAdapter(this);
   }
 
   get [fragnoDatabaseAdapterNameFakeSymbol](): string {
@@ -116,10 +139,15 @@ export class InMemoryAdapter implements DatabaseAdapter<InMemoryUowConfig> {
     ensureNamespaceStore(this.#store, namespaceKey, schema, resolver);
 
     const compiler = createInMemoryUowCompiler();
-    const executor = createInMemoryUowExecutor(this.#store, this.options, resolverFactory);
+    const executor = createInMemoryUowExecutor(
+      this.#store,
+      this.options,
+      resolverFactory,
+      this.#schemaByNamespace,
+    );
     const decoder = new InMemoryUowDecoder(resolverFactory);
 
-    const createUow = (opts?: { name?: string; config?: UnitOfWorkConfig }) =>
+    const createBaseUow = (opts?: { name?: string; config?: UnitOfWorkConfig }) =>
       new UnitOfWork(
         compiler,
         executor,
@@ -127,36 +155,115 @@ export class InMemoryAdapter implements DatabaseAdapter<InMemoryUowConfig> {
         opts?.name,
         opts?.config,
         this.#schemaNamespaceMap,
-      ).forSchema(schema);
+      );
 
-    const queryEngine = {
-      now: async () => this.options.clock.now(),
-      async find(tableName, builderFn) {
-        const uow = createUow();
+    const createUow = (opts?: { name?: string; config?: UnitOfWorkConfig }) =>
+      createBaseUow(opts).forSchema(schema);
+
+    async function find<TableName extends keyof T["tables"] & string, const TBuilderResult>(
+      tableName: TableName,
+      builderFn: (builder: Omit<FindBuilder<T["tables"][TableName]>, "build">) => TBuilderResult,
+    ): Promise<
+      SelectResult<
+        T["tables"][TableName],
+        ExtractJoinOut<TBuilderResult>,
+        Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+      >[]
+    >;
+    async function find<TableName extends keyof T["tables"] & string>(
+      tableName: TableName,
+    ): Promise<SelectResult<T["tables"][TableName], {}, true>[]>;
+    async function find<TableName extends keyof T["tables"] & string, const TBuilderResult>(
+      tableName: TableName,
+      builderFn?: (builder: Omit<FindBuilder<T["tables"][TableName]>, "build">) => TBuilderResult,
+    ): Promise<
+      SelectResult<
+        T["tables"][TableName],
+        ExtractJoinOut<TBuilderResult>,
+        Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+      >[]
+    > {
+      const uow = createUow();
+      if (builderFn) {
         uow.find(tableName, builderFn);
-        const [result]: unknown[][] = await uow.executeRetrieve();
-        return result ?? [];
-      },
+      } else {
+        uow.find(tableName);
+      }
+      const [result]: unknown[][] = await uow.executeRetrieve();
+      return (result ?? []) as SelectResult<
+        T["tables"][TableName],
+        ExtractJoinOut<TBuilderResult>,
+        Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+      >[];
+    }
 
-      async findWithCursor(tableName, builderFn) {
-        const uow = createUow().findWithCursor(tableName, builderFn);
-        const [result] = await uow.executeRetrieve();
-        return result as CursorResult<unknown>;
-      },
+    async function findWithCursor<
+      TableName extends keyof T["tables"] & string,
+      const TBuilderResult,
+    >(
+      tableName: TableName,
+      builderFn: (builder: Omit<FindBuilder<T["tables"][TableName]>, "build">) => TBuilderResult,
+    ): Promise<
+      CursorResult<
+        SelectResult<
+          T["tables"][TableName],
+          ExtractJoinOut<TBuilderResult>,
+          Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+        >
+      >
+    > {
+      const uow = createUow().findWithCursor(tableName, builderFn);
+      const [result] = await uow.executeRetrieve();
+      return result as CursorResult<
+        SelectResult<
+          T["tables"][TableName],
+          ExtractJoinOut<TBuilderResult>,
+          Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+        >
+      >;
+    }
 
-      async findFirst(tableName, builderFn) {
-        const uow = createUow();
-        if (builderFn) {
-          uow.find(tableName, (b) => {
-            builderFn(b);
-            return b.pageSize(1);
-          });
-        } else {
-          uow.find(tableName, (b) => b.whereIndex("primary").pageSize(1));
-        }
-        const [result]: unknown[][] = await uow.executeRetrieve();
-        return result?.[0] ?? null;
-      },
+    async function findFirst<TableName extends keyof T["tables"] & string, const TBuilderResult>(
+      tableName: TableName,
+      builderFn: (builder: Omit<FindBuilder<T["tables"][TableName]>, "build">) => TBuilderResult,
+    ): Promise<SelectResult<
+      T["tables"][TableName],
+      ExtractJoinOut<TBuilderResult>,
+      Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+    > | null>;
+    async function findFirst<TableName extends keyof T["tables"] & string>(
+      tableName: TableName,
+    ): Promise<SelectResult<T["tables"][TableName], {}, true> | null>;
+    async function findFirst<TableName extends keyof T["tables"] & string, const TBuilderResult>(
+      tableName: TableName,
+      builderFn?: (builder: Omit<FindBuilder<T["tables"][TableName]>, "build">) => TBuilderResult,
+    ): Promise<SelectResult<
+      T["tables"][TableName],
+      ExtractJoinOut<TBuilderResult>,
+      Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+    > | null> {
+      const uow = createUow();
+      if (builderFn) {
+        uow.find(tableName, (b) => {
+          builderFn(b);
+          return b.pageSize(1);
+        });
+      } else {
+        uow.find(tableName, (b) => b.whereIndex("primary").pageSize(1));
+      }
+      const [result]: unknown[][] = await uow.executeRetrieve();
+      return (result?.[0] ?? null) as SelectResult<
+        T["tables"][TableName],
+        ExtractJoinOut<TBuilderResult>,
+        Extract<ExtractSelect<TBuilderResult>, SelectClause<T["tables"][TableName]>>
+      > | null;
+    }
+
+    const queryEngine: SimpleQueryInterface<T, InMemoryUowConfig> = {
+      now: async () => this.options.clock.now(),
+      find,
+      findWithCursor,
+      findFirst,
 
       async create(tableName, values) {
         const uow = createUow();
@@ -237,7 +344,7 @@ export class InMemoryAdapter implements DatabaseAdapter<InMemoryUowConfig> {
         }
       },
 
-      async delete(tableName, id, builderFn) {
+      async delete(tableName, id, builderFn?) {
         const uow = createUow();
         uow.delete(tableName, id, builderFn);
         const { success } = await uow.executeMutations();
@@ -271,7 +378,11 @@ export class InMemoryAdapter implements DatabaseAdapter<InMemoryUowConfig> {
       createUnitOfWork(name, config) {
         return createUow({ name, config });
       },
-    } as SimpleQueryInterface<T, InMemoryUowConfig>;
+
+      createBaseUnitOfWork(name, config) {
+        return createBaseUow({ name, config });
+      },
+    };
     return queryEngine;
   }
 }

package/src/adapters/in-memory/in-memory-uow.mutations.test.ts

@@ -1,14 +1,15 @@
 import { describe, expect, it } from "vitest";
+
+import { UnitOfWork } from "../../query/unit-of-work/unit-of-work";
 import type { AnySchema } from "../../schema/create";
 import { column, idColumn, schema, FragnoId, referenceColumn } from "../../schema/create";
-import { UnitOfWork } from "../../query/unit-of-work/unit-of-work";
-import { createInMemoryStore } from "./store";
 import {
   createInMemoryUowCompiler,
   createInMemoryUowExecutor,
   InMemoryUowDecoder,
 } from "./in-memory-uow";
 import { resolveInMemoryAdapterOptions, type InMemoryAdapterOptions } from "./options";
+import { createInMemoryStore } from "./store";
 
 const testSchema = schema("test", (s) =>
   s.addTable("users", (t) => t.addColumn("id", idColumn()).addColumn("name", column("string"))),
@@ -30,6 +31,28 @@ const fkSchema = schema("fk", (s) =>
     }),
 );
 
+const joinOnlySchema = schema("join-only", (s) =>
+  s
+    .addTable("users", (t) =>
+      t
+        .addColumn("id", idColumn())
+        .addColumn("email", column("string"))
+        .createIndex("users_email_idx", ["email"], { unique: true }),
+    )
+    .addTable("invitations", (t) =>
+      t
+        .addColumn("id", idColumn())
+        .addColumn("email", column("string"))
+        .createIndex("invitations_email_idx", ["email"]),
+    )
+    .addReference("invitedUser", {
+      type: "one",
+      from: { table: "invitations", column: "email" },
+      to: { table: "users", column: "email" },
+      foreignKey: false,
+    }),
+);
+
 const createTestUowFactory = () => {
   const store = createInMemoryStore();
   const options = resolveInMemoryAdapterOptions({ idSeed: "seed" });
@@ -211,6 +234,31 @@ describe("in-memory uow mutations", () => {
     await expect(deleteUser.executeMutations()).rejects.toThrow("Foreign key constraint violation");
   });
 
+  it("does not enforce join-only relations as foreign keys", async () => {
+    const { createUow } = createUowFactoryWithOptions(joinOnlySchema);
+
+    const createInvitation = createUow();
+    createInvitation.create("invitations", { id: "invite-1", email: "missing@example.com" });
+    const createInvitationResult = await createInvitation.executeMutations();
+    expect(createInvitationResult.success).toBe(true);
+
+    const createUser = createUow();
+    createUser.create("users", { id: "user-1", email: "user@example.com" });
+    const createUserResult = await createUser.executeMutations();
+    expect(createUserResult.success).toBe(true);
+
+    const userId = createUser.getCreatedIds()[0]!;
+    const createInvitation2 = createUow();
+    createInvitation2.create("invitations", { id: "invite-2", email: "user@example.com" });
+    const createInvitation2Result = await createInvitation2.executeMutations();
+    expect(createInvitation2Result.success).toBe(true);
+
+    const deleteUser = createUow();
+    deleteUser.delete("users", userId, (b) => b.check());
+    const deleteUserResult = await deleteUser.executeMutations();
+    expect(deleteUserResult.success).toBe(true);
+  });
+
   it("uses custom internal id generators when provided", async () => {
     let current = 9n;
     const internalIdGenerator = () => {

package/src/adapters/in-memory/in-memory-uow.retrieval.test.ts

@@ -1,14 +1,22 @@
 import { describe, expect, it } from "vitest";
-import { column, idColumn, referenceColumn, schema, type AnySchema } from "../../schema/create";
+
+import type { CompiledJoin } from "../../query/orm/orm";
 import { UnitOfWork, type RetrievalOperation } from "../../query/unit-of-work/unit-of-work";
-import { createInMemoryStore } from "./store";
+import {
+  column,
+  ExplicitRelationInit,
+  idColumn,
+  referenceColumn,
+  schema,
+  type AnySchema,
+} from "../../schema/create";
 import {
   createInMemoryUowCompiler,
   createInMemoryUowExecutor,
   InMemoryUowDecoder,
 } from "./in-memory-uow";
 import { resolveInMemoryAdapterOptions } from "./options";
-import type { CompiledJoin } from "../../query/orm/orm";
+import { createInMemoryStore } from "./store";
 
 const joinSchema = schema("join", (s) =>
   s
@@ -25,13 +33,36 @@ const joinSchema = schema("join", (s) =>
         .addColumn("title", column("string"))
         .addColumn("authorId", referenceColumn()),
     )
+    .addTable("memberships", (t) =>
+      t
+        .addColumn("id", idColumn())
+        .addColumn("userId", referenceColumn())
+        .createIndex("idx_memberships_user", ["userId"]),
+    )
     .addReference("author", {
       type: "one",
       from: { table: "posts", column: "authorId" },
       to: { table: "users", column: "id" },
+    })
+    .addReference("membershipUser", {
+      type: "one",
+      from: { table: "memberships", column: "userId" },
+      to: { table: "users", column: "id" },
+    })
+    .addReference("memberships", {
+      type: "many",
+      from: { table: "users", column: "id" },
+      to: { table: "memberships", column: "userId" },
+      foreignKey: false,
     }),
 );
 
+const externalJoinSchema = schema("external-join", (s) =>
+  s
+    .addTable("left", (t) => t.addColumn("id", idColumn()).addColumn("label", column("string")))
+    .addTable("right", (t) => t.addColumn("id", idColumn()).addColumn("label", column("string"))),
+);
+
 const createHarness = () => {
   const store = createInMemoryStore();
   const options = resolveInMemoryAdapterOptions({ idSeed: "seed" });
@@ -45,6 +76,18 @@ const createHarness = () => {
   };
 };
 
+const createExternalJoinHarness = () => {
+  const store = createInMemoryStore();
+  const options = resolveInMemoryAdapterOptions({ idSeed: "seed" });
+  const compiler = createInMemoryUowCompiler();
+  const executor = createInMemoryUowExecutor(store, options);
+  const decoder = new InMemoryUowDecoder();
+
+  return {
+    createUow: () => new UnitOfWork(compiler, executor, decoder).forSchema(externalJoinSchema),
+  };
+};
+
 describe("in-memory uow retrieval", () => {
   it("throws when joins use orderBy instead of orderByIndex", async () => {
     const { createUow, executor } = createHarness();
@@ -97,4 +140,116 @@ describe("in-memory uow retrieval", () => {
       'In-memory adapter only supports orderByIndex; received orderBy on table "users".',
     );
   });
+
+  it("joins join-only relations using left-side id coercion", async () => {
+    const { createUow } = createHarness();
+
+    const createData = createUow();
+    createData.create("users", {
+      id: "user-1",
+      name: "Ada",
+      email: "ada@example.com",
+    });
+    createData.create("memberships", {
+      id: "membership-1",
+      userId: "user-1",
+    });
+    await createData.executeMutations();
+
+    const query = createUow();
+    query.find("users", (b) =>
+      b
+        .whereIndex("primary", (eb) => eb("id", "=", "user-1"))
+        .join((jb) => jb.memberships((mb) => mb.select(["id"]))),
+    );
+
+    const [users] = (await query.executeRetrieve()) as Array<
+      Array<{ memberships?: { id: { externalId: string } } }>
+    >;
+
+    expect(users).toHaveLength(1);
+    expect(users[0].memberships).toMatchObject({
+      id: expect.objectContaining({ externalId: "membership-1" }),
+    });
+  });
+
+  it("joins external-id relations without coercing both sides to internal ids", async () => {
+    const { createUow } = createExternalJoinHarness();
+
+    const relationInit = new ExplicitRelationInit(
+      "one",
+      externalJoinSchema.tables.right,
+      externalJoinSchema.tables.left,
+      { foreignKey: false },
+    );
+    relationInit.on.push(["id", "id"]);
+    const relation = relationInit.init("rightMatch");
+    externalJoinSchema.tables.left.relations["rightMatch"] = relation;
+
+    const createData = createUow();
+    createData.create("left", {
+      id: "left-1",
+      label: "Left One",
+    });
+    createData.create("left", {
+      id: "shared-id",
+      label: "Left Shared",
+    });
+    createData.create("right", {
+      id: "shared-id",
+      label: "Right Shared",
+    });
+    await createData.executeMutations();
+
+    const query = createUow();
+    query.find("left", (b) =>
+      b
+        .whereIndex("primary", (eb) => eb("id", "=", "shared-id"))
+        .join((jb) => jb["rightMatch"]((rb) => rb.select(["id", "label"]))),
+    );
+
+    const [rows] = (await query.executeRetrieve()) as Array<
+      Array<{ rightMatch?: { id: { externalId: string }; label: string } }>
+    >;
+
+    expect(rows).toHaveLength(1);
+    expect(rows[0].rightMatch).toMatchObject({
+      id: expect.objectContaining({ externalId: "shared-id" }),
+      label: "Right Shared",
+    });
+  });
+
+  it("applies page size after filtering primary-index lookups", async () => {
+    const { createUow } = createHarness();
+
+    const createData = createUow();
+    createData.create("users", {
+      id: "user-1",
+      name: "Ada",
+      email: "ada@example.com",
+    });
+    createData.create("users", {
+      id: "user-2",
+      name: "Grace",
+      email: "grace@example.com",
+    });
+    await createData.executeMutations();
+
+    const query = createUow();
+    query.findFirst("users", (b) => b.whereIndex("primary", (eb) => eb("id", "=", "user-2")));
+
+    const [[user]] = (await query.executeRetrieve()) as Array<
+      [
+        {
+          id: { externalId: string };
+          name: string;
+        } | null,
+      ]
+    >;
+
+    expect(user).toMatchObject({
+      id: expect.objectContaining({ externalId: "user-2" }),
+      name: "Grace",
+    });
+  });
 });