@fragno-dev/test 0.1.4 → 0.1.6

package/src/index.ts

@@ -1,8 +1,4 @@
-import { Kysely } from "kysely";
-import { SQLocalKysely } from "sqlocal/kysely";
-import { KyselyAdapter } from "@fragno-dev/db/adapters/kysely";
 import type { AnySchema } from "@fragno-dev/db/schema";
-import type { DatabaseAdapter } from "@fragno-dev/db/adapters";
 import {
   createFragmentForTest,
   type FragmentForTest,
@@ -10,6 +6,14 @@ import {
 } from "@fragno-dev/core/test";
 import type { FragnoPublicConfig } from "@fragno-dev/core/api/fragment-instantiation";
 import type { FragmentDefinition } from "@fragno-dev/core/api/fragment-builder";
+import {
+  createAdapter,
+  type SupportedAdapter,
+  type TestContext,
+  type KyselySqliteAdapter,
+  type KyselyPgliteAdapter,
+  type DrizzlePgliteAdapter,
+} from "./adapters";
 
 // Re-export utilities from @fragno-dev/core/test
 export {
@@ -21,6 +25,15 @@ export {
   type InitRoutesOverrides,
 } from "@fragno-dev/core/test";
 
+// Re-export adapter types
+export type {
+  SupportedAdapter,
+  KyselySqliteAdapter,
+  KyselyPgliteAdapter,
+  DrizzlePgliteAdapter,
+  TestContext,
+} from "./adapters";
+
 /**
  * Options for creating a database fragment for testing
  */
@@ -30,34 +43,48 @@ export interface CreateDatabaseFragmentForTestOptions<
   TServices,
   TAdditionalContext extends Record<string, unknown>,
   TOptions extends FragnoPublicConfig,
+  TAdapter extends SupportedAdapter,
 > extends Omit<
     CreateFragmentForTestOptions<TConfig, TDeps, TServices, TAdditionalContext, TOptions>,
     "config"
   > {
-  databasePath?: string;
+  adapter: TAdapter;
   migrateToVersion?: number;
   config?: TConfig;
 }
 
 /**
- * Extended fragment test instance with database adapter and Kysely instance
+ * Result of creating a database fragment for testing
+ * All properties are getters that return the current fragment instance
  */
-export interface DatabaseFragmentForTest<
+export interface DatabaseFragmentTestResult<
   TConfig,
   TDeps,
   TServices,
   TAdditionalContext extends Record<string, unknown>,
   TOptions extends FragnoPublicConfig,
-> extends FragmentForTest<TConfig, TDeps, TServices, TAdditionalContext, TOptions> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  kysely: Kysely<any>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  adapter: DatabaseAdapter<any>;
-  /**
-   * Resets the database by creating a fresh in-memory database instance and re-running migrations.
-   * After calling this, you should re-initialize any routes to ensure they use the new database instance.
-   */
-  resetDatabase: () => Promise<void>;
+  TAdapter extends SupportedAdapter,
+> {
+  readonly fragment: FragmentForTest<TConfig, TDeps, TServices, TAdditionalContext, TOptions>;
+  readonly services: TServices;
+  readonly initRoutes: FragmentForTest<
+    TConfig,
+    TDeps,
+    TServices,
+    TAdditionalContext,
+    TOptions
+  >["initRoutes"];
+  readonly handler: FragmentForTest<
+    TConfig,
+    TDeps,
+    TServices,
+    TAdditionalContext,
+    TOptions
+  >["handler"];
+  readonly config: TConfig;
+  readonly deps: TDeps;
+  readonly additionalContext: TAdditionalContext;
+  test: TestContext<TAdapter>;
 }
 
 export async function createDatabaseFragmentForTest<
@@ -67,28 +94,32 @@ export async function createDatabaseFragmentForTest<
   const TAdditionalContext extends Record<string, unknown>,
   const TOptions extends FragnoPublicConfig,
   const TSchema extends AnySchema,
+  const TAdapter extends SupportedAdapter,
 >(
   fragmentBuilder: {
     definition: FragmentDefinition<TConfig, TDeps, TServices, TAdditionalContext>;
     $requiredOptions: TOptions;
   },
-  options?: CreateDatabaseFragmentForTestOptions<
+  options: CreateDatabaseFragmentForTestOptions<
     TConfig,
     TDeps,
     TServices,
     TAdditionalContext,
-    TOptions
+    TOptions,
+    TAdapter
   >,
-): Promise<DatabaseFragmentForTest<TConfig, TDeps, TServices, TAdditionalContext, TOptions>> {
+): Promise<
+  DatabaseFragmentTestResult<TConfig, TDeps, TServices, TAdditionalContext, TOptions, TAdapter>
+> {
   const {
-    databasePath = ":memory:",
+    adapter: adapterConfig,
     migrateToVersion,
     config,
     options: fragmentOptions,
     deps,
     services,
     additionalContext,
-  } = options ?? {};
+  } = options;
 
   // Get schema and namespace from fragment definition's additionalContext
   // Safe cast: DatabaseFragmentBuilder adds databaseSchema and databaseNamespace to additionalContext
@@ -104,37 +135,13 @@ export async function createDatabaseFragmentForTest<
     );
   }
 
