@fragno-dev/db 0.2.2 → 0.3.0

package/src/hooks/hooks.test.ts

@@ -2,17 +2,26 @@ import SQLite from "better-sqlite3";
 import { SqliteDialect } from "kysely";
 import { beforeAll, describe, expect, it, vi } from "vitest";
 import { instantiate } from "@fragno-dev/core";
-import { prepareHookMutations, processHooks, type HooksMap, type HookContext } from "./hooks";
+import {
+  prepareHookMutations,
+  processHooks,
+  type HooksMap,
+  type HookContext,
+  type HookHandlerTx,
+} from "./hooks";
 import { internalFragmentDef, internalSchema } from "../fragments/internal-fragment";
 import type { FragnoPublicConfigWithDatabase } from "../db-fragment-definition-builder";
-import { DrizzleAdapter } from "../adapters/drizzle/drizzle-adapter";
+import { SqlAdapter } from "../adapters/generic-sql/generic-sql-adapter";
 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("Hook System", () => {
+  const handlerTx = (() => {
+    throw new Error("handlerTx not configured for hooks test");
+  }) as HookHandlerTx;
   let sqliteDatabase: SQLite.Database;
-  let adapter: DrizzleAdapter;
+  let adapter: SqlAdapter;
   let internalFragment: ReturnType<typeof instantiateFragment>;
 
   function instantiateFragment(options: FragnoPublicConfigWithDatabase) {
@@ -26,18 +35,19 @@ describe("Hook System", () => {
       database: sqliteDatabase,
     });
 
-    adapter = new DrizzleAdapter({
+    adapter = new SqlAdapter({
       dialect,
       driverConfig: new BetterSQLite3DriverConfig(),
     });
 
     {
-      const migrations = adapter.prepareMigrations(internalSchema, "");
+      const migrations = adapter.prepareMigrations(internalSchema, null);
       await migrations.executeWithDriver(adapter.driver, 0);
     }
 
     const options: FragnoPublicConfigWithDatabase = {
       databaseAdapter: adapter,
+      databaseNamespace: null,
     };
 
     internalFragment = instantiateFragment(options);
@@ -72,6 +82,7 @@ describe("Hook System", () => {
               hooks,
               namespace,
               internalFragment,
+              handlerTx,
               defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 5 }),
             });
           })
@@ -118,6 +129,7 @@ describe("Hook System", () => {
               hooks,
               namespace,
               internalFragment,
+              handlerTx,
               defaultRetryPolicy: new NoRetryPolicy(),
             });
           })
@@ -160,6 +172,7 @@ describe("Hook System", () => {
               hooks,
               namespace,
               internalFragment,
+              handlerTx,
               defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 10 }),
             });
           })
@@ -177,6 +190,84 @@ describe("Hook System", () => {
 
       expect(events[0]?.maxAttempts).toBe(1);
     });
+
+    it("should set nextRetryAt when processAt is in the future", async () => {
+      const namespace = "test-process-at-future";
+      const hooks: HooksMap = {
+        onScheduled: vi.fn(),
+      };
+      const futureTime = new Date(Date.now() + 60000);
+
+      await internalFragment.inContext(async function () {
+        await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema, hooks);
+
+            uow.triggerHook("onScheduled", { data: "test" }, { processAt: futureTime });
+
+            prepareHookMutations(uow, {
+              hooks,
+              namespace,
+              internalFragment,
+              handlerTx,
+              defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 5 }),
+            });
+          })
+          .execute();
+      });
+
+      const events = await internalFragment.inContext(async function () {
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHooksByNamespace(namespace)] as const,
+          )
+          .transform(({ serviceResult: [result] }) => result)
+          .execute();
+      });
+
+      expect(events).toHaveLength(1);
+      expect(events[0]?.nextRetryAt).toBeInstanceOf(Date);
+      expect(events[0]?.nextRetryAt?.getTime()).toBe(futureTime.getTime());
+    });
+
+    it("should keep processAt in the past while remaining immediately eligible", async () => {
+      const namespace = "test-process-at-past";
+      const hooks: HooksMap = {
+        onImmediate: vi.fn(),
+      };
+      const pastTime = new Date(Date.now() - 60000);
+
+      await internalFragment.inContext(async function () {
+        await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema, hooks);
+
+            uow.triggerHook("onImmediate", { data: "test" }, { processAt: pastTime });
+
+            prepareHookMutations(uow, {
+              hooks,
+              namespace,
+              internalFragment,
+              handlerTx,
+              defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 5 }),
+            });
+          })
+          .execute();
+      });
+
+      const events = await internalFragment.inContext(async function () {
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHooksByNamespace(namespace)] as const,
+          )
+          .transform(({ serviceResult: [result] }) => result)
+          .execute();
+      });
+
+      expect(events).toHaveLength(1);
+      expect(events[0]?.nextRetryAt).toBeInstanceOf(Date);
+      expect(events[0]?.nextRetryAt?.getTime()).toBe(pastTime.getTime());
+    });
   });
 
   describe("processHooks", () => {
@@ -216,6 +307,7 @@ describe("Hook System", () => {
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3 }),
       });
 
