@fragno-dev/db 0.3.0 → 0.4.1

package/src/adapters/in-memory/outbox.test.ts

@@ -0,0 +1,361 @@
+import { describe, expect, it } from "vitest";
+
+import superjson, { type SuperJSONResult } from "superjson";
+
+import { defineFragment, instantiate } from "@fragno-dev/core";
+
+import type { InternalFragmentInstance } from "../../fragments/internal-fragment";
+import { internalSchema } from "../../fragments/internal-fragment";
+import { getInternalFragment } from "../../internal/adapter-registry";
+import type { AnyFragnoInstantiatedDatabaseFragment, DatabaseRequestContext } from "../../mod";
+import type { OutboxEntry, OutboxPayload } from "../../outbox/outbox";
+import { schema, idColumn, column, referenceColumn, FragnoReference } from "../../schema/create";
+import { withDatabase } from "../../with-database";
+import { InMemoryAdapter } from "./in-memory-adapter";
+
+const buildOutboxSchema = () =>
+  schema("outbox", (s) => {
+    return s
+      .addTable("users", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("email", column("string"))
+          .createIndex("idx_users_email", ["email"], { unique: true });
+      })
+      .addTable("posts", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("authorId", referenceColumn())
+          .addColumn("title", column("string"));
+      })
+      .addReference("author", {
+        type: "one",
+        from: { table: "posts", column: "authorId" },
+        to: { table: "users", column: "id" },
+      });
+  });
+
+const outboxSchema = buildOutboxSchema();
+
+const outboxFragmentName = "outbox-in-memory-test";
+const outboxFragmentDef = defineFragment(outboxFragmentName)
+  .extend(withDatabase(outboxSchema))
+  .build();
+
+type OutboxTestContext = {
+  fragment: AnyFragnoInstantiatedDatabaseFragment<typeof outboxSchema>;
+  internalFragment: InternalFragmentInstance;
+  cleanup: () => Promise<void>;
+};
+
+async function buildOutboxTest(options: { outboxEnabled?: boolean }): Promise<OutboxTestContext> {
+  const adapter = new InMemoryAdapter({
+    idSeed: "outbox-seed",
+  });
+
+  const fragment = instantiate(outboxFragmentDef)
+    .withConfig({})
+    .withRoutes([])
+    .withOptions({
+      databaseAdapter: adapter,
+      outbox: options.outboxEnabled ? { enabled: true } : undefined,
+    })
+    .build();
+
+  return {
+    fragment,
+    internalFragment: getInternalFragment(adapter),
+    cleanup: async () => {
+      await adapter.close();
+    },
+  };
+}
+
+async function listOutbox(
+  internalFragment: InternalFragmentInstance,
+  options?: { afterVersionstamp?: string; limit?: number },
+): Promise<OutboxEntry[]> {
+  return internalFragment.inContext(async function (this: DatabaseRequestContext) {
+    return (await this.handlerTx()
+      .withServiceCalls(() => [internalFragment.services.outboxService.list(options)] as const)
+      .transform(({ serviceResult: [result] }) => result)
+      .execute()) as OutboxEntry[];
+  });
+}
+
+async function listOutboxMutations(internalFragment: InternalFragmentInstance): Promise<
+  Array<{
+    entryVersionstamp: string;
+    mutationVersionstamp: string;
+    uowId: string;
+    schema: string;
+    table: string;
+    externalId: string;
+    op: string;
+  }>
+> {
+  return internalFragment.inContext(async function (this: DatabaseRequestContext) {
+    return await this.handlerTx()
+      .retrieve(({ forSchema }) =>
+        forSchema(internalSchema).find("fragno_db_outbox_mutations", (b) =>
+          b
+            .whereIndex("idx_outbox_mutations_entry")
+            .orderByIndex("idx_outbox_mutations_entry", "asc"),
+        ),
+      )
+      .transformRetrieve(([result]) => result)
+      .execute();
+  });
+}
+
+async function createUser(
+  fragment: AnyFragnoInstantiatedDatabaseFragment<typeof outboxSchema>,
+  email: string,
+) {
+  return fragment.inContext(async function (this: DatabaseRequestContext) {
+    await this.handlerTx()
+      .mutate(({ forSchema }) => forSchema(outboxSchema).create("users", { email }))
+      .execute();
+
+    const user = await this.handlerTx()
+      .retrieve(({ forSchema }) =>
+        forSchema(outboxSchema).findFirst("users", (b) =>
+          b.whereIndex("idx_users_email", (eb) => eb("email", "=", email)),
+        ),
+      )
+      .transformRetrieve(([result]) => result)
+      .execute();
+
+    if (!user) {
+      throw new Error("Expected user to be created.");
+    }
+
+    return user.id;
+  });
+}
+
+async function createPost(
+  fragment: AnyFragnoInstantiatedDatabaseFragment<typeof outboxSchema>,
+  title: string,
+  authorId: FragnoReference,
+) {
+  return fragment.inContext(async function (this: DatabaseRequestContext) {
+    return await this.handlerTx()
+      .mutate(({ forSchema }) => forSchema(outboxSchema).create("posts", { title, authorId }))
+      .transform(({ mutateResult }) => mutateResult)
+      .execute();
+  });
+}
+
+describe("in-memory outbox", () => {
+  it("does not write outbox entries when disabled", async () => {
+    const { fragment, internalFragment, cleanup } = await buildOutboxTest({
+      outboxEnabled: false,
+    });
+
+    await createUser(fragment, "disabled@example.com");
+
+    const entries = await listOutbox(internalFragment);
+    expect(entries).toHaveLength(0);
+    const mutations = await listOutboxMutations(internalFragment);
+    expect(mutations).toHaveLength(0);
+
+    await cleanup();
+  });
+
+  it("stores refMap placeholders and lists entries in order", async () => {
+    const { fragment, internalFragment, cleanup } = await buildOutboxTest({ outboxEnabled: true });
+
+    const userId = await createUser(fragment, "alpha@example.com");
+    expect(userId.internalId).toBeDefined();
+
+    await createPost(fragment, "Hello", FragnoReference.fromInternal(userId.internalId!));
+
+    const entries = await listOutbox(internalFragment);
+    expect(entries).toHaveLength(2);
+    expect(entries[0].versionstamp < entries[1].versionstamp).toBe(true);
+
+    const payload = superjson.deserialize(entries[1].payload as SuperJSONResult) as OutboxPayload;
+    expect(payload.version).toBe(1);
+    expect(payload.mutations).toHaveLength(1);
+    const [mutation] = payload.mutations;
+    if (mutation.op !== "create") {
+      throw new Error("Expected create mutation in outbox payload.");
+    }
+    expect(mutation.values).toMatchObject({
+      authorId: { __fragno_ref: "0.authorId" },
+    });
+    expect(entries[1].refMap).toEqual({
+      "0.authorId": userId.externalId,
+    });
+
+    await cleanup();
+  });
+
+  it("writes mutation log rows for each outbox entry", async () => {
+    const { fragment, internalFragment, cleanup } = await buildOutboxTest({
+      outboxEnabled: true,
+    });
+
+    const userId = await createUser(fragment, "log-alpha@example.com");
+    expect(userId.internalId).toBeDefined();
+
+    await createPost(fragment, "Log", FragnoReference.fromInternal(userId.internalId!));
+
+    const entries = await listOutbox(internalFragment);
+    const mutations = await listOutboxMutations(internalFragment);
+
+    expect(entries).toHaveLength(2);
+    expect(mutations).toHaveLength(2);
+
+    const entryByVersion = new Map(entries.map((entry) => [entry.versionstamp, entry]));
+
+    for (const entry of entries) {
+      const payload = superjson.deserialize(entry.payload as SuperJSONResult) as OutboxPayload;
+      expect(payload.mutations).toHaveLength(1);
+    }
+
+    for (const mutationRow of mutations) {
+      const entry = entryByVersion.get(mutationRow.entryVersionstamp);
+      expect(entry).toBeDefined();
+      const payload = superjson.deserialize(entry!.payload as SuperJSONResult) as OutboxPayload;
+      const mutation = payload.mutations[0];
+      expect(mutationRow.mutationVersionstamp).toBe(mutation.versionstamp);
+      expect(mutationRow.uowId).toBe(entry!.uowId);
+      expect(mutationRow.schema).toBe(mutation.schema);
+      expect(mutationRow.table).toBe(mutation.table);
+      expect(mutationRow.externalId).toBe(mutation.externalId);
+      expect(mutationRow.op).toBe(mutation.op);
+    }
+
+    await cleanup();
+  });
+
+  it("resolves refMap lookups within the correct namespace", async () => {
+    const adapter = new InMemoryAdapter({
+      idSeed: "outbox-seed",
+    });
+
+    try {
+      const schemaA = buildOutboxSchema();
+      const schemaB = buildOutboxSchema();
+
+      const fragmentDefA = defineFragment(`${outboxFragmentName}-a`)
+        .extend(withDatabase(schemaA))
+        .build();
+      const fragmentDefB = defineFragment(`${outboxFragmentName}-b`)
+        .extend(withDatabase(schemaB))
+        .build();
+
+      const fragmentA = instantiate(fragmentDefA)
+        .withConfig({})
+        .withRoutes([])
+        .withOptions({
+          databaseAdapter: adapter,
+          databaseNamespace: "tenant-a",
+          outbox: { enabled: true },
+        })
+        .build();
+      const fragmentB = instantiate(fragmentDefB)
+        .withConfig({})
+        .withRoutes([])
+        .withOptions({
+          databaseAdapter: adapter,
+          databaseNamespace: "tenant-b",
+          outbox: { enabled: true },
+        })
+        .build();
+
+      const userA = await fragmentA.inContext(async function (this: DatabaseRequestContext) {
+        await this.handlerTx()
+          .mutate(({ forSchema }) =>
+            forSchema(schemaA).create("users", { email: "tenant-a@example.com" }),
+          )
+          .execute();
+
+        const user = await this.handlerTx()
+          .retrieve(({ forSchema }) =>
+            forSchema(schemaA).findFirst("users", (b) =>
+              b.whereIndex("idx_users_email", (eb) => eb("email", "=", "tenant-a@example.com")),
+            ),
+          )
+          .transformRetrieve(([result]) => result)
+          .execute();
+
+        if (!user) {
+          throw new Error("Expected user to be created.");
+        }
+
+        return user.id;
+      });
+
+      const userB = await fragmentB.inContext(async function (this: DatabaseRequestContext) {
+        await this.handlerTx()
+          .mutate(({ forSchema }) =>
+            forSchema(schemaB).create("users", { email: "tenant-b@example.com" }),
+          )
+          .execute();
+
+        const user = await this.handlerTx()
+          .retrieve(({ forSchema }) =>
+            forSchema(schemaB).findFirst("users", (b) =>
+              b.whereIndex("idx_users_email", (eb) => eb("email", "=", "tenant-b@example.com")),
+            ),
+          )
+          .transformRetrieve(([result]) => result)
+          .execute();
+
+        if (!user) {
+          throw new Error("Expected user to be created.");
+        }
+
+        return user.id;
+      });
+
+      expect(userA.internalId).toBeDefined();
+      expect(userB.internalId).toBeDefined();
+      expect(userA.internalId).toBe(userB.internalId);
+
+      await fragmentB.inContext(async function (this: DatabaseRequestContext) {
+        await this.handlerTx()
+          .mutate(({ forSchema }) =>
+            forSchema(schemaB).create("posts", {
+              title: "Hello",
+              authorId: FragnoReference.fromInternal(userB.internalId!),
+            }),
+          )
+          .execute();
+      });
+
+      const entries = await listOutbox(getInternalFragment(adapter));
+      let postEntry: OutboxEntry | undefined;
+      let postPayload: OutboxPayload | undefined;
+
+      for (const entry of entries) {
+        const payload = superjson.deserialize(entry.payload as SuperJSONResult) as OutboxPayload;
+        if (
+          payload.mutations.some(
+            (mutation) =>
+              mutation.op === "create" &&
+              mutation.table === "posts" &&
+              mutation.namespace === "tenant-b",
+          )
+        ) {
+          postEntry = entry;
+          postPayload = payload;
+          break;
+        }
+      }
+
+      if (!postEntry || !postPayload) {
+        throw new Error("Expected outbox entry for tenant-b posts.");
+      }
+
+      expect(postEntry.refMap).toEqual({
+        "0.authorId": userB.externalId,
+      });
+    } finally {
+      await adapter.close();
+    }
+  });
+});

