@fragno-dev/test 1.0.1 → 2.0.0

package/src/adapters.ts

@@ -1,15 +1,19 @@
+// Test database adapter helpers and reset logic for fragment suites.
 import { Kysely } from "kysely";
 import { SQLocalKysely } from "sqlocal/kysely";
 import { KyselyPGlite } from "kysely-pglite";
 import { drizzle } from "drizzle-orm/pglite";
 import { PGlite } from "@electric-sql/pglite";
-import { KyselyAdapter } from "@fragno-dev/db/adapters/kysely";
-import { DrizzleAdapter } from "@fragno-dev/db/adapters/drizzle";
+import { InMemoryAdapter, type InMemoryAdapterOptions } from "@fragno-dev/db/adapters/in-memory";
+import { SqlAdapter } from "@fragno-dev/db/adapters/sql";
 import type { AnySchema } from "@fragno-dev/db/schema";
 import type { DatabaseAdapter } from "@fragno-dev/db/adapters";
+import type { UnitOfWorkConfig } from "@fragno-dev/db/adapters/sql";
+import type { OutboxConfig } from "@fragno-dev/db/adapters/sql";
 import { rm } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import type { BaseTestContext } from ".";
+import { ModelCheckerAdapter } from "./model-checker-adapter";
 import { createCommonTestContextMethods } from ".";
 import { PGLiteDriverConfig, SQLocalDriverConfig } from "@fragno-dev/db/drivers";
 import { internalFragmentDef } from "@fragno-dev/db";
@@ -18,30 +22,52 @@ import type { SimpleQueryInterface } from "@fragno-dev/db/query";
 // Adapter configuration types
 export interface KyselySqliteAdapter {
   type: "kysely-sqlite";
+  uowConfig?: UnitOfWorkConfig;
+  outbox?: OutboxConfig;
 }
 
 export interface KyselyPgliteAdapter {
   type: "kysely-pglite";
   databasePath?: string;
+  uowConfig?: UnitOfWorkConfig;
+  outbox?: OutboxConfig;
 }
 
 export interface DrizzlePgliteAdapter {
   type: "drizzle-pglite";
   databasePath?: string;
+  uowConfig?: UnitOfWorkConfig;
+  outbox?: OutboxConfig;
 }
 
-export type SupportedAdapter = KyselySqliteAdapter | KyselyPgliteAdapter | DrizzlePgliteAdapter;
+export interface InMemoryAdapterConfig {
+  type: "in-memory";
+  options?: InMemoryAdapterOptions;
+  uowConfig?: UnitOfWorkConfig;
+}
+
+export interface ModelCheckerAdapterConfig {
+  type: "model-checker";
+  options?: InMemoryAdapterOptions;
+}
+
+export type SupportedAdapter =
+  | KyselySqliteAdapter
+  | KyselyPgliteAdapter
+  | DrizzlePgliteAdapter
+  | InMemoryAdapterConfig
+  | ModelCheckerAdapterConfig;
 
 // Schema configuration for multi-schema adapters
 export interface SchemaConfig {
   schema: AnySchema;
-  namespace: string;
+  namespace: string | null;
   migrateToVersion?: number;
 }
 
 // Internal test context extends BaseTestContext with getOrm (not exposed publicly)
 interface InternalTestContext extends BaseTestContext {
-  getOrm: <TSchema extends AnySchema>(namespace: string) => SimpleQueryInterface<TSchema>;
+  getOrm: <TSchema extends AnySchema>(namespace: string | null) => SimpleQueryInterface<TSchema>;
 }
 
 // Conditional return types based on adapter (adapter-specific properties only)
@@ -55,7 +81,9 @@ export type AdapterContext<T extends SupportedAdapter> = T extends
     ? {
         readonly drizzle: ReturnType<typeof drizzle<any>>; // eslint-disable-line @typescript-eslint/no-explicit-any
       }
