@fragno-dev/test 1.0.2 → 2.0.2

package/src/adapters.ts

@@ -1,50 +1,58 @@
-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 type { AnySchema } from "@fragno-dev/db/schema";
 import type { DatabaseAdapter } from "@fragno-dev/db/adapters";
-import { rm } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import type { BaseTestContext } from ".";
-import { createCommonTestContextMethods } from ".";
-import { PGLiteDriverConfig, SQLocalDriverConfig } from "@fragno-dev/db/drivers";
-import { internalFragmentDef } from "@fragno-dev/db";
+import type { InMemoryAdapterOptions } from "@fragno-dev/db/adapters/in-memory";
+import type { UnitOfWorkConfig } from "@fragno-dev/db/adapters/sql";
 import type { SimpleQueryInterface } from "@fragno-dev/db/query";
+import type { AnySchema } from "@fragno-dev/db/schema";
+import type { drizzle } from "drizzle-orm/pglite";
+import type { Kysely } from "kysely";
+
+import type { BaseTestContext } from ".";
 
-// Adapter configuration types
 export interface KyselySqliteAdapter {
   type: "kysely-sqlite";
+  uowConfig?: UnitOfWorkConfig;
 }
 
 export interface KyselyPgliteAdapter {
   type: "kysely-pglite";
   databasePath?: string;
+  uowConfig?: UnitOfWorkConfig;
 }
 
 export interface DrizzlePgliteAdapter {
   type: "drizzle-pglite";
   databasePath?: string;
+  uowConfig?: UnitOfWorkConfig;
 }
 
-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)
 export type AdapterContext<T extends SupportedAdapter> = T extends
   | KyselySqliteAdapter
   | KyselyPgliteAdapter