@@ -275,6 +367,7 @@ describe("Hook System", () => {
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3 }),
       });
 
@@ -329,6 +422,7 @@ describe("Hook System", () => {
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new NoRetryPolicy(),
       });
 
@@ -379,6 +473,7 @@ describe("Hook System", () => {
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new NoRetryPolicy(),
       });
 
@@ -395,6 +490,68 @@ describe("Hook System", () => {
       expect(result?.error).toBe("Hook 'onMissing' not found in hooks map");
     });
 
+    it("should re-queue stuck processing hooks and call the handler", async () => {
+      const namespace = "test-stuck-processing";
+      const hookFn = vi.fn();
+      const hooks: HooksMap = {
+        onStuck: hookFn,
+      };
+      const onStuckProcessingHooks = vi.fn();
+
+      let eventId: FragnoId;
+
+      await internalFragment.inContext(async function () {
+        const createdId = await this.handlerTx()
+          .mutate(({ forSchema }) => {
+            const uow = forSchema(internalSchema);
+            return uow.create("fragno_hooks", {
+              namespace,
+              hookName: "onStuck",
+              payload: { ok: true },
+              status: "processing",
+              attempts: 0,
+              maxAttempts: 5,
+              lastAttemptAt: new Date(Date.now() - 20 * 60_000),
+              nextRetryAt: null,
+              error: null,
+              nonce: "test-nonce",
+            });
+          })
+          .execute();
+        eventId = createdId;
+      });
+
+      await processHooks({
+        hooks,
+        namespace,
+        internalFragment,
+        handlerTx,
+        stuckProcessingTimeoutMinutes: 1,
+        onStuckProcessingHooks,
+      });
+
+      expect(hookFn).toHaveBeenCalledOnce();
+      expect(onStuckProcessingHooks).toHaveBeenCalledOnce();
+      expect(onStuckProcessingHooks).toHaveBeenCalledWith(
+        expect.objectContaining({
+          namespace,
+          timeoutMinutes: 1,
+          events: [expect.objectContaining({ hookName: "onStuck" })],
+        }),
+      );
+
+      const result = await internalFragment.inContext(async function () {
+        return await this.handlerTx()
+          .withServiceCalls(
+            () => [internalFragment.services.hookService.getHookById(eventId)] as const,
+          )
+          .transform(({ serviceResult: [event] }) => event)
+          .execute();
+      });
+
+      expect(result?.status).toBe("completed");
+    });
+
     it("should process multiple hooks in parallel", async () => {
       const namespace = "test-parallel";
       const hook1 = vi.fn();
@@ -454,6 +611,7 @@ describe("Hook System", () => {
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3 }),
       });
 
@@ -534,6 +692,7 @@ describe("Hook System", () => {
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3 }),
       });
 
@@ -570,6 +729,7 @@ describe("Hook System", () => {
         hooks,
         namespace,
         internalFragment,
+        handlerTx,
         defaultRetryPolicy: new ExponentialBackoffRetryPolicy({ maxRetries: 3 }),
       });
 

package/src/hooks/hooks.ts

@@ -1,8 +1,13 @@
+import type {
+  ExecuteTxOptions,
+  HandlerTxBuilder,
+} from "../query/unit-of-work/execute-unit-of-work";
 import type { RetryPolicy } from "../query/unit-of-work/retry-policy";
 import { ExponentialBackoffRetryPolicy } from "../query/unit-of-work/retry-policy";
 import type { IUnitOfWork } from "../query/unit-of-work/unit-of-work";
 import type { InternalFragmentInstance } from "../fragments/internal-fragment";
 import type { TxResult } from "../query/unit-of-work/execute-unit-of-work";
+import type { FragnoId } from "../schema/create";
 
 /**
  * Context available in hook functions via `this`.
@@ -14,6 +19,10 @@ export interface HookContext {
    * Use this for idempotency checks in your hook implementation.
    */
   idempotencyKey: string;