-    : never;
+    : T extends InMemoryAdapterConfig | ModelCheckerAdapterConfig
+      ? {}
+      : never;
 
 // Factory function return type
 interface AdapterFactoryResult<T extends SupportedAdapter> {
@@ -64,14 +92,49 @@ interface AdapterFactoryResult<T extends SupportedAdapter> {
   adapter: DatabaseAdapter<any>;
 }
 
+const runInternalFragmentMigrations = async (
+  adapter: SqlAdapter,
+): Promise<SchemaConfig | undefined> => {
+  const dependencies = internalFragmentDef.dependencies;
+  if (!dependencies) {
+    return undefined;
+  }
+
+  const databaseDeps = dependencies({
+    config: {},
+    options: { databaseAdapter: adapter, databaseNamespace: null },
+  });
+  if (databaseDeps?.schema) {
+    const migrations = adapter.prepareMigrations(databaseDeps.schema, databaseDeps.namespace);
+    await migrations.executeWithDriver(adapter.driver, 0);
+    return { schema: databaseDeps.schema, namespace: databaseDeps.namespace };
+  }
+  return undefined;
+};
+
+const resolveSchemaName = (
+  adapter: DatabaseAdapter<any>, // eslint-disable-line @typescript-eslint/no-explicit-any
+  namespace: string | null,
+): string | null => {
+  if (adapter.namingStrategy.namespaceScope !== "schema") {
+    return null;
+  }
+  if (!namespace || namespace.length === 0) {
+    return null;
+  }
+  return adapter.namingStrategy.namespaceToSchema(namespace);
+};
+
 /**
  * Create Kysely + SQLite adapter using SQLocalKysely (always in-memory)
  * Supports multiple schemas with separate namespaces
  */
 export async function createKyselySqliteAdapter(
-  _config: KyselySqliteAdapter,
+  config: KyselySqliteAdapter,
   schemas: SchemaConfig[],
 ): Promise<AdapterFactoryResult<KyselySqliteAdapter>> {
+  let internalSchemaConfig: SchemaConfig | undefined;
+
   // Helper to create a new database instance and run migrations for all schemas
   const createDatabase = async () => {
     // Create SQLocalKysely instance (always in-memory for tests)
@@ -81,15 +144,18 @@ export async function createKyselySqliteAdapter(
       dialect,
     });
 
-    // Create KyselyAdapter
-    const adapter = new KyselyAdapter({
+    // Create SqlAdapter
+    const adapter = new SqlAdapter({
       dialect,
       driverConfig: new SQLocalDriverConfig(),
+      uowConfig: config.uowConfig,
+      outbox: config.outbox,
     });
+    internalSchemaConfig = await runInternalFragmentMigrations(adapter);
 
     // Run migrations for all schemas in order
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const ormMap = new Map<string, SimpleQueryInterface<any, any>>();
+    const ormMap = new Map<string | null, SimpleQueryInterface<any, any>>();
 
     for (const { schema, namespace, migrateToVersion } of schemas) {
       // Run migrations
@@ -113,11 +179,12 @@ export async function createKyselySqliteAdapter(
 
   // Reset database function - truncates all tables (only supported for in-memory databases)
   const resetDatabase = async () => {
+    const schemasToTruncate = internalSchemaConfig ? [internalSchemaConfig, ...schemas] : schemas;
+
     // For SQLite, truncate all tables by deleting rows
-    for (const { schema, namespace } of schemas) {
-      const mapper = adapter.createTableNameMapper(namespace);
+    for (const { schema, namespace } of schemasToTruncate) {
       for (const tableName of Object.keys(schema.tables)) {
-        const physicalTableName = mapper.toPhysical(tableName);
+        const physicalTableName = adapter.namingStrategy.tableName(tableName, namespace);
         await kysely.deleteFrom(physicalTableName).execute();
       }
     }
@@ -157,6 +224,7 @@ export async function createKyselyPgliteAdapter(
   schemas: SchemaConfig[],
 ): Promise<AdapterFactoryResult<KyselyPgliteAdapter>> {
   const databasePath = config.databasePath;
+  let internalSchemaConfig: SchemaConfig | undefined;
 
   // Helper to create a new database instance and run migrations for all schemas
   const createDatabase = async () => {
@@ -169,15 +237,18 @@ export async function createKyselyPgliteAdapter(
       dialect: kyselyPglite.dialect,
     });
 
-    // Create KyselyAdapter
-    const adapter = new KyselyAdapter({
+    // Create SqlAdapter
+    const adapter = new SqlAdapter({
       dialect: kyselyPglite.dialect,
       driverConfig: new PGLiteDriverConfig(),
+      uowConfig: config.uowConfig,
+      outbox: config.outbox,
     });
+    internalSchemaConfig = await runInternalFragmentMigrations(adapter);
 
     // Run migrations for all schemas in order
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const ormMap = new Map<string, SimpleQueryInterface<any, any>>();
+    const ormMap = new Map<string | null, SimpleQueryInterface<any, any>>();
 
     for (const { schema, namespace, migrateToVersion } of schemas) {
       // Run migrations
@@ -205,12 +276,15 @@ export async function createKyselyPgliteAdapter(
       throw new Error("resetDatabase is only supported for in-memory databases");
     }
 
+    const schemasToTruncate = internalSchemaConfig ? [internalSchemaConfig, ...schemas] : schemas;
+
     // Truncate all tables
-    for (const { schema, namespace } of schemas) {
-      const mapper = adapter.createTableNameMapper(namespace);
+    for (const { schema, namespace } of schemasToTruncate) {
       for (const tableName of Object.keys(schema.tables)) {
-        const physicalTableName = mapper.toPhysical(tableName);
-        await kysely.deleteFrom(physicalTableName).execute();
+        const physicalTableName = adapter.namingStrategy.tableName(tableName, namespace);
+        const schemaName = resolveSchemaName(adapter, namespace);
+        const scopedKysely = schemaName ? kysely.withSchema(schemaName) : kysely;
+        await scopedKysely.deleteFrom(physicalTableName).execute();
       }
     }
   };
@@ -260,6 +334,7 @@ export async function createDrizzlePgliteAdapter(
   schemas: SchemaConfig[],
 ): Promise<AdapterFactoryResult<DrizzlePgliteAdapter>> {
   const databasePath = config.databasePath;
+  let internalSchemaConfig: SchemaConfig | undefined;
 
   // Helper to create a new database instance and run migrations for all schemas
   const createDatabase = async () => {
@@ -267,23 +342,18 @@ export async function createDrizzlePgliteAdapter(
 
     const { dialect } = new KyselyPGlite(pglite);
 
-    const adapter = new DrizzleAdapter({
+    const adapter = new SqlAdapter({
       dialect,
       driverConfig: new PGLiteDriverConfig(),
+      uowConfig: config.uowConfig,
+      outbox: config.outbox,
     });
 
+    internalSchemaConfig = await runInternalFragmentMigrations(adapter);
+
     // Run migrations for all schemas
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const ormMap = new Map<string, SimpleQueryInterface<any, any>>();
-
-    const databaseDeps = internalFragmentDef.dependencies?.({
-      config: {},
-      options: { databaseAdapter: adapter },
-    });
-    if (databaseDeps?.schema) {
-      const migrations = adapter.prepareMigrations(databaseDeps.schema, databaseDeps.namespace);
-      await migrations.executeWithDriver(adapter.driver, 0);
-    }
+    const ormMap = new Map<string | null, SimpleQueryInterface<any, any>>();
 
     for (const { schema, namespace, migrateToVersion } of schemas) {
       const preparedMigrations = adapter.prepareMigrations(schema, namespace);
@@ -313,12 +383,18 @@ export async function createDrizzlePgliteAdapter(
       throw new Error("resetDatabase is only supported for in-memory databases");
     }
 
+    const schemasToTruncate = internalSchemaConfig ? [internalSchemaConfig, ...schemas] : schemas;
+
     // Truncate all tables by deleting rows
-    for (const { schema, namespace } of schemas) {
-      const mapper = adapter.createTableNameMapper(namespace);
-      for (const tableName of Object.keys(schema.tables)) {
-        const physicalTableName = mapper.toPhysical(tableName);
-        await drizzleDb.execute(`DELETE FROM "${physicalTableName}"`);
+    for (const { schema, namespace } of schemasToTruncate) {
+      const tableNames = Object.keys(schema.tables).slice().reverse();
+      for (const tableName of tableNames) {
+        const physicalTableName = adapter.namingStrategy.tableName(tableName, namespace);
+        const schemaName = resolveSchemaName(adapter, namespace);
+        const qualifiedTable = schemaName
+          ? `"${schemaName}"."${physicalTableName}"`
+          : `"${physicalTableName}"`;
+        await drizzleDb.execute(`DELETE FROM ${qualifiedTable}`);
       }
     }
   };
@@ -354,6 +430,89 @@ export async function createDrizzlePgliteAdapter(
   };
 }
 
+/**
+ * Create InMemory adapter (no migrations required).
+ */
+export async function createInMemoryAdapter(
+  config: InMemoryAdapterConfig,
+  schemas: SchemaConfig[],
+): Promise<AdapterFactoryResult<InMemoryAdapterConfig>> {
+  const adapter = new InMemoryAdapter(config.options);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const ormMap = new Map<string | null, SimpleQueryInterface<any, any>>();
+  for (const { schema, namespace } of schemas) {
+    const orm = adapter.createQueryEngine(schema, namespace);
+    ormMap.set(namespace, orm);
+  }
+
+  const resetDatabase = async () => {
+    await adapter.reset();
+  };
+
+  const cleanup = async () => {
+    await adapter.close();
+  };
+
+  const commonMethods = createCommonTestContextMethods(ormMap);
+
+  return {
+    testContext: {
+      get adapter() {
+        return adapter;
+      },
+      ...commonMethods,
+      resetDatabase,
+      cleanup,
+    },
+    get adapter() {
+      return adapter;
+    },
+  };
+}
+
+/**
+ * Create ModelChecker adapter (wraps the in-memory adapter).
+ */
+export async function createModelCheckerAdapter(
+  config: ModelCheckerAdapterConfig,
+  schemas: SchemaConfig[],
+): Promise<AdapterFactoryResult<ModelCheckerAdapterConfig>> {
+  const baseAdapter = new InMemoryAdapter(config.options);
+  const adapter = new ModelCheckerAdapter(baseAdapter);
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const ormMap = new Map<string | null, SimpleQueryInterface<any, any>>();
+  for (const { schema, namespace } of schemas) {
+    const orm = adapter.createQueryEngine(schema, namespace);
+    ormMap.set(namespace, orm);
+  }
+
+  const resetDatabase = async () => {
+    await baseAdapter.reset();
+  };
+
+  const cleanup = async () => {
+    await adapter.close();
+  };
+
+  const commonMethods = createCommonTestContextMethods(ormMap);
+
+  return {
+    testContext: {
+      get adapter() {
+        return adapter;
+      },
+      ...commonMethods,
+      resetDatabase,
+      cleanup,
+    },
+    get adapter() {
+      return adapter;
+    },
+  };
+}
+
 /**
  * Create adapter based on configuration
  * Supports multiple schemas with separate namespaces
@@ -368,6 +527,10 @@ export async function createAdapter<T extends SupportedAdapter>(
     return createKyselyPgliteAdapter(adapterConfig, schemas) as Promise<AdapterFactoryResult<T>>;
   } else if (adapterConfig.type === "drizzle-pglite") {
     return createDrizzlePgliteAdapter(adapterConfig, schemas) as Promise<AdapterFactoryResult<T>>;
+  } else if (adapterConfig.type === "in-memory") {
+    return createInMemoryAdapter(adapterConfig, schemas) as Promise<AdapterFactoryResult<T>>;
+  } else if (adapterConfig.type === "model-checker") {
+    return createModelCheckerAdapter(adapterConfig, schemas) as Promise<AdapterFactoryResult<T>>;
   }
 
   throw new Error(`Unsupported adapter type: ${(adapterConfig as SupportedAdapter).type}`);

package/src/db-test.test.ts

@@ -7,7 +7,7 @@ import { z } from "zod";
 import { buildDatabaseFragmentsTest } from "./db-test";
 
 // Test schema with users table
-const userSchema = schema((s) => {
+const userSchema = schema("user", (s) => {
   return s.addTable("users", (t) => {
     return t
       .addColumn("id", idColumn())
@@ -18,7 +18,7 @@ const userSchema = schema((s) => {
 });
 
 // Test schema with posts table
-const postSchema = schema((s) => {
+const postSchema = schema("post", (s) => {
   return s.addTable("posts", (t) => {
     return t
       .addColumn("id", idColumn())

package/src/db-test.ts

@@ -16,6 +16,7 @@ import {
 import type { DatabaseAdapter } from "@fragno-dev/db";
 import type { SimpleQueryInterface } from "@fragno-dev/db/query";
 import type { BaseTestContext } from ".";
+import { drainDurableHooks } from "./durable-hooks";
 
 // BoundServices is an internal type that strips 'this' parameters from service methods
 // It's used to represent services after they've been bound to a context
@@ -303,14 +304,26 @@ export class DatabaseFragmentsTestBuilder<
 
       // Extract schema and namespace from definition by calling dependencies with a mock adapter
       let schema: AnySchema | undefined;
-      let namespace: string | undefined;
+      let namespace: string | null | undefined;
 
       if (definition.dependencies) {
         try {
           // Create a mock adapter to extract the schema
           const mockAdapter = {
             createQueryEngine: () => ({ schema: null }),
+            getSchemaVersion: async () => undefined,
+            namingStrategy: {
+              namespaceScope: "suffix",
+              namespaceToSchema: (value: string) => value,
+              tableName: (logicalTable: string, ns: string | null) =>
+                ns ? `${logicalTable}_${ns}` : logicalTable,
+              columnName: (logicalColumn: string) => logicalColumn,
+              indexName: (logicalIndex: string) => logicalIndex,
+              uniqueIndexName: (logicalIndex: string) => logicalIndex,
+              foreignKeyName: ({ referenceName }: { referenceName: string }) => referenceName,
+            },
             contextStorage: { run: (_data: unknown, fn: () => unknown) => fn() },
+            close: async () => {},
           };
 
           // Use the actual config from the builder instead of an empty mock
@@ -353,7 +366,7 @@ export class DatabaseFragmentsTestBuilder<
         );
       }
 
-      if (!namespace) {
+      if (namespace === undefined) {
         throw new Error(
           `Fragment '${definition.name}' does not have a namespace in dependencies. ` +
             `This should be automatically provided by withDatabase().`,
@@ -374,7 +387,6 @@ export class DatabaseFragmentsTestBuilder<
       });
     }
 
-    // Create adapter with all schemas
     const { testContext, adapter } = await createAdapter(adapterConfig, schemaConfigs);
 
     // Helper to create fragments with service wiring
@@ -510,9 +522,47 @@ export class DatabaseFragmentsTestBuilder<
       throw new Error("At least one fragment must be added");
     }
 
+    const originalCleanup = testContext.cleanup;
+    const cleanup = async () => {
+      let drainError: unknown;
+      let cleanupError: unknown;
+
+      for (const result of fragmentResults) {
+        try {
+          await drainDurableHooks(result.fragment);
+        } catch (error) {
+          if (!drainError) {
+            drainError = error;
+          }
+        }
+      }
+
+      try {
+        await originalCleanup();
+      } catch (error) {
+        cleanupError = error;
+      }
+
+      if (drainError && cleanupError) {
+        throw new AggregateError(
+          [drainError, cleanupError],
+          "Failed to drain durable hooks and clean up test context",
+        );
+      }
+
+      if (drainError) {
+        throw drainError;
+      }
+
+      if (cleanupError) {
+        throw cleanupError;
+      }
+    };
+
     const finalTestContext = {
       ...testContext,
       resetDatabase,
+      cleanup,
       adapter,
       inContext: firstFragment.inContext.bind(firstFragment),
     };

package/src/durable-hooks.ts

@@ -0,0 +1,13 @@
+import {
+  createDurableHooksProcessor,
+  type AnyFragnoInstantiatedDatabaseFragment,
+} from "@fragno-dev/db";
+import type { AnyFragnoInstantiatedFragment } from "@fragno-dev/core";
+
+export async function drainDurableHooks(fragment: AnyFragnoInstantiatedFragment): Promise<void> {
+  const processor = createDurableHooksProcessor(fragment as AnyFragnoInstantiatedDatabaseFragment);
+  if (!processor) {
+    return;
+  }
+  await processor.drain();
+}

package/src/index.test.ts

@@ -1,19 +1,20 @@
 import { describe, expect, expectTypeOf, it } from "vitest";
 import { column, idColumn, schema } from "@fragno-dev/db/schema";
-import { withDatabase } from "@fragno-dev/db";
+import { Cursor, withDatabase } from "@fragno-dev/db";
 import { defineFragment } from "@fragno-dev/core";
 import { instantiate } from "@fragno-dev/core";
 import { buildDatabaseFragmentsTest } from "./db-test";
 import type { ExtractFragmentServices } from "@fragno-dev/core/route";
 
 // Test schema with multiple versions
-const testSchema = schema((s) => {
+const testSchema = schema("test", (s) => {
   return s
     .addTable("users", (t) => {
       return t
         .addColumn("id", idColumn())
         .addColumn("name", column("string"))
         .addColumn("email", column("string"))
+        .createIndex("idx_users_name", ["name"])
         .createIndex("idx_users_all", ["id"]); // Index for querying
     })
     .alterTable("users", (t) => {
@@ -36,6 +37,18 @@ const testFragmentDef = defineFragment<{}>("test-fragment")
         );
         return users.map((u) => ({ ...u, id: u.id.valueOf() }));
       },
+      getUsersWithCursor: async (cursor?: Cursor | string) => {
+        return deps.db.findWithCursor("users", (b) => {
+          let builder = b
+            .whereIndex("idx_users_name")
+            .orderByIndex("idx_users_name", "asc")
+            .pageSize(2);
+          if (cursor) {
+            builder = builder.after(cursor);
+          }
+          return builder;
+        });
+      },
     };
   })
   .build();
@@ -83,6 +96,70 @@ describe("buildDatabaseFragmentsTest", () => {
     ).rejects.toThrow("Fragment 'non-db-fragment' does not have a database schema");
   });
 
+  it("should support the in-memory adapter", async () => {
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "in-memory" })
+      .withFragment("test", instantiate(testFragmentDef).withConfig({}).withRoutes([]))
+      .build();
+
+    const user = await fragments.test.services.createUser({
+      name: "Memory User",
+      email: "memory@example.com",
+      age: 31,
+    });
+
+    expect(user).toMatchObject({
+      id: expect.any(String),
+      name: "Memory User",
+      email: "memory@example.com",
+      age: 31,
+    });
+
+    const users = await fragments.test.services.getUsers();
+    expect(users).toHaveLength(1);
+    expect(users[0]).toMatchObject(user);
+
+    await test.cleanup();
+  });
+
+  it("should support cursor pagination with in-memory adapter", async () => {
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "in-memory" })
+      .withFragment("test", instantiate(testFragmentDef).withConfig({}).withRoutes([]))
+      .build();
+
+    const fragment = fragments.test;
+
+    const users = [
+      { name: "Alice", email: "alice@example.com" },
+      { name: "Brett", email: "brett@example.com" },
+      { name: "Cora", email: "cora@example.com" },
+      { name: "Dylan", email: "dylan@example.com" },
+      { name: "Emma", email: "emma@example.com" },
+    ];
+
+    for (const user of users) {
+      await fragment.services.createUser(user);
+    }
+
+    const firstPage = await fragment.services.getUsersWithCursor();
+    expect(firstPage.items.map((item) => item.name)).toEqual(["Alice", "Brett"]);
+    expect(firstPage.hasNextPage).toBe(true);
+    expect(firstPage.cursor).toBeDefined();
+
+    const secondPage = await fragment.services.getUsersWithCursor(firstPage.cursor);
+    expect(secondPage.items.map((item) => item.name)).toEqual(["Cora", "Dylan"]);
+    expect(secondPage.hasNextPage).toBe(true);
+    expect(secondPage.cursor).toBeDefined();
+
+    const thirdPage = await fragment.services.getUsersWithCursor(secondPage.cursor);
+    expect(thirdPage.items.map((item) => item.name)).toEqual(["Emma"]);
+    expect(thirdPage.hasNextPage).toBe(false);
+    expect(thirdPage.cursor).toBeUndefined();
+
+    await test.cleanup();
+  });
+
   it("should reset database by truncating tables", async () => {
     const { fragments, test } = await buildDatabaseFragmentsTest()
       .withTestAdapter({ type: "kysely-sqlite" })
@@ -149,7 +226,7 @@ describe("buildDatabaseFragmentsTest", () => {
 
   it("should work with multi-table schema", async () => {
     // Simplified auth schema for testing
-    const authSchema = schema((s) => {
+    const authSchema = schema("auth", (s) => {
       return s
         .addTable("user", (t) => {
           return t
@@ -214,7 +291,7 @@ describe("buildDatabaseFragmentsTest", () => {
 
 describe("multi-fragment tests", () => {
   // Create two different schemas
-  const userSchema = schema((s) => {
+  const userSchema = schema("user", (s) => {
     return s.addTable("user", (t) => {
       return t
         .addColumn("id", idColumn())
@@ -224,7 +301,7 @@ describe("multi-fragment tests", () => {
     });
   });
 
-  const postSchema = schema((s) => {
+  const postSchema = schema("post", (s) => {
     return s.addTable("post", (t) => {
       return t
         .addColumn("id", idColumn())
@@ -325,7 +402,7 @@ describe("multi-fragment tests", () => {
 
 describe("ExtractFragmentServices", () => {
   it("extracts provided services from database fragment with new API", () => {
-    const testSchema = schema((s) => s);
+    const testSchema = schema("test", (s) => s);
 
     interface ITestService {
       doSomething: (input: string) => Promise<string>;
@@ -352,7 +429,7 @@ describe("ExtractFragmentServices", () => {
   });
 
   it("merges base services and provided services in database fragment", () => {
-    const testSchema = schema((s) => s);
+    const testSchema = schema("test", (s) => s);
 
     const fragment = defineFragment<{}>("test-db-fragment")
       .extend(withDatabase(testSchema))