@fragno-dev/db 0.1.15 → 0.2.0

package/src/db-fragment-integration.test.ts

@@ -1,4 +1,3 @@
-import { Kysely } from "kysely";
 import { SQLocalKysely } from "sqlocal/kysely";
 import { assert, beforeAll, describe, expect, it } from "vitest";
 import { z } from "zod";
@@ -8,6 +7,8 @@ import { defineFragment, instantiate } from "@fragno-dev/core";
 import { defineRoutes } from "@fragno-dev/core/route";
 import { withDatabase } from "./with-database";
 import type { FragnoPublicConfigWithDatabase } from "./db-fragment-definition-builder";
+import { ConcurrencyConflictError } from "./query/unit-of-work/execute-unit-of-work";
+import { SQLocalDriverConfig } from "./adapters/generic-sql/driver-config";
 
 describe.sequential("Database Fragment Integration", () => {
   // Schema 1: Users fragment
@@ -180,8 +181,6 @@ describe.sequential("Database Fragment Integration", () => {
   ]);
 
   let adapter: KyselyAdapter;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let kysely: Kysely<any>;
   let usersFragment: ReturnType<typeof instantiateUsersFragment>;
   let ordersFragment: ReturnType<typeof instantiateOrdersFragment>;
 
@@ -211,23 +210,21 @@ describe.sequential("Database Fragment Integration", () => {
   beforeAll(async () => {
     // Create in-memory SQLite database with Kysely
     const { dialect } = new SQLocalKysely(":memory:");
-    kysely = new Kysely({
-      dialect,
-    });
-
     adapter = new KyselyAdapter({
-      db: kysely,
-      provider: "sqlite",
+      dialect,
+      driverConfig: new SQLocalDriverConfig(),
     });
 
     // Run migrations for both schemas
-    const usersMigrator = adapter.createMigrationEngine(usersSchema, "users");
-    const usersPrep = await usersMigrator.prepareMigration({ updateSettings: false });
-    await usersPrep.execute();
+    const usersPreparedMigrations = adapter.prepareMigrations(usersSchema, "users");
+    await usersPreparedMigrations.execute(0, usersSchema.version, {
+      updateVersionInMigration: false,
+    });
 
-    const ordersMigrator = adapter.createMigrationEngine(ordersSchema, "orders");
-    const ordersPrep = await ordersMigrator.prepareMigration({ updateSettings: false });
-    await ordersPrep.execute();
+    const ordersPreparedMigrations = adapter.prepareMigrations(ordersSchema, "orders");
+    await ordersPreparedMigrations.execute(0, ordersSchema.version, {
+      updateVersionInMigration: false,
+    });
 
     // Instantiate fragments with shared database adapter
     const options: FragnoPublicConfigWithDatabase = {
@@ -375,7 +372,8 @@ describe.sequential("Database Fragment Integration", () => {
 
         if (currentAttempt === 0) {
           firstNonce = nonce;
-          throw new Error("Test error");
+          // Trigger a conflict by throwing the specific conflict error
+          throw new ConcurrencyConflictError();
         }
 
         expect(nonce).toBe(firstNonce);

package/src/fragments/internal-fragment.test.ts

@@ -1,22 +1,17 @@
-import { drizzle } from "drizzle-orm/libsql";
+import SQLite from "better-sqlite3";
+import { SqliteDialect } from "kysely";
 import { beforeAll, describe, expect, it } from "vitest";
 import { instantiate } from "@fragno-dev/core";
-import { internalFragmentDef, settingsSchema } from "./internal-fragment";
+import { internalFragmentDef, internalSchema, SETTINGS_NAMESPACE } from "./internal-fragment";
 import type { FragnoPublicConfigWithDatabase } from "../db-fragment-definition-builder";
 import { DrizzleAdapter } from "../adapters/drizzle/drizzle-adapter";
-import type { DBType } from "../adapters/drizzle/shared";
-import { writeAndLoadSchema } from "../adapters/drizzle/test-utils";
-import { createClient } from "@libsql/client";
-import { createRequire } from "node:module";
-
-// Import drizzle-kit for migrations
-const require = createRequire(import.meta.url);
-const { generateSQLiteDrizzleJson, generateSQLiteMigration } =
-  require("drizzle-kit/api") as typeof import("drizzle-kit/api");
+import { BetterSQLite3DriverConfig } from "../adapters/generic-sql/driver-config";
+import { ExponentialBackoffRetryPolicy, NoRetryPolicy } from "../query/unit-of-work/retry-policy";
+import type { FragnoId } from "../schema/create";
 
 describe("Internal Fragment", () => {
+  let sqliteDatabase: SQLite.Database;
   let adapter: DrizzleAdapter;
-  let db: DBType;
   let fragment: ReturnType<typeof instantiateFragment>;
 
   function instantiateFragment(options: FragnoPublicConfigWithDatabase) {
@@ -24,36 +19,22 @@ describe("Internal Fragment", () => {
   }
 
   beforeAll(async () => {
-    const { schemaModule, cleanup } = await writeAndLoadSchema(
-      "internal-fragment",
-      settingsSchema,
-      "sqlite",
-      "",
-    );
+    sqliteDatabase = new SQLite(":memory:");
 
-    const client = createClient({
-      url: "file::memory:?cache=shared",
+    const dialect = new SqliteDialect({
+      database: sqliteDatabase,
     });
 
-    db = drizzle(client, {
-      schema: schemaModule,
-    }) as unknown as DBType;
-
-    // Generate and run migrations for both schemas
-    const emptyJson = await generateSQLiteDrizzleJson({});
-    const targetJson = await generateSQLiteDrizzleJson(schemaModule);
-
-    const migrationStatements = await generateSQLiteMigration(emptyJson, targetJson);
-
-    for (const statement of migrationStatements) {
-      await client.execute(statement);
-    }
-
     adapter = new DrizzleAdapter({
-      db,
-      provider: "sqlite",
+      dialect,
+      driverConfig: new BetterSQLite3DriverConfig(),
     });
 
+    {
+      const migrations = adapter.prepareMigrations(internalSchema, "");
+      await migrations.executeWithDriver(adapter.driver, 0);
+    }
+
     // Instantiate fragment with shared database adapter
     const options: FragnoPublicConfigWithDatabase = {
       databaseAdapter: adapter,
@@ -62,15 +43,14 @@ describe("Internal Fragment", () => {
     fragment = instantiateFragment(options);
 
     return async () => {
-      client.close();
-      await cleanup();
+      await adapter.close();
     };
   }, 12000);
 
   it("should get undefined for non-existent key", async () => {
     const result = await fragment.inContext(async function () {
       return await this.uow(async ({ executeRetrieve }) => {
-        const valuePromise = fragment.services.settingsService.get("test-key");
+        const valuePromise = fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key");
         await executeRetrieve();
         return await valuePromise;
       });
@@ -82,7 +62,11 @@ describe("Internal Fragment", () => {
   it("should set and get a value", async () => {
     await fragment.inContext(async function () {
       return await this.uow(async ({ executeMutate }) => {
-        const setPromise = fragment.services.settingsService.set("test-key", "test-value");
+        const setPromise = fragment.services.settingsService.set(
+          SETTINGS_NAMESPACE,
+          "test-key",
+          "test-value",
+        );
         await executeMutate();
         await setPromise;
       });
@@ -90,7 +74,7 @@ describe("Internal Fragment", () => {
 
     const result = await fragment.inContext(async function () {
       return await this.uow(async ({ executeRetrieve }) => {
-        const valuePromise = fragment.services.settingsService.get("test-key");
+        const valuePromise = fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key");
         await executeRetrieve();
         return await valuePromise;
       });
@@ -105,7 +89,11 @@ describe("Internal Fragment", () => {
   it("should update an existing value", async () => {
     await fragment.inContext(async function () {
       return await this.uow(async ({ executeMutate }) => {
-        const setPromise = fragment.services.settingsService.set("test-key", "updated-value");
+        const setPromise = fragment.services.settingsService.set(
+          SETTINGS_NAMESPACE,
+          "test-key",
+          "updated-value",
+        );
         await executeMutate();
         await setPromise;
       });
@@ -113,7 +101,7 @@ describe("Internal Fragment", () => {
 
     const result = await fragment.inContext(async function () {
       return await this.uow(async ({ executeRetrieve }) => {
-        const valuePromise = fragment.services.settingsService.get("test-key");
+        const valuePromise = fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key");
         await executeRetrieve();
         return await valuePromise;
       });
@@ -129,7 +117,7 @@ describe("Internal Fragment", () => {
     // First get the ID
     const setting = await fragment.inContext(async function () {
       return await this.uow(async ({ executeRetrieve }) => {
-        const valuePromise = fragment.services.settingsService.get("test-key");
+        const valuePromise = fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key");
         await executeRetrieve();
         return await valuePromise;
       });
@@ -149,7 +137,7 @@ describe("Internal Fragment", () => {
     // Verify it's gone
     const result = await fragment.inContext(async function () {
       return await this.uow(async ({ executeRetrieve }) => {
-        const valuePromise = fragment.services.settingsService.get("test-key");
+        const valuePromise = fragment.services.settingsService.get(SETTINGS_NAMESPACE, "test-key");
         await executeRetrieve();
         return await valuePromise;
       });
@@ -158,3 +146,404 @@ describe("Internal Fragment", () => {
     expect(result).toBeUndefined();
   });
 });
+
+describe("Hook Service", () => {
+  let sqliteDatabase: SQLite.Database;
+  let adapter: DrizzleAdapter;
+  let fragment: ReturnType<typeof instantiateFragment>;
+
+  function instantiateFragment(options: FragnoPublicConfigWithDatabase) {
+    return instantiate(internalFragmentDef).withConfig({}).withOptions(options).build();
+  }
+
+  beforeAll(async () => {
+    sqliteDatabase = new SQLite(":memory:");
+
+    const dialect = new SqliteDialect({
+      database: sqliteDatabase,
+    });
+
+    adapter = new DrizzleAdapter({
+      dialect,
+      driverConfig: new BetterSQLite3DriverConfig(),
+    });
+
+    {
+      const migrations = adapter.prepareMigrations(internalSchema, "");
+      await migrations.executeWithDriver(adapter.driver, 0);
+    }
+
+    const options: FragnoPublicConfigWithDatabase = {
+      databaseAdapter: adapter,
+    };
+
+    fragment = instantiateFragment(options);
+
+    return async () => {
+      await adapter.close();
+    };
+  }, 12000);
+
+  it("should create a hook event and retrieve it by namespace", async () => {
+    const nonce = "test-nonce-1";
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeMutate }) => {
+        const uow = forSchema(internalSchema);
+        uow.create("fragno_hooks", {
+          namespace: "test-namespace",
+          hookName: "onTest",
+          payload: { test: "data" },
+          status: "pending",
+          attempts: 0,
+          maxAttempts: 5,
+          lastAttemptAt: null,
+          nextRetryAt: null,
+          error: null,
+          nonce,
+        });
+        uow.create("fragno_hooks", {
+          namespace: "test-namespace",
+          hookName: "onTest",
+          payload: { test: "already-completed-data" },
+          status: "completed",
+          attempts: 0,
+          maxAttempts: 5,
+          lastAttemptAt: null,
+          nextRetryAt: null,
+          error: null,
+          nonce,
+        });
+        await executeMutate();
+      });
+    });
+
+    const events = await fragment.inContext(async function () {
+      return await this.uow(async ({ executeRetrieve }) => {
+        const eventsPromise = fragment.services.hookService.getPendingHookEvents("test-namespace");
+        await executeRetrieve();
+        return await eventsPromise;
+      });
+    });
+
+    expect(events).toHaveLength(1);
+    expect(events[0]).toMatchObject({
+      hookName: "onTest",
+      payload: { test: "data" },
+      attempts: 0,
+      maxAttempts: 5,
+      nonce,
+    });
+  });
+
+  it("should mark a hook event as completed", async () => {
+    const nonce = "test-nonce-2";
+    let eventId: FragnoId;
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeMutate }) => {
+        const uow = forSchema(internalSchema);
+        eventId = uow.create("fragno_hooks", {
+          namespace: "test-namespace",
+          hookName: "onComplete",
+          payload: { test: "data" },
+          status: "pending",
+          attempts: 0,
+          maxAttempts: 5,
+          lastAttemptAt: null,
+          nextRetryAt: null,
+          error: null,
+          nonce,
+        });
+        await executeMutate();
+      });
+    });
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ executeMutate }) => {
+        fragment.services.hookService.markHookCompleted(eventId);
+        await executeMutate();
+      });
+    });
+
+    const result = await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeRetrieve }) => {
+        const uow = forSchema(internalSchema);
+        const findUow = uow.find("fragno_hooks", (b) =>
+          b.whereIndex("primary", (eb) => eb("id", "=", eventId)),
+        );
+        await executeRetrieve();
+        const [events] = await findUow.retrievalPhase;
+        return events?.[0];
+      });
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.status).toBe("completed");
+    expect(result?.lastAttemptAt).toBeInstanceOf(Date);
+  });
+
+  it("should mark a hook event as processing", async () => {
+    const nonce = "test-nonce-3";
+    let eventId: FragnoId;
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeMutate }) => {
+        const uow = forSchema(internalSchema);
+        eventId = uow.create("fragno_hooks", {
+          namespace: "test-namespace",
+          hookName: "onProcess",
+          payload: { test: "data" },
+          status: "pending",
+          attempts: 0,
+          maxAttempts: 5,
+          lastAttemptAt: null,
+          nextRetryAt: null,
+          error: null,
+          nonce,
+        });
+        await executeMutate();
+      });
+    });
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ executeMutate }) => {
+        fragment.services.hookService.markHookProcessing(eventId);
+        await executeMutate();
+      });
+    });
+
+    const result = await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeRetrieve }) => {
+        const uow = forSchema(internalSchema);
+        const findUow = uow.find("fragno_hooks", (b) =>
+          b.whereIndex("primary", (eb) => eb("id", "=", eventId)),
+        );
+        await executeRetrieve();
+        const [events] = await findUow.retrievalPhase;
+        return events?.[0];
+      });
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.status).toBe("processing");
+    expect(result?.lastAttemptAt).toBeInstanceOf(Date);
+  });
+
+  it("should mark a hook event as failed with retry scheduled", async () => {
+    const nonce = "test-nonce-4";
+    let eventId: FragnoId;
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeMutate }) => {
+        const uow = forSchema(internalSchema);
+        eventId = uow.create("fragno_hooks", {
+          namespace: "test-namespace",
+          hookName: "onFail",
+          payload: { test: "data" },
+          status: "pending",
+          attempts: 0,
+          maxAttempts: 5,
+          lastAttemptAt: null,
+          nextRetryAt: null,
+          error: null,
+          nonce,
+        });
+        await executeMutate();
+      });
+    });
+
+    const retryPolicy = new ExponentialBackoffRetryPolicy({ maxRetries: 3 });
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ executeMutate }) => {
+        fragment.services.hookService.markHookFailed(eventId, "Test error", 0, retryPolicy);
+        await executeMutate();
+      });
+    });
+
+    const result = await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeRetrieve }) => {
+        const uow = forSchema(internalSchema);
+        const findUow = uow.find("fragno_hooks", (b) =>
+          b.whereIndex("primary", (eb) => eb("id", "=", eventId)),
+        );
+        await executeRetrieve();
+        const [events] = await findUow.retrievalPhase;
+        return events?.[0];
+      });
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.status).toBe("pending");
+    expect(result?.attempts).toBe(1);
+    expect(result?.error).toBe("Test error");
+    expect(result?.nextRetryAt).toBeInstanceOf(Date);
+    expect(result?.lastAttemptAt).toBeInstanceOf(Date);
+  });
+
+  it("should mark a hook event as permanently failed when max attempts reached", async () => {
+    const nonce = "test-nonce-5";
+    let eventId: FragnoId;
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeMutate }) => {
+        const uow = forSchema(internalSchema);
+        eventId = uow.create("fragno_hooks", {
+          namespace: "test-namespace",
+          hookName: "onMaxFail",
+          payload: { test: "data" },
+          status: "pending",
+          attempts: 0,
+          maxAttempts: 1,
+          lastAttemptAt: null,
+          nextRetryAt: null,
+          error: null,
+          nonce,
+        });
+        await executeMutate();
+      });
+    });
+
+    const retryPolicy = new NoRetryPolicy();
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ executeMutate }) => {
+        fragment.services.hookService.markHookFailed(
+          eventId,
+          "Max attempts reached",
+          0,
+          retryPolicy,
+        );
+        await executeMutate();
+      });
+    });
+
+    const result = await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeRetrieve }) => {
+        const uow = forSchema(internalSchema);
+        const findUow = uow.find("fragno_hooks", (b) =>
+          b.whereIndex("primary", (eb) => eb("id", "=", eventId)),
+        );
+        await executeRetrieve();
+        const [events] = await findUow.retrievalPhase;
+        return events?.[0];
+      });
+    });
+
+    expect(result).toBeDefined();
+    expect(result?.status).toBe("failed");
+    expect(result?.attempts).toBe(1);
+    expect(result?.error).toBe("Max attempts reached");
+  });
+
+  it("should retrieve stale events ready for retry", async () => {
+    const nonce = "test-nonce-6";
+    let eventId: FragnoId;
+
+    const pastTime = new Date(Date.now() - 10000);
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeMutate }) => {
+        const uow = forSchema(internalSchema);
+        eventId = uow.create("fragno_hooks", {
+          namespace: "test-namespace",
+          hookName: "onStale",
+          payload: { test: "stale" },
+          status: "pending",
+          attempts: 1,
+          maxAttempts: 5,
+          lastAttemptAt: pastTime,
+          nextRetryAt: pastTime,
+          error: "Previous error",
+          nonce,
+        });
+        await executeMutate();
+      });
+    });
+
+    const events = await fragment.inContext(async function () {
+      return await this.uow(async ({ executeRetrieve }) => {
+        const eventsPromise = fragment.services.hookService.getPendingHookEvents("test-namespace");
+        await executeRetrieve();
+        return await eventsPromise;
+      });
+    });
+
+    const staleEvent = events.find((e) => e.id.externalId === eventId.externalId);
+    expect(staleEvent).toBeDefined();
+    expect(staleEvent?.hookName).toBe("onStale");
+    expect(staleEvent?.attempts).toBe(1);
+  });
+
+  it("should not retrieve events from different namespace", async () => {
+    const nonce = "test-nonce-7";
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeMutate }) => {
+        const uow = forSchema(internalSchema);
+        uow.create("fragno_hooks", {
+          namespace: "other-namespace",
+          hookName: "onOther",
+          payload: { test: "other" },
+          status: "pending",
+          attempts: 0,
+          maxAttempts: 5,
+          lastAttemptAt: null,
+          nextRetryAt: null,
+          error: null,
+          nonce,
+        });
+        await executeMutate();
+      });
+    });
+
+    const events = await fragment.inContext(async function () {
+      return await this.uow(async ({ executeRetrieve }) => {
+        const eventsPromise = fragment.services.hookService.getPendingHookEvents("test-namespace");
+        await executeRetrieve();
+        return await eventsPromise;
+      });
+    });
+
+    const otherEvent = events.find((e) => e.hookName === "onOther");
+    expect(otherEvent).toBeUndefined();
+  });
+
+  it("should not retrieve events not yet ready for retry", async () => {
+    const nonce = "test-nonce-8";
+    let eventId: FragnoId;
+
+    const futureTime = new Date(Date.now() + 60000);
+
+    await fragment.inContext(async function () {
+      return await this.uow(async ({ forSchema, executeMutate }) => {
+        const uow = forSchema(internalSchema);
+        eventId = uow.create("fragno_hooks", {
+          namespace: "test-namespace",
+          hookName: "onFuture",
+          payload: { test: "future" },
+          status: "pending",
+          attempts: 1,
+          maxAttempts: 5,
+          lastAttemptAt: new Date(),
+          nextRetryAt: futureTime,
+          error: "Previous error",
+          nonce,
+        });
+        await executeMutate();
+      });
+    });
+
+    const events = await fragment.inContext(async function () {
+      return await this.uow(async ({ executeRetrieve }) => {
+        const eventsPromise = fragment.services.hookService.getPendingHookEvents("test-namespace");
+        await executeRetrieve();
+        return await eventsPromise;
+      });
+    });
+
+    const futureEvent = events.find((e) => e.id.externalId === eventId.externalId);
+    expect(futureEvent).toBeUndefined();
+  });
+});