-  // Helper to create a new database instance and run migrations
-  const createDatabase = async () => {
-    // Create SQLocalKysely instance
-    const { dialect } = new SQLocalKysely(databasePath);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const kysely = new Kysely<any>({
-      dialect,
-    });
-
-    // Create KyselyAdapter
-    const adapter = new KyselyAdapter({
-      db: kysely,
-      provider: "sqlite",
-    });
-
-    // Run migrations
-    const migrator = adapter.createMigrationEngine(schema, namespace);
-    const preparedMigration = migrateToVersion
-      ? await migrator.prepareMigrationTo(migrateToVersion, {
-          updateSettings: false,
-        })
-      : await migrator.prepareMigration({
-          updateSettings: false,
-        });
-    await preparedMigration.execute();
-
-    return { kysely, adapter };
-  };
-
-  // Create initial database
-  let { kysely, adapter } = await createDatabase();
+  // Create adapter using the factory
+  const { testContext: originalTestContext, adapter } = await createAdapter(
+    adapterConfig,
+    schema,
+    namespace,
+    migrateToVersion,
+  );
 
   // Create fragment with database adapter in options
   // Safe cast: We're merging the user's options with the databaseAdapter, which is required by TOptions
@@ -155,32 +162,68 @@ export async function createDatabaseFragmentForTest<
     additionalContext,
   });
 
-  // Reset database function - creates a fresh in-memory database and re-runs migrations
-  const resetDatabase = async () => {
-    // Destroy the old Kysely instance
-    await kysely.destroy();
-
-    // Create a new database instance
-    const newDb = await createDatabase();
-    kysely = newDb.kysely;
-    adapter = newDb.adapter;
+  // Wrap resetDatabase to also recreate the fragment with the new adapter
+  const originalResetDatabase = originalTestContext.resetDatabase;
 
-    // Recreate the fragment with the new adapter
-    mergedOptions = {
-      ...fragmentOptions,
-      databaseAdapter: adapter,
-    } as unknown as TOptions;
-
-    fragment = createFragmentForTest(fragmentBuilder, {
-      config: config as TConfig,
-      options: mergedOptions,
-      deps,
-      services,
-      additionalContext,
-    });
-  };
+  // Create test context with getters that always return current values
+  // We need to cast to any to avoid TypeScript errors when accessing kysely/drizzle properties
+  // that may not exist depending on the adapter type
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const testContext: any = Object.create(originalTestContext, {
+    kysely: {
+      get() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (originalTestContext as any).kysely;
+      },
+      enumerable: true,
+    },
+    drizzle: {
+      get() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (originalTestContext as any).drizzle;
+      },
+      enumerable: true,
+    },
+    adapter: {
+      get() {
+        return originalTestContext.adapter;
+      },
+      enumerable: true,
+    },
+    resetDatabase: {
+      value: async () => {
+        // Call the original reset database function
+        await originalResetDatabase();
+
+        // Recreate the fragment with the new adapter (which has been updated by the factory's resetDatabase)
+        mergedOptions = {
+          ...fragmentOptions,
+          databaseAdapter: originalTestContext.adapter,
+        } as unknown as TOptions;
+
+        fragment = createFragmentForTest(fragmentBuilder, {
+          config: config as TConfig,
+          options: mergedOptions,
+          deps,
+          services,
+          additionalContext,
+        });
+      },
+      enumerable: true,
+    },
+    cleanup: {
+      value: async () => {
+        await originalTestContext.cleanup();
+      },
+      enumerable: true,
+    },
+  });
 
+  // Return an object with getters for fragment properties so they always reference the current fragment
   return {
+    get fragment() {
+      return fragment;
+    },
     get services() {
       return fragment.services;
     },
@@ -199,12 +242,6 @@ export async function createDatabaseFragmentForTest<
     get additionalContext() {
       return fragment.additionalContext;
     },
-    get kysely() {
-      return kysely;
-    },
-    get adapter() {
-      return adapter;
-    },
-    resetDatabase,
+    test: testContext,
   };
 }