+  /**
+   * Create a handler transaction builder to run atomic operations.
+   */
+  handlerTx: HookHandlerTx;
 }
 
 /**
@@ -43,6 +52,11 @@ export interface TriggerHookOptions {
    * If not provided, uses the default retry policy.
    */
   retryPolicy?: RetryPolicy;
+  /**
+   * Absolute time for the first attempt. If in the future, the hook is
+   * scheduled for that time; if in the past, it runs immediately.
+   */
+  processAt?: Date;
 }
 
 /**
@@ -55,14 +69,88 @@ export interface TriggeredHook {
   options?: TriggerHookOptions;
 }
 
+export type HookScheduler = {
+  schedule: () => Promise<number>;
+  drain: () => Promise<void>;
+};
+
 /**
  * Configuration for hook processing.
  */
-export interface HookProcessorConfig {
-  hooks: HooksMap;
+export interface HookProcessorConfig<THooks extends HooksMap = HooksMap> {
+  hooks: THooks;
   namespace: string;
   internalFragment: InternalFragmentInstance;
+  handlerTx: HookHandlerTx;
+  /**
+   * Internal hook scheduler used to coordinate processing/drain.
+   */
+  scheduler?: HookScheduler;
   defaultRetryPolicy?: RetryPolicy;
+  /**
+   * Re-queue hooks that have been in `processing` for at least this many minutes.
+   * Use `false` to disable stuck-processing recovery entirely.
+   * Values <= 0 are treated as `false`.
+   *
+   * Default: 10 minutes.
+   */
+  stuckProcessingTimeoutMinutes?: StuckHookProcessingTimeoutMinutes;
+  /**
+   * Called when stuck processing hooks are detected and re-queued.
+   * Invoked after the hooks are moved back to `pending`.
+   */
+  onStuckProcessingHooks?: (info: StuckHookProcessingInfo) => void;
+}
+
+export type StuckHookProcessingTimeoutMinutes = number | false;
+
+export type StuckHookProcessingEvent = {
+  id: FragnoId;
+  hookName: string;
+  attempts: number;
+  maxAttempts: number;
+  lastAttemptAt: Date | null;
+  nextRetryAt: Date | null;
+};
+
+export type StuckHookProcessingInfo = {
+  namespace: string;
+  timeoutMinutes: number;
+  events: StuckHookProcessingEvent[];
+};
+
+export type DurableHooksProcessingOptions = {
+  /**
+   * Re-queue hooks that have been in `processing` for at least this many minutes.
+   * Use `false` to disable stuck-processing recovery entirely.
+   * Values <= 0 are treated as `false`.
+   *
+   * Default: 10 minutes.
+   */
+  stuckProcessingTimeoutMinutes?: StuckHookProcessingTimeoutMinutes;
+  /**
+   * Called when stuck processing hooks are detected and re-queued.
+   * Invoked after the hooks are moved back to `pending`.
+   */
+  onStuckProcessingHooks?: (info: StuckHookProcessingInfo) => void;
+};
+
+export type HookHandlerTx = (
+  execOptions?: Omit<ExecuteTxOptions, "createUnitOfWork">,
+) => HandlerTxBuilder<readonly [], [], [], unknown, unknown, false, false, false, false, HooksMap>;
+
+const DEFAULT_STUCK_PROCESSING_TIMEOUT_MINUTES = 10;
+
+function resolveStuckProcessingTimeoutMinutes(
+  value: StuckHookProcessingTimeoutMinutes | undefined,
+): number | false {
+  if (value === false) {
+    return false;
+  }
+  if (typeof value === "number") {
+    return value > 0 ? value : false;
+  }
+  return DEFAULT_STUCK_PROCESSING_TIMEOUT_MINUTES;
 }
 
 /**
@@ -70,7 +158,10 @@ export interface HookProcessorConfig {
  * This should be called before executeMutations() so hook records are created
  * in the same transaction as the user's mutations.
  */
-export function prepareHookMutations(uow: IUnitOfWork, config: HookProcessorConfig): void {
+export function prepareHookMutations<THooks extends HooksMap>(
+  uow: IUnitOfWork,
+  config: HookProcessorConfig<THooks>,
+): void {
   const { namespace, internalFragment, defaultRetryPolicy } = config;
   const retryPolicy = defaultRetryPolicy ?? new ExponentialBackoffRetryPolicy({ maxRetries: 5 });
 
@@ -86,6 +177,8 @@ export function prepareHookMutations(uow: IUnitOfWork, config: HookProcessorConf
   for (const hook of triggeredHooks) {
     const hookRetryPolicy = hook.options?.retryPolicy ?? retryPolicy;
     const maxAttempts = hookRetryPolicy.shouldRetry(4) ? 5 : 1;
+    const processAt = hook.options?.processAt ? new Date(hook.options.processAt) : null;
+    const nextRetryAt = processAt ?? null;
     internalUow.create("fragno_hooks", {
       namespace,
       hookName: hook.hookName,
@@ -94,7 +187,7 @@ export function prepareHookMutations(uow: IUnitOfWork, config: HookProcessorConf
       attempts: 0,
       maxAttempts,
       lastAttemptAt: null,
-      nextRetryAt: null,
+      nextRetryAt,
       error: null,
       nonce: uow.idempotencyKey,
     });
@@ -105,22 +198,65 @@ export function prepareHookMutations(uow: IUnitOfWork, config: HookProcessorConf
  * Process pending hook events after the transaction has committed.
  * This should be called in the onSuccess callback after executeMutations().
  */
-export async function processHooks(config: HookProcessorConfig): Promise<void> {
+export async function processHooks<THooks extends HooksMap>(
+  config: HookProcessorConfig<THooks>,
+): Promise<number> {
   const { hooks, namespace, internalFragment, defaultRetryPolicy } = config;
   const retryPolicy = defaultRetryPolicy ?? new ExponentialBackoffRetryPolicy({ maxRetries: 5 });
+  const stuckProcessingTimeoutMinutes = resolveStuckProcessingTimeoutMinutes(
+    config.stuckProcessingTimeoutMinutes,
+  );
+  const getDbNow = async () => {
+    const services = internalFragment.services as { getDbNow?: () => Promise<Date> };
+    if (services.getDbNow) {
+      return services.getDbNow();
+    }
+    return new Date();
+  };
+  const dbNow = await getDbNow();
 
-  // Get pending events
+  if (stuckProcessingTimeoutMinutes !== false) {
+    const staleBefore = new Date(dbNow.getTime() - stuckProcessingTimeoutMinutes * 60_000);
+    const stuckEvents = await internalFragment.inContext(async function () {
+      return await this.handlerTx()
+        .withServiceCalls(
+          () =>
+            [
+              internalFragment.services.hookService.requeueStuckProcessingHooks(
+                namespace,
+                staleBefore,
+              ),
+            ] as const,
+        )
+        .transform(({ serviceResult: [events] }) => events)
+        .execute();
+    });
+
+    if (stuckEvents.length > 0) {
+      try {
+        config.onStuckProcessingHooks?.({
+          namespace,
+          timeoutMinutes: stuckProcessingTimeoutMinutes,
+          events: stuckEvents,
+        });
+      } catch (error) {
+        console.error("Error calling onStuckProcessingHooks", error);
+      }
+    }
+  }
+
+  // Claim pending events in the same transaction to avoid double-processing.
   const pendingEvents = await internalFragment.inContext(async function () {
     return await this.handlerTx()
       .withServiceCalls(
-        () => [internalFragment.services.hookService.getPendingHookEvents(namespace)] as const,
+        () => [internalFragment.services.hookService.claimPendingHookEvents(namespace)] as const,
       )
       .transform(({ serviceResult: [events] }) => events)
       .execute();
   });
 
   if (pendingEvents.length === 0) {
-    return;
+    return 0;
   }
 
   // Process events (async work outside transaction)
@@ -138,7 +274,10 @@ export async function processHooks(config: HookProcessorConfig): Promise<void> {
       }
 
       try {
-        const hookContext: HookContext = { idempotencyKey: event.idempotencyKey };
+        const hookContext: HookContext = {
+          idempotencyKey: event.idempotencyKey,
+          handlerTx: config.handlerTx,
+        };
         await hookFn.call(hookContext, event.payload);
         return {
           eventId: event.id,
@@ -179,6 +318,7 @@ export async function processHooks(config: HookProcessorConfig): Promise<void> {
                 error,
                 attempts,
                 retryPolicy,
+                dbNow,
               ),
             );
           }
@@ -187,4 +327,52 @@ export async function processHooks(config: HookProcessorConfig): Promise<void> {
       })
       .execute();
   });
+
+  const processedCount = processedEvents.reduce(
+    (count, result) => count + (result.status === "fulfilled" ? 1 : 0),
+    0,
+  );
+
+  return processedCount;
+}
+
+export function createHookScheduler(config: HookProcessorConfig): HookScheduler {
+  let processing = false;
+  let queued = false;
+  let currentPromise: Promise<number> | null = null;
+
+  const schedule = async () => {
+    if (processing) {
+      queued = true;
+      return currentPromise ?? Promise.resolve(0);
+    }
+
+    processing = true;
+    currentPromise = (async () => {
+      let lastCount = 0;
+      try {
+        do {
+          queued = false;
+          lastCount = await processHooks(config);
+        } while (queued);
+        return lastCount;
+      } finally {
+        processing = false;
+        queued = false;
+      }
+    })();
+
+    return currentPromise;
+  };
+
+  const drain = async () => {
+    while (true) {
+      const processed = await schedule();
+      if (processed === 0) {
+        return;
+      }
+    }
+  };
+
+  return { schedule, drain };
 }

package/src/migration-engine/auto-from-schema.test.ts

@@ -4,7 +4,7 @@ import { generateMigrationFromSchema } from "./auto-from-schema";
 
 describe("generateMigrationFromSchema", () => {
   it("should generate create-table operation for new tables", () => {
-    const mySchema = schema((s) => {
+    const mySchema = schema("my", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -35,7 +35,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should generate multiple table operations in sequence", () => {
-    const mySchema = schema((s) => {
+    const mySchema = schema("my", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -79,7 +79,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should generate add-foreign-key operation for new foreign keys", () => {
-    const mySchema = schema((s) => {
+    const mySchema = schema("my", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn());
@@ -108,7 +108,7 @@ describe("generateMigrationFromSchema", () => {
     const fkOp = operations[0];
     if (fkOp.type === "add-foreign-key") {
       expect(fkOp.value).toMatchObject({
-        name: "posts_users_author_fk",
+        name: "author",
         referencedTable: "users",
         columns: ["authorId"],
         referencedColumns: ["_internalId"],
@@ -117,7 +117,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should generate add-index operation for indexes added via alterTable", () => {
-    const mySchema = schema((s) => {
+    const mySchema = schema("my", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("email", column("string"));
@@ -141,7 +141,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should generate mixed operations for tables and foreign keys", () => {
-    const mySchema = schema((s) => {
+    const mySchema = schema("my", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("name", column("string"));
@@ -166,7 +166,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should generate mixed operations for tables, indexes, and foreign keys", () => {
-    const mySchema = schema((s) => {
+    const mySchema = schema("my", (s) => {
       return s
         .addTable("users", (t) => {
           return t.addColumn("id", idColumn()).addColumn("email", column("string"));
@@ -195,7 +195,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should generate no operations when version range is empty", () => {
-    const mySchema = schema((s) => {
+    const mySchema = schema("my", (s) => {
       return s.addTable("users", (t) => {
         return t.addColumn("id", idColumn()).addColumn("name", column("string"));
       });
@@ -207,7 +207,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should throw error when fromVersion exceeds schema version", () => {
-    const mySchema = schema((s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
+    const mySchema = schema("my", (s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
 
     expect(() => {
       generateMigrationFromSchema(mySchema, 999, 1000);
@@ -215,7 +215,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should throw error when toVersion exceeds schema version", () => {
-    const mySchema = schema((s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
+    const mySchema = schema("my", (s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
 
     expect(() => {
       generateMigrationFromSchema(mySchema, 0, 999);
@@ -223,7 +223,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should throw error when trying to migrate backwards", () => {
-    const mySchema = schema((s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
+    const mySchema = schema("my", (s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
 
     expect(() => {
       generateMigrationFromSchema(mySchema, 1, 0);
@@ -231,7 +231,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should throw error for negative fromVersion", () => {
-    const mySchema = schema((s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
+    const mySchema = schema("my", (s) => s.addTable("users", (t) => t.addColumn("id", idColumn())));
 
     expect(() => {
       generateMigrationFromSchema(mySchema, -1, 1);
@@ -239,7 +239,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should only create constraints for references, not for referenceColumns", () => {
-    const mySchema = schema((s) => {
+    const mySchema = schema("my", (s) => {
       return s
         .addTable("posts", (t) => {
           return t
@@ -276,7 +276,7 @@ describe("generateMigrationFromSchema", () => {
   });
 
   it("should not create duplicate foreign key constraints", () => {
-    const mySchema = schema((s) => {
+    const mySchema = schema("my", (s) => {
       return s
         .addTable("users", (t) => t.addColumn("id", idColumn()))
         .addTable("posts", (t) =>