@fragno-dev/test 0.1.11 → 0.1.13

package/src/index.ts

@@ -1,30 +1,19 @@
 import type { AnySchema } from "@fragno-dev/db/schema";
-import {
-  createFragmentForTest,
-  type FragmentForTest,
-  type CreateFragmentForTestOptions,
-} 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 type { AnyRouteOrFactory, FlattenRouteFactories } from "@fragno-dev/core/api/route";
-import {
-  createAdapter,
-  type SupportedAdapter,
-  type TestContext,
-  type KyselySqliteAdapter,
-  type KyselyPgliteAdapter,
-  type DrizzlePgliteAdapter,
+import type {
+  SupportedAdapter,
+  AdapterContext,
+  KyselySqliteAdapter,
+  KyselyPgliteAdapter,
+  DrizzlePgliteAdapter,
 } from "./adapters";
-import type { FragnoRouteConfig } from "@fragno-dev/core";
-import type { HTTPMethod } from "@fragno-dev/core/api";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { DatabaseAdapter } from "@fragno-dev/db";
+import type { AbstractQuery } from "@fragno-dev/db/query";
 
 // Re-export utilities from @fragno-dev/core/test
 export {
   createFragmentForTest,
   type CreateFragmentForTestOptions,
   type RouteHandlerInputOptions,
-  type FragmentForTest,
 } from "@fragno-dev/core/test";
 
 // Re-export adapter types
@@ -33,240 +22,49 @@ export type {
   KyselySqliteAdapter,
   KyselyPgliteAdapter,
   DrizzlePgliteAdapter,
-  TestContext,
+  AdapterContext,
 } from "./adapters";
 
+// Re-export new builder-based database test utilities
+export { buildDatabaseFragmentsTest, DatabaseFragmentsTestBuilder } from "./db-test";
+
 /**
- * Options for creating a database fragment for testing
+ * Base test context with common functionality across all adapters
  */
-export interface CreateDatabaseFragmentForTestOptions<
-  TConfig,
-  TDeps,
-  TServices,
-  TAdditionalContext extends Record<string, unknown>,
-  TOptions extends FragnoPublicConfig,
-  TAdapter extends SupportedAdapter,
-> extends Omit<
-    CreateFragmentForTestOptions<TConfig, TDeps, TServices, TAdditionalContext, TOptions>,
-    "config"
-  > {
-  adapter: TAdapter;
-  migrateToVersion?: number;
-  config?: TConfig;
+export interface BaseTestContext {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  readonly adapter: DatabaseAdapter<any>;
+  resetDatabase: () => Promise<void>;
+  cleanup: () => Promise<void>;
 }
 
 /**
- * Result of creating a database fragment for testing
- * All properties are getters that return the current fragment instance
+ * Internal interface with getOrm for adapter implementations
  */
-export interface DatabaseFragmentTestResult<
-  TConfig,
-  TDeps,
-  TServices,
-  TAdditionalContext extends Record<string, unknown>,
-  TOptions extends FragnoPublicConfig,
-  TAdapter extends SupportedAdapter,
-  TRoutes extends readonly FragnoRouteConfig<
-    HTTPMethod,
-    string,
-    StandardSchemaV1 | undefined,
-    StandardSchemaV1 | undefined,
-    string,
-    string
-  >[],
-> {
-  readonly fragment: FragmentForTest<
-    TConfig,
-    TDeps,
-    TServices,
-    TAdditionalContext,
-    TOptions,
-    TRoutes
-  >;
-  readonly services: TServices;
-  readonly callRoute: FragmentForTest<
-    TConfig,
-    TDeps,
-    TServices,
-    TAdditionalContext,
-    TOptions,
-    TRoutes
-  >["callRoute"];
-  readonly config: TConfig;
-  readonly deps: TDeps;
-  readonly additionalContext: TAdditionalContext;
-  test: TestContext<TAdapter>;
+export interface InternalTestContextMethods {
+  getOrm: <TSchema extends AnySchema>(namespace: string) => AbstractQuery<TSchema>;
 }
 
-export async function createDatabaseFragmentForTest<
-  const TConfig,
-  const TDeps,
-  const TServices extends Record<string, unknown>,
-  const TAdditionalContext extends Record<string, unknown>,
-  const TOptions extends FragnoPublicConfig,
-  const TSchema extends AnySchema,
-  const TAdapter extends SupportedAdapter,
-  const TRoutesOrFactories extends readonly AnyRouteOrFactory[],
->(
-  fragmentBuilder: {
-    definition: FragmentDefinition<TConfig, TDeps, TServices, TAdditionalContext>;
-    $requiredOptions: TOptions;
-  },
-  routesOrFactories: TRoutesOrFactories,
-  options: CreateDatabaseFragmentForTestOptions<
-    TConfig,
-    TDeps,
-    TServices,
-    TAdditionalContext,
-    TOptions,
-    TAdapter
-  >,
-): Promise<
-  DatabaseFragmentTestResult<
-    TConfig,
-    TDeps,
-    TServices,
-    TAdditionalContext,
-    TOptions,
-    TAdapter,
-    FlattenRouteFactories<TRoutesOrFactories>
-  >
-> {
-  const {
-    adapter: adapterConfig,
-    migrateToVersion,
-    config,
-    options: fragmentOptions,
-    deps,
-    services,
-    additionalContext,
-  } = options;
-
-  // Get schema and namespace from fragment definition's additionalContext
-  // Safe cast: DatabaseFragmentBuilder adds databaseSchema and databaseNamespace to additionalContext
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const fragmentAdditionalContext = fragmentBuilder.definition.additionalContext as any;
-  const schema = fragmentAdditionalContext?.databaseSchema as TSchema | undefined;
-  const namespace = (fragmentAdditionalContext?.databaseNamespace as string | undefined) ?? "";
-
-  if (!schema) {
-    throw new Error(
-      `Fragment '${fragmentBuilder.definition.name}' does not have a database schema. ` +
-        `Make sure you're using defineFragmentWithDatabase().withDatabase(schema).`,
-    );
-  }
-
-  // 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
-  // The user's TOptions is constrained to FragnoPublicConfig (or a subtype), which we extend with databaseAdapter
-  let mergedOptions = {
-    ...fragmentOptions,
-    databaseAdapter: adapter,
-  } as unknown as TOptions;
-
-  let fragment = createFragmentForTest(fragmentBuilder, routesOrFactories, {
-    // Safe cast: If config is not provided, we pass undefined as TConfig.
-    // The base createFragmentForTest expects config: TConfig, but if TConfig allows undefined
-    // or if the fragment doesn't use config in its dependencies function, this will work correctly.
-    config: config as TConfig,
-    options: mergedOptions,
-    deps,
-    services,
-    additionalContext,
-  });
-
-  // Wrap resetDatabase to also recreate the fragment with the new adapter
-  const originalResetDatabase = originalTestContext.resetDatabase;
-
-  // 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
+/**
+ * Helper to create common test context methods from an ORM map
+ * This is used internally by adapter implementations to avoid code duplication
+ */
+export function createCommonTestContextMethods(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const testContext: any = Object.create(originalTestContext, {
-    db: {
-      get() {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return (originalTestContext as any).db;
-      },
-      enumerable: true,
-    },
-    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, routesOrFactories, {
-          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
+  ormMap: Map<string, AbstractQuery<any>>,
+): InternalTestContextMethods {
   return {
-    get fragment() {
-      return fragment;
-    },
-    get services() {
-      return fragment.services;
-    },
-    get callRoute() {
-      return fragment.callRoute;
-    },
-    get config() {
-      return fragment.config;
-    },
-    get deps() {
-      return fragment.deps;
+    getOrm: <TSchema extends AnySchema>(namespace: string) => {
+      const orm = ormMap.get(namespace);
+      if (!orm) {
+        throw new Error(`No ORM found for namespace: ${namespace}`);
+      }
+      return orm as AbstractQuery<TSchema>;
     },
-    get additionalContext() {
-      return fragment.additionalContext;
-    },
-    test: testContext,
   };
 }
+
+/**
+ * Complete test context combining base and adapter-specific functionality
+ */
+export type TestContext<T extends SupportedAdapter> = BaseTestContext & AdapterContext<T>;