@@ -55,320 +63,44 @@ 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> {
+export interface AdapterFactoryResult<T extends SupportedAdapter> {
   testContext: InternalTestContext & AdapterContext<T>;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   adapter: DatabaseAdapter<any>;
 }
 
-/**
- * Create Kysely + SQLite adapter using SQLocalKysely (always in-memory)
- * Supports multiple schemas with separate namespaces
- */
-export async function createKyselySqliteAdapter(
-  _config: KyselySqliteAdapter,
-  schemas: SchemaConfig[],
-): Promise<AdapterFactoryResult<KyselySqliteAdapter>> {
-  // Helper to create a new database instance and run migrations for all schemas
-  const createDatabase = async () => {
-    // Create SQLocalKysely instance (always in-memory for tests)
-    const { dialect } = new SQLocalKysely(":memory:");
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const kysely = new Kysely<any>({
-      dialect,
-    });
-
-    // Create KyselyAdapter
-    const adapter = new KyselyAdapter({
-      dialect,
-      driverConfig: new SQLocalDriverConfig(),
-    });
-
-    // Run migrations for all schemas in order
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const ormMap = new Map<string, SimpleQueryInterface<any, any>>();
-
-    for (const { schema, namespace, migrateToVersion } of schemas) {
-      // Run migrations
-      const preparedMigrations = adapter.prepareMigrations(schema, namespace);
-      if (migrateToVersion !== undefined) {
-        await preparedMigrations.execute(0, migrateToVersion, { updateVersionInMigration: false });
-      } else {
-        await preparedMigrations.execute(0, schema.version, { updateVersionInMigration: false });
-      }
-
-      // Create ORM instance and store in map
-      const orm = adapter.createQueryEngine(schema, namespace);
-      ormMap.set(namespace, orm);
-    }
-
-    return { kysely, adapter, ormMap };
-  };
-
-  // Create initial database
-  let { kysely, adapter, ormMap } = await createDatabase();
-
-  // Reset database function - truncates all tables (only supported for in-memory databases)
-  const resetDatabase = async () => {
-    // For SQLite, 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 kysely.deleteFrom(physicalTableName).execute();
-      }
-    }
-  };
-
-  // Cleanup function - closes connections (no files to delete for in-memory)
-  const cleanup = async () => {
-    await kysely.destroy();
-  };
-
-  const commonMethods = createCommonTestContextMethods(ormMap);
-
-  return {
-    testContext: {
-      get kysely() {
-        return kysely;
-      },
-      get adapter() {
-        return adapter;
-      },
-      ...commonMethods,
-      resetDatabase,
-      cleanup,
-    },
-    get adapter() {
-      return adapter;
-    },
-  };
-}
-
-/**
- * Create Kysely + PGLite adapter using kysely-pglite
- * Supports multiple schemas with separate namespaces
- */
-export async function createKyselyPgliteAdapter(
-  config: KyselyPgliteAdapter,
-  schemas: SchemaConfig[],
-): Promise<AdapterFactoryResult<KyselyPgliteAdapter>> {
-  const databasePath = config.databasePath;
-
-  // Helper to create a new database instance and run migrations for all schemas
-  const createDatabase = async () => {
-    // Create KyselyPGlite instance
-    const kyselyPglite = await KyselyPGlite.create(databasePath);
-
-    // Create Kysely instance with PGlite dialect
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const kysely = new Kysely<any>({
-      dialect: kyselyPglite.dialect,
-    });
-
-    // Create KyselyAdapter
-    const adapter = new KyselyAdapter({
-      dialect: kyselyPglite.dialect,
-      driverConfig: new PGLiteDriverConfig(),
-    });
-
-    // Run migrations for all schemas in order
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const ormMap = new Map<string, SimpleQueryInterface<any, any>>();
-
-    for (const { schema, namespace, migrateToVersion } of schemas) {
-      // Run migrations
-      const preparedMigrations = adapter.prepareMigrations(schema, namespace);
-      if (migrateToVersion !== undefined) {
-        await preparedMigrations.execute(0, migrateToVersion, { updateVersionInMigration: false });
-      } else {
-        await preparedMigrations.execute(0, schema.version, { updateVersionInMigration: false });
-      }
-
-      // Create ORM instance and store in map
-      const orm = adapter.createQueryEngine(schema, namespace);
-      ormMap.set(namespace, orm);
-    }
-
-    return { kysely, adapter, kyselyPglite, ormMap };
-  };
-
-  // Create initial database
-  const { kysely, adapter, kyselyPglite, ormMap } = await createDatabase();
-
-  // Reset database function - truncates all tables (only supported for in-memory databases)
-  const resetDatabase = async () => {
-    if (databasePath && databasePath !== ":memory:") {
-      throw new Error("resetDatabase is only supported for in-memory databases");
-    }
-
-    // Truncate all tables
-    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 kysely.deleteFrom(physicalTableName).execute();
-      }
-    }
-  };
-
-  // Cleanup function - closes connections and deletes database directory
-  const cleanup = async () => {
-    await kysely.destroy();
-
-    try {
-      await kyselyPglite.client.close();
-    } catch {
-      // Ignore if already closed
-    }
-
-    // Delete the database directory if it exists and is a file path
-    if (databasePath && databasePath !== ":memory:" && existsSync(databasePath)) {
-      await rm(databasePath, { recursive: true, force: true });
-    }
-  };
-
-  const commonMethods = createCommonTestContextMethods(ormMap);
-
-  return {
-    testContext: {
-      get kysely() {
-        return kysely;
-      },
-      get adapter() {
-        return adapter;
-      },
-      ...commonMethods,
-      resetDatabase,
-      cleanup,
-    },
-    get adapter() {
-      return adapter;
-    },
-  };
-}
-
-/**
- * Create Drizzle + PGLite adapter using drizzle-orm/pglite
- * Supports multiple schemas with separate namespaces
- */
-export async function createDrizzlePgliteAdapter(
-  config: DrizzlePgliteAdapter,
-  schemas: SchemaConfig[],
-): Promise<AdapterFactoryResult<DrizzlePgliteAdapter>> {
-  const databasePath = config.databasePath;
-
-  // Helper to create a new database instance and run migrations for all schemas
-  const createDatabase = async () => {
-    const pglite = new PGlite(databasePath);
-
-    const { dialect } = new KyselyPGlite(pglite);
-
-    const adapter = new DrizzleAdapter({
-      dialect,
-      driverConfig: new PGLiteDriverConfig(),
-    });
-
-    // 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);
-    }
-
-    for (const { schema, namespace, migrateToVersion } of schemas) {
-      const preparedMigrations = adapter.prepareMigrations(schema, namespace);
-      if (migrateToVersion !== undefined) {
-        await preparedMigrations.execute(0, migrateToVersion, { updateVersionInMigration: false });
-      } else {
-        await preparedMigrations.execute(0, schema.version, { updateVersionInMigration: false });
-      }
-
-      // Create ORM instance and store in map
-      const orm = adapter.createQueryEngine(schema, namespace);
-      ormMap.set(namespace, orm);
-    }
-
-    // Create Drizzle instance for backward compatibility (if needed)
-    const db = drizzle(pglite) as any; // eslint-disable-line @typescript-eslint/no-explicit-any
-
-    return { drizzle: db, adapter, pglite, ormMap };
-  };
-
-  // Create initial database
-  const { drizzle: drizzleDb, adapter, ormMap } = await createDatabase();
-
-  // Reset database function - truncates all tables (only supported for in-memory databases)
-  const resetDatabase = async () => {
-    if (databasePath && databasePath !== ":memory:") {
-      throw new Error("resetDatabase is only supported for in-memory databases");
-    }
-
-    // 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}"`);
-      }
-    }
-  };
-
-  // Cleanup function - closes connections and deletes database directory
-  const cleanup = async () => {
-    // Close the adapter (which will handle closing the underlying database connection)
-    await adapter.close();
-
-    // Delete the database directory if it exists and is a file path
-    if (databasePath && databasePath !== ":memory:" && existsSync(databasePath)) {
-      await rm(databasePath, { recursive: true, force: true });
-    }
-  };
-
-  const commonMethods = createCommonTestContextMethods(ormMap);
-
-  return {
-    testContext: {
-      get drizzle() {
-        return drizzleDb;
-      },
-      get adapter() {
-        return adapter;
-      },
-      ...commonMethods,
-      resetDatabase,
-      cleanup,
-    },
-    get adapter() {
-      return adapter;
-    },
-  };
-}
-
-/**
- * Create adapter based on configuration
- * Supports multiple schemas with separate namespaces
- */
 export async function createAdapter<T extends SupportedAdapter>(
   adapterConfig: T,
   schemas: SchemaConfig[],
 ): Promise<AdapterFactoryResult<T>> {
   if (adapterConfig.type === "kysely-sqlite") {
+    const { createKyselySqliteAdapter } = await import("./test-adapters/kysely-sqlite");
     return createKyselySqliteAdapter(adapterConfig, schemas) as Promise<AdapterFactoryResult<T>>;
-  } else if (adapterConfig.type === "kysely-pglite") {
+  }
+
+  if (adapterConfig.type === "kysely-pglite") {
+    const { createKyselyPgliteAdapter } = await import("./test-adapters/kysely-pglite");
     return createKyselyPgliteAdapter(adapterConfig, schemas) as Promise<AdapterFactoryResult<T>>;
-  } else if (adapterConfig.type === "drizzle-pglite") {
+  }
+
+  if (adapterConfig.type === "drizzle-pglite") {
+    const { createDrizzlePgliteAdapter } = await import("./test-adapters/drizzle-pglite");
     return createDrizzlePgliteAdapter(adapterConfig, schemas) as Promise<AdapterFactoryResult<T>>;
   }
 
+  if (adapterConfig.type === "in-memory") {
+    const { createInMemoryAdapter } = await import("./test-adapters/in-memory");
+    return createInMemoryAdapter(adapterConfig, schemas) as Promise<AdapterFactoryResult<T>>;
+  }
+
+  if (adapterConfig.type === "model-checker") {
+    const { createModelCheckerAdapter } = await import("./test-adapters/model-checker");
+    return createModelCheckerAdapter(adapterConfig, schemas) as Promise<AdapterFactoryResult<T>>;
+  }
+
   throw new Error(`Unsupported adapter type: ${(adapterConfig as SupportedAdapter).type}`);
 }