package/src/adapters/in-memory/reference-resolution.test.ts

@@ -1,8 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { column, idColumn, referenceColumn, schema } from "../../schema/create";
+
 import { ReferenceSubquery } from "../../query/value-encoding";
-import { createInMemoryStore, ensureNamespaceStore } from "./store";
+import { column, idColumn, referenceColumn, schema } from "../../schema/create";
 import { resolveReferenceSubqueries } from "./reference-resolution";
+import { createInMemoryStore, ensureNamespaceStore } from "./store";
 
 const testSchema = schema("test", (s) =>
   s

package/src/adapters/in-memory/reference-resolution.ts

@@ -1,7 +1,7 @@
-import type { AnyTable } from "../../schema/create";
+import type { NamingResolver } from "../../naming/sql-naming";
 import { ReferenceSubquery } from "../../query/value-encoding";
+import type { AnyTable } from "../../schema/create";
 import type { InMemoryNamespaceStore, InMemoryTableStore } from "./store";
-import type { NamingResolver } from "../../naming/sql-naming";
 
 const getTableStore = (
   namespaceStore: InMemoryNamespaceStore,

package/src/adapters/in-memory/sorted-array-index.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+
 import { UniqueConstraintError } from "./errors";
 import { SortedArrayIndex } from "./sorted-array-index";
 

package/src/adapters/in-memory/store.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+
 import { column, idColumn, schema } from "../../schema/create";
 import { createInMemoryStore, ensureNamespaceStore } from "./store";
 

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

@@ -1,9 +1,9 @@
+import type { NamingResolver } from "../../naming/sql-naming";
+import { createSQLSerializer } from "../../query/serialize/create-sql-serializer";
 import type { AnyColumn, AnySchema, AnyTable } from "../../schema/create";
-import { SortedArrayIndex } from "./sorted-array-index";
 import { SQLocalDriverConfig } from "../generic-sql/driver-config";
-import { createSQLSerializer } from "../../query/serialize/create-sql-serializer";
+import { SortedArrayIndex } from "./sorted-array-index";
 import { compareNormalizedValues } from "./value-comparison";
-import type { NamingResolver } from "../../naming/sql-naming";
 
 export type InMemoryRow = Record<string, unknown>;
 

package/src/adapters/in-memory/value-normalization.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "vitest";
+
 import { column, idColumn, referenceColumn, schema } from "../../schema/create";
 import { buildIndexKey } from "./store";
 

package/src/adapters/prisma/prisma-adapter-sqlite3.test.ts

@@ -1,19 +1,21 @@
+import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
+
 import SQLite from "better-sqlite3";
 import { SqliteDialect } from "kysely";
-import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
-import { SqlAdapter } from "../generic-sql/generic-sql-adapter";
-import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
+
+import { internalSchema } from "../../fragments/internal-fragment";
+import { generateSchemaArtifacts } from "../../migration-engine/generation-engine";
+import { FragnoDatabase } from "../../mod";
 import { Cursor } from "../../query/cursor";
 import {
   createHandlerTxBuilder,
   createServiceTxBuilder,
 } from "../../query/unit-of-work/execute-unit-of-work";
 import { ExponentialBackoffRetryPolicy } from "../../query/unit-of-work/retry-policy";
+import { column, idColumn, referenceColumn, schema, type FragnoId } from "../../schema/create";
 import { BetterSQLite3DriverConfig } from "../generic-sql/driver-config";
-import { internalSchema } from "../../fragments/internal-fragment";
+import { SqlAdapter } from "../generic-sql/generic-sql-adapter";
 import { sqliteStorageDefault, sqliteStoragePrisma } from "../generic-sql/sqlite-storage";
-import { FragnoDatabase } from "../../mod";
-import { generateSchemaArtifacts } from "../../migration-engine/generation-engine";
 
 describe("SqlAdapter SQLite (prisma profile)", () => {
   const testSchema = schema("test", (s) => {
@@ -23,7 +25,8 @@ describe("SqlAdapter SQLite (prisma profile)", () => {
           .addColumn("id", idColumn())
           .addColumn("name", column("string"))
           .addColumn("age", column("integer").nullable())
-          .createIndex("name_idx", ["name"]);
+          .createIndex("name_idx", ["name"])
+          .createIndex("name_id_idx", ["name", "id"]);
       })
       .addTable("emails", (t) => {
         return t
@@ -384,6 +387,47 @@ describe("SqlAdapter SQLite (prisma profile)", () => {
     expect(secondPage.map((u) => u.name)).toEqual([`${prefix} C`, `${prefix} D`]);
   });
 
+  it("should support composite cursor pagination", async () => {
+    const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
+    const nameValue = "Prisma SQLite Composite Cursor";
+
+    const createUow = queryEngine.createUnitOfWork("create-composite-cursor-users");
+    for (let i = 0; i < 5; i += 1) {
+      createUow.create("users", { name: nameValue, age: 30 + i });
+    }
+    await createUow.executeMutations();
+
+    const all = await queryEngine.find("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .orderByIndex("name_id_idx", "asc"),
+    );
+
+    const firstPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .orderByIndex("name_id_idx", "asc")
+        .pageSize(2),
+    );
+
+    const secondPage = await queryEngine.findWithCursor("users", (b) =>
+      b
+        .whereIndex("name_id_idx", (eb) => eb("name", "=", nameValue))
+        .after(firstPage.cursor!)
+        .orderByIndex("name_id_idx", "asc")
+        .pageSize(2),
+    );
+
+    const ids = (rows: { id: FragnoId }[]) => rows.map((row) => row.id.externalId);
+
+    expect(all.length).toBeGreaterThanOrEqual(5);
+    expect(firstPage.items).toHaveLength(2);
+    expect(firstPage.cursor).toBeInstanceOf(Cursor);
+    expect(firstPage.hasNextPage).toBe(true);
+    expect(ids(firstPage.items)).toEqual(ids(all).slice(0, 2));
+    expect(ids([...firstPage.items, ...secondPage.items])).toEqual(ids(all).slice(0, 4));
+  });
+
   it("should verify hasNextPage in cursor pagination", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
     const prefix = "Prisma SQLite HasNextPage";