package/src/db-roundtrip-guard.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, it } from "vitest";
+
+import { defineRoute } from "@fragno-dev/core/route";
+import { column, idColumn, schema } from "@fragno-dev/db/schema";
+import { z } from "zod";
+
+import { defineFragment, instantiate } from "@fragno-dev/core";
+import { withDatabase, type DatabaseRequestContext, type TxResult } from "@fragno-dev/db";
+
+import { buildDatabaseFragmentsTest } from "./db-test";
+
+const userSchema = schema("user-roundtrip", (s) => {
+  return s.addTable("users", (t) => {
+    return t
+      .addColumn("id", idColumn())
+      .addColumn("name", column("string"))
+      .addColumn("email", column("string"))
+      .createIndex("idx_users_all", ["id"]);
+  });
+});
+
+describe("dbRoundtripGuard", () => {
+  it("blocks multiple handlerTx().execute() calls by default", async () => {
+    const userFragmentDef = defineFragment<{}>("user-roundtrip-fragment")
+      .extend(withDatabase(userSchema))
+      .providesBaseService(() => ({}))
+      .build();
+
+    const multiRoundtripRoute = defineRoute({
+      method: "POST",
+      path: "/multi",
+      outputSchema: z.object({ ok: z.boolean() }),
+      handler: async function (this: DatabaseRequestContext, _input, { json }) {
+        await this.handlerTx()
+          .mutate(({ forSchema }) =>
+            forSchema(userSchema).create("users", {
+              name: "User 1",
+              email: "user1@example.com",
+            }),
+          )
+          .execute();
+
+        await this.handlerTx()
+          .mutate(({ forSchema }) =>
+            forSchema(userSchema).create("users", {
+              name: "User 2",
+              email: "user2@example.com",
+            }),
+          )
+          .execute();
+
+        return json({ ok: true });
+      },
+    });
+
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment(
+        "user",
+        instantiate(userFragmentDef).withConfig({}).withRoutes([multiRoundtripRoute]),
+      )
+      .build();
+
+    const response = await fragments.user.callRoute("POST", "/multi");
+
+    expect(response.type).toBe("error");
+    if (response.type === "error") {
+      expect(response.error.code).toBe("DB_ROUNDTRIP_LIMIT_EXCEEDED");
+    }
+
+    await test.cleanup();
+  });
+
+  it("counts withServiceCalls retrieve roundtrips", async () => {
+    const userFragmentDef = defineFragment<{}>("user-roundtrip-fragment")
+      .extend(withDatabase(userSchema))
+      .providesBaseService(({ defineService }) =>
+        defineService({
+          listUsers: function () {
+            return this.serviceTx(userSchema)
+              .retrieve((uow) => uow.find("users"))
+              .build();
+          },
+        }),
+      )
+      .build();
+
+    const serviceRoutesFactory = ({
+      services,
+    }: {
+      services: { listUsers: () => TxResult<unknown, unknown> };
+    }) => [
+      defineRoute({
+        method: "POST",
+        path: "/service-multi",
+        outputSchema: z.object({ ok: z.boolean() }),
+        handler: async function (this: DatabaseRequestContext, _input, { json }) {
+          await this.handlerTx()
+            .withServiceCalls(() => [services.listUsers()])
+            .execute();
+
+          await this.handlerTx()
+            .withServiceCalls(() => [services.listUsers()])
+            .execute();
+
+          return json({ ok: true });
+        },
+      }),
+    ];
+
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment(
+        "user",
+        instantiate(userFragmentDef).withConfig({}).withRoutes([serviceRoutesFactory]),
+      )
+      .build();
+
+    const response = await fragments.user.callRoute("POST", "/service-multi");
+
+    expect(response.type).toBe("error");
+    if (response.type === "error") {
+      expect(response.error.code).toBe("DB_ROUNDTRIP_LIMIT_EXCEEDED");
+    }
+
+    await test.cleanup();
+  });
+
+  it("allows retrieve-only then mutate-only when maxRoundtrips is 1", async () => {
+    const userFragmentDef = defineFragment<{}>("user-roundtrip-fragment")
+      .extend(withDatabase(userSchema))
+      .providesBaseService(() => ({}))
+      .build();
+
+    const splitRoundtripRoute = defineRoute({
+      method: "POST",
+      path: "/split",
+      outputSchema: z.object({ count: z.number() }),
+      handler: async function (this: DatabaseRequestContext, _input, { json }) {
+        const existing = await this.handlerTx()
+          .retrieve(({ forSchema }) => forSchema(userSchema).find("users"))
+          .transformRetrieve(([users]) => users)
+          .execute();
+
+        await this.handlerTx()
+          .mutate(({ forSchema }) =>
+            forSchema(userSchema).create("users", {
+              name: "User 3",
+              email: "user3@example.com",
+            }),
+          )
+          .execute();
+
+        return json({ count: existing.length });
+      },
+    });
+
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withDbRoundtripGuard({ maxRoundtrips: 1 })
+      .withFragment(
+        "user",
+        instantiate(userFragmentDef).withConfig({}).withRoutes([splitRoundtripRoute]),
+      )
+      .build();
+
+    const response = await fragments.user.callRoute("POST", "/split");
+
+    expect(response.type).toBe("json");
+    if (response.type === "json") {
+      expect(response.data.count).toBe(0);
+    }
+
+    await test.cleanup();
+  });
+
+  it("does not enforce the guard inside inContext", async () => {
+    const userFragmentDef = defineFragment<{}>("user-roundtrip-fragment")
+      .extend(withDatabase(userSchema))
+      .providesBaseService(() => ({}))
+      .build();
+
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("user", instantiate(userFragmentDef).withConfig({}))
+      .build();
+
+    const result = await fragments.user.fragment.inContext(
+      async function (this: DatabaseRequestContext) {
+        await this.handlerTx()
+          .retrieve(({ forSchema }) => forSchema(userSchema).find("users"))
+          .execute();
+
+        await this.handlerTx()
+          .retrieve(({ forSchema }) => forSchema(userSchema).find("users"))
+          .execute();
+
+        return "ok";
+      },
+    );
+
+    expect(result).toBe("ok");
+
+    await test.cleanup();
+  });
+});