@fragno-dev/test 0.1.12 → 0.1.13

package/dist/index.js

@@ -1,6 +1,5 @@
-import { createAdapter } from "./adapters.js";
-import { createFragmentForTest, createFragmentForTest as createFragmentForTest$1 } from "@fragno-dev/core/test";
-import { withUnitOfWork } from "@fragno-dev/db";
+import { DatabaseFragmentsTestBuilder, buildDatabaseFragmentsTest } from "./db-test.js";
+import { createFragmentForTest } from "@fragno-dev/core/test";
 
 //#region src/index.ts
 /**
@@ -8,147 +7,13 @@ import { withUnitOfWork } from "@fragno-dev/db";
 * This is used internally by adapter implementations to avoid code duplication
 */
 function createCommonTestContextMethods(ormMap) {
-	return {
-		getOrm: (namespace) => {
-			const orm = ormMap.get(namespace);
-			if (!orm) throw new Error(`No ORM found for namespace: ${namespace}`);
-			return orm;
-		},
-		createUnitOfWork: (name) => {
-			const firstOrm = ormMap.values().next().value;
-			if (!firstOrm) throw new Error("No ORMs available to create UnitOfWork");
-			return firstOrm.createUnitOfWork(name);
-		},
-		withUnitOfWork: async (fn) => {
-			const firstOrm = ormMap.values().next().value;
-			if (!firstOrm) throw new Error("No ORMs available to create UnitOfWork");
-			const uow = firstOrm.createUnitOfWork();
-			return withUnitOfWork(uow, async () => {
-				return await fn(uow);
-			});
-		},
-		callService: async (fn) => {
-			const firstOrm = ormMap.values().next().value;
-			if (!firstOrm) throw new Error("No ORMs available to create UnitOfWork");
-			const uow = firstOrm.createUnitOfWork();
-			return withUnitOfWork(uow, async () => {
-				const resultPromise = fn();
-				await uow.executeRetrieve();
-				await uow.executeMutations();
-				return await resultPromise;
-			});
-		}
-	};
-}
-/**
-* Implementation of createDatabaseFragmentsForTest
-*/
-async function createDatabaseFragmentsForTest(fragments, options) {
-	const { adapter: adapterConfig } = options;
-	const isArray = Array.isArray(fragments);
-	const fragmentsArray = isArray ? fragments : Object.values(fragments);
-	const schemaConfigs = fragmentsArray.map((fragmentConfig) => {
-		const fragmentAdditionalContext = fragmentConfig.definition.definition.additionalContext;
-		const schema = fragmentAdditionalContext?.databaseSchema;
-		const namespace = fragmentAdditionalContext?.databaseNamespace ?? fragmentConfig.definition.definition.name + "-db";
-		if (!schema) throw new Error(`Fragment '${fragmentConfig.definition.definition.name}' does not have a database schema. Make sure you're using defineFragmentWithDatabase().withDatabase(schema).`);
-		return {
-			schema,
-			namespace,
-			migrateToVersion: fragmentConfig.migrateToVersion
-		};
-	});
-	const { testContext, adapter } = await createAdapter(adapterConfig, schemaConfigs);
-	const createFragments = () => {
-		const providedServicesByName = {};
-		for (let i = 0; i < fragmentsArray.length; i++) {
-			const fragmentConfig = fragmentsArray[i];
-			const namespace = schemaConfigs[i].namespace;
-			const orm = testContext.getOrm(namespace);
-			const mergedOptions = { databaseAdapter: adapter };
-			const tempFragment = createFragmentForTest$1(fragmentConfig.definition, [], {
-				config: fragmentConfig.config ?? {},
-				options: mergedOptions,
-				interfaceImplementations: {}
-			});
-			const providedServicesMetadata = fragmentConfig.definition.definition.providedServices;
-			if (providedServicesMetadata) {
-				const serviceNames = typeof providedServicesMetadata === "function" ? Object.keys(tempFragment.services) : Object.keys(providedServicesMetadata);
-				for (const serviceName of serviceNames) if (tempFragment.services[serviceName]) providedServicesByName[serviceName] = {
-					service: tempFragment.services[serviceName],
-					orm
-				};
-			}
-		}
-		return fragmentsArray.map((fragmentConfig, index) => {
-			const namespace = schemaConfigs[index].namespace;
-			const schema = schemaConfigs[index].schema;
-			const orm = testContext.getOrm(namespace);
-			const mergedOptions = { databaseAdapter: adapter };
-			const interfaceImplementations = {};
-			const usedServices = fragmentConfig.definition.definition.usedServices;
-			if (usedServices) {
-				for (const serviceName of Object.keys(usedServices)) if (providedServicesByName[serviceName]) interfaceImplementations[serviceName] = providedServicesByName[serviceName].service;
-			}
-			const fragment = createFragmentForTest$1(fragmentConfig.definition, fragmentConfig.routes, {
-				config: fragmentConfig.config ?? {},
-				options: mergedOptions,
-				interfaceImplementations
-			});
-			return {
-				fragment,
-				services: fragment.services,
-				callRoute: fragment.callRoute,
-				config: fragment.config,
-				deps: fragment.deps,
-				additionalContext: fragment.additionalContext,
-				get db() {
-					return orm;
-				},
-				_orm: orm,
-				_schema: schema
-			};
-		});
-	};
-	const fragmentResults = createFragments();
-	const originalResetDatabase = testContext.resetDatabase;
-	const resetDatabase = async () => {
-		await originalResetDatabase();
-		createFragments().forEach((newResult, index) => {
-			const result = fragmentResults[index];
-			result.fragment = newResult.fragment;
-			result.services = newResult.services;
-			result.callRoute = newResult.callRoute;
-			result.config = newResult.config;
-			result.deps = newResult.deps;
-			result.additionalContext = newResult.additionalContext;
-			result._orm = newResult._orm;
-		});
-	};
-	const finalTestContext = {
-		...testContext,
-		resetDatabase
-	};
-	if (isArray) return {
-		fragments: fragmentResults,
-		test: finalTestContext
-	};
-	else {
-		const keys = Object.keys(fragments);
-		return {
-			fragments: Object.fromEntries(keys.map((key, index) => [key, fragmentResults[index]])),
-			test: finalTestContext
-		};
-	}
-}
-async function createDatabaseFragmentForTest(fragment, options) {
-	const result = await createDatabaseFragmentsForTest([fragment], options);
-	return {
-		fragment: result.fragments[0],
-		test: result.test
-	};
+	return { getOrm: (namespace) => {
+		const orm = ormMap.get(namespace);
+		if (!orm) throw new Error(`No ORM found for namespace: ${namespace}`);
+		return orm;
+	} };
 }
 
 //#endregion
-export { createCommonTestContextMethods, createDatabaseFragmentForTest, createDatabaseFragmentsForTest, createFragmentForTest };
+export { DatabaseFragmentsTestBuilder, buildDatabaseFragmentsTest, createCommonTestContextMethods, createFragmentForTest };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["fragmentsArray: FragmentConfig[]","schemaConfigs: SchemaConfig[]","providedServicesByName: Record<string, { service: any; orm: any }>","createFragmentForTest","interfaceImplementations: Record<string, any>"],"sources":["../src/index.ts"],"sourcesContent":["import type { AnySchema } from \"@fragno-dev/db/schema\";\nimport {\n  createFragmentForTest,\n  type FragmentForTest,\n  type CreateFragmentForTestOptions,\n} from \"@fragno-dev/core/test\";\nimport type { FragnoPublicConfig } from \"@fragno-dev/core/api/fragment-instantiation\";\nimport type { FragmentDefinition } from \"@fragno-dev/core/api/fragment-builder\";\nimport type { AnyRouteOrFactory, FlattenRouteFactories } from \"@fragno-dev/core/api/route\";\nimport {\n  createAdapter,\n  type SupportedAdapter,\n  type AdapterContext,\n  type KyselySqliteAdapter,\n  type KyselyPgliteAdapter,\n  type DrizzlePgliteAdapter,\n  type SchemaConfig,\n} from \"./adapters\";\nimport { withUnitOfWork, type IUnitOfWorkBase, type DatabaseAdapter } from \"@fragno-dev/db\";\nimport type { AbstractQuery } from \"@fragno-dev/db/query\";\n\n// Re-export utilities from @fragno-dev/core/test\nexport {\n  createFragmentForTest,\n  type CreateFragmentForTestOptions,\n  type RouteHandlerInputOptions,\n  type FragmentForTest,\n} from \"@fragno-dev/core/test\";\n\n// Re-export adapter types\nexport type {\n  SupportedAdapter,\n  KyselySqliteAdapter,\n  KyselyPgliteAdapter,\n  DrizzlePgliteAdapter,\n  AdapterContext,\n} from \"./adapters\";\n\n/**\n * Base test context with common functionality across all adapters\n */\nexport interface BaseTestContext {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  readonly adapter: DatabaseAdapter<any>;\n  createUnitOfWork: (name?: string) => IUnitOfWorkBase;\n  withUnitOfWork: <T>(fn: (uow: IUnitOfWorkBase) => Promise<T>) => Promise<T>;\n  callService: <T>(fn: () => T | Promise<T>) => Promise<T>;\n  resetDatabase: () => Promise<void>;\n  cleanup: () => Promise<void>;\n}\n\n/**\n * Internal interface with getOrm for adapter implementations\n */\nexport interface InternalTestContextMethods {\n  getOrm: <TSchema extends AnySchema>(namespace: string) => AbstractQuery<TSchema>;\n  createUnitOfWork: (name?: string) => IUnitOfWorkBase;\n  withUnitOfWork: <T>(fn: (uow: IUnitOfWorkBase) => Promise<T>) => Promise<T>;\n  callService: <T>(fn: () => T | Promise<T>) => Promise<T>;\n}\n\n/**\n * Helper to create common test context methods from an ORM map\n * This is used internally by adapter implementations to avoid code duplication\n */\nexport function createCommonTestContextMethods(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ormMap: Map<string, AbstractQuery<any>>,\n): InternalTestContextMethods {\n  return {\n    getOrm: <TSchema extends AnySchema>(namespace: string) => {\n      const orm = ormMap.get(namespace);\n      if (!orm) {\n        throw new Error(`No ORM found for namespace: ${namespace}`);\n      }\n      return orm as AbstractQuery<TSchema>;\n    },\n    createUnitOfWork: (name?: string) => {\n      // Use the first schema's ORM to create a base UOW\n      const firstOrm = ormMap.values().next().value;\n      if (!firstOrm) {\n        throw new Error(\"No ORMs available to create UnitOfWork\");\n      }\n      return firstOrm.createUnitOfWork(name);\n    },\n    withUnitOfWork: async <T>(fn: (uow: IUnitOfWorkBase) => Promise<T>) => {\n      const firstOrm = ormMap.values().next().value;\n      if (!firstOrm) {\n        throw new Error(\"No ORMs available to create UnitOfWork\");\n      }\n      const uow = firstOrm.createUnitOfWork();\n      return withUnitOfWork(uow, async () => {\n        return await fn(uow);\n      });\n    },\n    callService: async <T>(fn: () => T | Promise<T>) => {\n      const firstOrm = ormMap.values().next().value;\n      if (!firstOrm) {\n        throw new Error(\"No ORMs available to create UnitOfWork\");\n      }\n      const uow = firstOrm.createUnitOfWork();\n      return withUnitOfWork(uow, async () => {\n        // Call the function to schedule operations (don't await yet)\n        const resultPromise = fn();\n\n        // Execute UOW phases\n        await uow.executeRetrieve();\n        await uow.executeMutations();\n\n        // Now await the result\n        return await resultPromise;\n      });\n    },\n  };\n}\n\n/**\n * Complete test context combining base and adapter-specific functionality\n */\nexport type TestContext<T extends SupportedAdapter> = BaseTestContext & AdapterContext<T>;\n\n/**\n * Helper type to extract the schema from a fragment definition's additional context\n */\ntype ExtractSchemaFromAdditionalContext<TAdditionalContext> = TAdditionalContext extends {\n  databaseSchema?: infer TSchema extends AnySchema;\n}\n  ? TSchema\n  : AnySchema;\n\n/**\n * Fragment configuration for multi-fragment setup\n */\nexport interface FragmentConfig<\n  TDef extends {\n    definition: FragmentDefinition<any, any, any, any, any, any>; // eslint-disable-line @typescript-eslint/no-explicit-any\n    $requiredOptions: any; // eslint-disable-line @typescript-eslint/no-explicit-any\n  } = {\n    definition: FragmentDefinition<any, any, any, any, any, any>; // eslint-disable-line @typescript-eslint/no-explicit-any\n    $requiredOptions: any; // eslint-disable-line @typescript-eslint/no-explicit-any\n  },\n  TRoutes extends readonly AnyRouteOrFactory[] = readonly AnyRouteOrFactory[],\n> {\n  definition: TDef;\n  routes: TRoutes;\n  config?: TDef[\"definition\"] extends FragmentDefinition<infer TConfig, any, any, any, any, any> // eslint-disable-line @typescript-eslint/no-explicit-any\n    ? TConfig\n    : never;\n  migrateToVersion?: number;\n}\n\n/**\n * Options for creating multiple database fragments for testing\n */\nexport interface MultiFragmentTestOptions<TAdapter extends SupportedAdapter> {\n  adapter: TAdapter;\n}\n\n/**\n * Result type for a single fragment in a multi-fragment setup\n */\ntype FragmentResultFromConfig<TConfig extends FragmentConfig> = TConfig[\"definition\"] extends {\n  definition: FragmentDefinition<\n    infer TConf,\n    infer TDeps,\n    infer TServices,\n    infer TAdditionalCtx,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    any,\n    infer TProvidedServices\n  >;\n  $requiredOptions: infer TOptions extends FragnoPublicConfig;\n}\n  ? {\n      fragment: FragmentForTest<\n        TConf,\n        TDeps,\n        TServices & TProvidedServices,\n        TAdditionalCtx,\n        TOptions,\n        FlattenRouteFactories<TConfig[\"routes\"]>\n      >;\n      services: TServices & TProvidedServices;\n      callRoute: FragmentForTest<\n        TConf,\n        TDeps,\n        TServices & TProvidedServices,\n        TAdditionalCtx,\n        TOptions,\n        FlattenRouteFactories<TConfig[\"routes\"]>\n      >[\"callRoute\"];\n      config: TConf;\n      deps: TDeps;\n      additionalContext: TAdditionalCtx;\n      db: AbstractQuery<ExtractSchemaFromAdditionalContext<TAdditionalCtx>>;\n    }\n  : never;\n\nexport interface SingleFragmentTestResult<\n  TFragment extends FragmentConfig,\n  TAdapter extends SupportedAdapter,\n> {\n  fragment: FragmentResultFromConfig<TFragment>;\n  test: TestContext<TAdapter>;\n}\n\n/**\n * Result of creating multiple database fragments for testing (array input)\n */\nexport interface MultiFragmentTestResult<\n  TFragments extends readonly FragmentConfig[],\n  TAdapter extends SupportedAdapter,\n> {\n  fragments: {\n    [K in keyof TFragments]: FragmentResultFromConfig<TFragments[K]>;\n  };\n  test: TestContext<TAdapter>;\n}\n\n/**\n * Result of creating multiple database fragments for testing (object input)\n */\nexport interface NamedMultiFragmentTestResult<\n  TFragments extends Record<string, FragmentConfig>,\n  TAdapter extends SupportedAdapter,\n> {\n  fragments: {\n    [K in keyof TFragments]: FragmentResultFromConfig<TFragments[K]>;\n  };\n  test: TestContext<TAdapter>;\n}\n\n/**\n * Create multiple database fragments for testing with a shared adapter (array input)\n */\nexport async function createDatabaseFragmentsForTest<\n  const TFragments extends readonly FragmentConfig[],\n  const TAdapter extends SupportedAdapter,\n>(\n  fragments: TFragments,\n  options: MultiFragmentTestOptions<TAdapter>,\n): Promise<MultiFragmentTestResult<TFragments, TAdapter>>;\n\n/**\n * Create multiple database fragments for testing with a shared adapter (object input)\n */\nexport async function createDatabaseFragmentsForTest<\n  const TFragments extends Record<string, FragmentConfig>,\n  const TAdapter extends SupportedAdapter,\n>(\n  fragments: TFragments,\n  options: MultiFragmentTestOptions<TAdapter>,\n): Promise<NamedMultiFragmentTestResult<TFragments, TAdapter>>;\n\n/**\n * Implementation of createDatabaseFragmentsForTest\n */\nexport async function createDatabaseFragmentsForTest<\n  const TFragments extends readonly FragmentConfig[] | Record<string, FragmentConfig>,\n  const TAdapter extends SupportedAdapter,\n>(\n  fragments: TFragments,\n  options: MultiFragmentTestOptions<TAdapter>,\n): Promise<\n  | MultiFragmentTestResult<any, TAdapter> // eslint-disable-line @typescript-eslint/no-explicit-any\n  | NamedMultiFragmentTestResult<any, TAdapter> // eslint-disable-line @typescript-eslint/no-explicit-any\n> {\n  const { adapter: adapterConfig } = options;\n\n  // Convert to array for processing\n  const isArray = Array.isArray(fragments);\n  const fragmentsArray: FragmentConfig[] = isArray\n    ? fragments\n    : Object.values(fragments as Record<string, FragmentConfig>);\n\n  // Extract schemas from all fragments\n  const schemaConfigs: SchemaConfig[] = fragmentsArray.map((fragmentConfig) => {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const fragmentAdditionalContext = fragmentConfig.definition.definition.additionalContext as any;\n    const schema = fragmentAdditionalContext?.databaseSchema as AnySchema | undefined;\n    const namespace =\n      (fragmentAdditionalContext?.databaseNamespace as string | undefined) ??\n      fragmentConfig.definition.definition.name + \"-db\";\n\n    if (!schema) {\n      throw new Error(\n        `Fragment '${fragmentConfig.definition.definition.name}' does not have a database schema. ` +\n          `Make sure you're using defineFragmentWithDatabase().withDatabase(schema).`,\n      );\n    }\n\n    return {\n      schema,\n      namespace,\n      migrateToVersion: fragmentConfig.migrateToVersion,\n    };\n  });\n\n  // Create adapter with all schemas\n  const { testContext, adapter } = await createAdapter(adapterConfig, schemaConfigs);\n\n  // Helper to create fragments with service wiring\n  const createFragments = () => {\n    // First pass: create fragments without dependencies to extract their provided services\n    // Map from service name to { service: wrapped service, orm: ORM for that service's schema }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const providedServicesByName: Record<string, { service: any; orm: any }> = {};\n\n    for (let i = 0; i < fragmentsArray.length; i++) {\n      const fragmentConfig = fragmentsArray[i]!;\n      const namespace = schemaConfigs[i]!.namespace;\n      const orm = testContext.getOrm(namespace);\n\n      // Create fragment without interface implementations to extract its services\n      const mergedOptions = {\n        databaseAdapter: adapter,\n      };\n\n      const tempFragment = createFragmentForTest(fragmentConfig.definition, [], {\n        config: fragmentConfig.config ?? {},\n        options: mergedOptions,\n        interfaceImplementations: {},\n      });\n\n      // Extract provided services from the created fragment\n      // Check which services this fragment provides\n      const providedServicesMetadata = fragmentConfig.definition.definition.providedServices;\n      if (providedServicesMetadata) {\n        // If providedServices is a function, it returns all services\n        // If it's an object, the keys are the service names\n        const serviceNames =\n          typeof providedServicesMetadata === \"function\"\n            ? Object.keys(tempFragment.services)\n            : Object.keys(providedServicesMetadata);\n\n        for (const serviceName of serviceNames) {\n          if (tempFragment.services[serviceName]) {\n            providedServicesByName[serviceName] = {\n              service: tempFragment.services[serviceName],\n              orm,\n            };\n          }\n        }\n      }\n    }\n\n    // Second pass: create fragments with service dependencies wired up\n    return fragmentsArray.map((fragmentConfig, index) => {\n      const namespace = schemaConfigs[index]!.namespace;\n\n      // Get ORM for this fragment's namespace\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const schema = schemaConfigs[index]!.schema as any;\n      const orm = testContext.getOrm(namespace);\n\n      // Create fragment with database adapter in options\n      const mergedOptions = {\n        databaseAdapter: adapter,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } as any;\n\n      // Build interface implementations for services this fragment uses\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const interfaceImplementations: Record<string, any> = {};\n      const usedServices = fragmentConfig.definition.definition.usedServices;\n\n      if (usedServices) {\n        for (const serviceName of Object.keys(usedServices)) {\n          if (providedServicesByName[serviceName]) {\n            // Use the wrapped service\n            interfaceImplementations[serviceName] = providedServicesByName[serviceName]!.service;\n          }\n        }\n      }\n\n      const fragment = createFragmentForTest(fragmentConfig.definition, fragmentConfig.routes, {\n        config: (fragmentConfig.config ?? {}) as any, // eslint-disable-line @typescript-eslint/no-explicit-any\n        options: mergedOptions,\n        interfaceImplementations,\n      });\n\n      // Return fragment services without wrapping - users manage UOW lifecycle explicitly\n      return {\n        fragment,\n        services: fragment.services,\n        callRoute: fragment.callRoute,\n        config: fragment.config,\n        deps: fragment.deps,\n        additionalContext: fragment.additionalContext,\n        get db() {\n          return orm;\n        },\n        _orm: orm,\n        _schema: schema,\n      };\n    });\n  };\n\n  const fragmentResults = createFragments();\n\n  // Wrap resetDatabase to also recreate all fragments\n  const originalResetDatabase = testContext.resetDatabase;\n  const resetDatabase = async () => {\n    await originalResetDatabase();\n\n    // Recreate all fragments with service wiring\n    const newFragmentResults = createFragments();\n\n    // Update the result objects\n    newFragmentResults.forEach((newResult, index) => {\n      const result = fragmentResults[index]!;\n      result.fragment = newResult.fragment;\n      result.services = newResult.services;\n      result.callRoute = newResult.callRoute;\n      result.config = newResult.config;\n      result.deps = newResult.deps;\n      result.additionalContext = newResult.additionalContext;\n      result._orm = newResult._orm;\n    });\n  };\n\n  const finalTestContext = {\n    ...testContext,\n    resetDatabase,\n  };\n\n  // Return in the same structure as input\n  if (isArray) {\n    return {\n      fragments: fragmentResults as any, // eslint-disable-line @typescript-eslint/no-explicit-any\n      test: finalTestContext,\n    };\n  } else {\n    const keys = Object.keys(fragments as Record<string, FragmentConfig>);\n    const fragmentsObject = Object.fromEntries(\n      keys.map((key, index) => [key, fragmentResults[index]]),\n    );\n    return {\n      fragments: fragmentsObject as any, // eslint-disable-line @typescript-eslint/no-explicit-any\n      test: finalTestContext,\n    };\n  }\n}\n\nexport async function createDatabaseFragmentForTest<\n  const TFragment extends FragmentConfig,\n  const TAdapter extends SupportedAdapter,\n>(\n  fragment: TFragment,\n  options: MultiFragmentTestOptions<TAdapter>,\n): Promise<SingleFragmentTestResult<TFragment, TAdapter>> {\n  const result = await createDatabaseFragmentsForTest([fragment], options);\n\n  return {\n    fragment: result.fragments[0]!,\n    test: result.test,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { AnySchema } from \"@fragno-dev/db/schema\";\nimport type {\n  SupportedAdapter,\n  AdapterContext,\n  KyselySqliteAdapter,\n  KyselyPgliteAdapter,\n  DrizzlePgliteAdapter,\n} from \"./adapters\";\nimport type { DatabaseAdapter } from \"@fragno-dev/db\";\nimport type { AbstractQuery } from \"@fragno-dev/db/query\";\n\n// Re-export utilities from @fragno-dev/core/test\nexport {\n  createFragmentForTest,\n  type CreateFragmentForTestOptions,\n  type RouteHandlerInputOptions,\n} from \"@fragno-dev/core/test\";\n\n// Re-export adapter types\nexport type {\n  SupportedAdapter,\n  KyselySqliteAdapter,\n  KyselyPgliteAdapter,\n  DrizzlePgliteAdapter,\n  AdapterContext,\n} from \"./adapters\";\n\n// Re-export new builder-based database test utilities\nexport { buildDatabaseFragmentsTest, DatabaseFragmentsTestBuilder } from \"./db-test\";\n\n/**\n * Base test context with common functionality across all adapters\n */\nexport interface BaseTestContext {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  readonly adapter: DatabaseAdapter<any>;\n  resetDatabase: () => Promise<void>;\n  cleanup: () => Promise<void>;\n}\n\n/**\n * Internal interface with getOrm for adapter implementations\n */\nexport interface InternalTestContextMethods {\n  getOrm: <TSchema extends AnySchema>(namespace: string) => AbstractQuery<TSchema>;\n}\n\n/**\n * Helper to create common test context methods from an ORM map\n * This is used internally by adapter implementations to avoid code duplication\n */\nexport function createCommonTestContextMethods(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ormMap: Map<string, AbstractQuery<any>>,\n): InternalTestContextMethods {\n  return {\n    getOrm: <TSchema extends AnySchema>(namespace: string) => {\n      const orm = ormMap.get(namespace);\n      if (!orm) {\n        throw new Error(`No ORM found for namespace: ${namespace}`);\n      }\n      return orm as AbstractQuery<TSchema>;\n    },\n  };\n}\n\n/**\n * Complete test context combining base and adapter-specific functionality\n */\nexport type TestContext<T extends SupportedAdapter> = BaseTestContext & AdapterContext<T>;\n"],"mappings":";;;;;;;;AAmDA,SAAgB,+BAEd,QAC4B;AAC5B,QAAO,EACL,SAAoC,cAAsB;EACxD,MAAM,MAAM,OAAO,IAAI,UAAU;AACjC,MAAI,CAAC,IACH,OAAM,IAAI,MAAM,+BAA+B,YAAY;AAE7D,SAAO;IAEV"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fragno-dev/test",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "type": "module",
   "exports": {
     ".": {
@@ -15,15 +15,15 @@
   "dependencies": {
     "@standard-schema/spec": "^1.0.0",
     "kysely": "^0.28.7",
-    "sqlocal": "^0.15.2",
-    "@fragno-dev/core": "0.1.8",
-    "@fragno-dev/db": "0.1.14"
+    "sqlocal": "^0.15.2"
   },
   "peerDependencies": {
     "@electric-sql/pglite": "^0.3.11",
     "drizzle-kit": "^0.30.3",
     "drizzle-orm": "^0.44.7",
-    "kysely-pglite": "^0.6.1"
+    "kysely-pglite": "^0.6.1",
+    "@fragno-dev/core": "0.1.9",
+    "@fragno-dev/db": "0.1.15"
   },
   "peerDependenciesMeta": {
     "@electric-sql/pglite": {
@@ -49,6 +49,8 @@
     "kysely-pglite": "^0.6.1",
     "vitest": "^3.2.4",
     "zod": "^4.1.12",
+    "@fragno-dev/core": "0.1.9",
+    "@fragno-dev/db": "0.1.15",
     "@fragno-private/typescript-config": "0.0.1",
     "@fragno-private/vitest-config": "0.0.0"
   },

package/src/db-test.test.ts

@@ -0,0 +1,352 @@
+import { assert, describe, expect, it } from "vitest";
+import { column, idColumn, schema } from "@fragno-dev/db/schema";
+import { withDatabase } from "@fragno-dev/db";
+import { defineFragment, instantiate } from "@fragno-dev/core";
+import { defineRoute } from "@fragno-dev/core/route";
+import { z } from "zod";
+import { buildDatabaseFragmentsTest } from "./db-test";
+
+// Test schema with users table
+const userSchema = schema((s) => {
+  return s.addTable("users", (t) => {
+    return t
+      .addColumn("id", idColumn())
+      .addColumn("name", column("string"))
+      .addColumn("email", column("string"))
+      .createIndex("idx_users_all", ["id"]);
+  });
+});
+
+// Test schema with posts table
+const postSchema = schema((s) => {
+  return s.addTable("posts", (t) => {
+    return t
+      .addColumn("id", idColumn())
+      .addColumn("title", column("string"))
+      .addColumn("userId", column("string"))
+      .createIndex("idx_posts_all", ["id"]);
+  });
+});
+
+describe("buildDatabaseFragmentsTest", () => {
+  it("should create multiple fragments with shared adapter", async () => {
+    // Define fragments using new API
+    const userFragmentDef = defineFragment<{}>("user-fragment")
+      .extend(withDatabase(userSchema))
+      .providesBaseService(({ deps }) => ({
+        createUser: async (data: { name: string; email: string }) => {
+          const id = await deps.db.create("users", data);
+          return { ...data, id: id.valueOf() };
+        },
+        getUsers: async () => {
+          const users = await deps.db.find("users", (b) =>
+            b.whereIndex("idx_users_all", (eb) => eb("id", "!=", "")),
+          );
+          return users.map((u) => ({ ...u, id: u.id.valueOf() }));
+        },
+      }))
+      .build();
+
+    const postFragmentDef = defineFragment<{}>("post-fragment")
+      .extend(withDatabase(postSchema))
+      .providesBaseService(({ deps }) => ({
+        createPost: async (data: { title: string; userId: string }) => {
+          const id = await deps.db.create("posts", data);
+          return { ...data, id: id.valueOf() };
+        },
+        getPosts: async () => {
+          const posts = await deps.db.find("posts", (b) =>
+            b.whereIndex("idx_posts_all", (eb) => eb("id", "!=", "")),
+          );
+          return posts.map((p) => ({ ...p, id: p.id.valueOf() }));
+        },
+      }))
+      .build();
+
+    // Build test setup with new builder API
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("user", instantiate(userFragmentDef).withConfig({}).withRoutes([]))
+      .withFragment("post", instantiate(postFragmentDef).withConfig({}).withRoutes([]))
+      .build();
+
+    // Test user fragment
+    const user = await fragments.user.services.createUser({
+      name: "Test User",
+      email: "test@example.com",
+    });
+
+    expect(user).toMatchObject({
+      id: expect.any(String),
+      name: "Test User",
+      email: "test@example.com",
+    });
+
+    // Test post fragment
+    const post = await fragments.post.services.createPost({
+      title: "Test Post",
+      userId: user.id,
+    });
+
+    expect(post).toMatchObject({
+      id: expect.any(String),
+      title: "Test Post",
+      userId: user.id,
+    });
+
+    // Verify data exists
+    const users = await fragments.user.services.getUsers();
+    expect(users).toHaveLength(1);
+
+    const posts = await fragments.post.services.getPosts();
+    expect(posts).toHaveLength(1);
+    expect(posts[0]!.userId).toBe(user.id);
+
+    // Cleanup
+    await test.cleanup();
+  });
+
+  it("should reset database and recreate fragments", async () => {
+    const userFragmentDef = defineFragment<{}>("user-fragment")
+      .extend(withDatabase(userSchema))
+      .providesBaseService(({ deps }) => ({
+        createUser: async (data: { name: string; email: string }) => {
+          const id = await deps.db.create("users", data);
+          return { ...data, id: id.valueOf() };
+        },
+        getUsers: async () => {
+          const users = await deps.db.find("users", (b) =>
+            b.whereIndex("idx_users_all", (eb) => eb("id", "!=", "")),
+          );
+          return users.map((u) => ({ ...u, id: u.id.valueOf() }));
+        },
+      }))
+      .build();
+
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("user", instantiate(userFragmentDef).withConfig({}).withRoutes([]))
+      .build();
+
+    // Create a user
+    await fragments.user.services.createUser({
+      name: "User 1",
+      email: "user1@example.com",
+    });
+
+    // Verify user exists
+    let users = await fragments.user.services.getUsers();
+    expect(users).toHaveLength(1);
+
+    // Reset database
+    await test.resetDatabase();
+
+    // Verify database is empty
+    users = await fragments.user.services.getUsers();
+    expect(users).toHaveLength(0);
+
+    // Cleanup
+    await test.cleanup();
+  });
+
+  it("should expose db for direct queries", async () => {
+    const userFragmentDef = defineFragment<{}>("user-fragment")
+      .extend(withDatabase(userSchema))
+      .providesBaseService(() => ({}))
+      .build();
+
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("user", instantiate(userFragmentDef).withConfig({}).withRoutes([]))
+      .build();
+
+    // Use db directly
+    const userId = await fragments.user.db.create("users", {
+      name: "Direct DB User",
+      email: "direct@example.com",
+    });
+
+    expect(userId).toBeDefined();
+    expect(typeof userId.valueOf()).toBe("string");
+
+    // Find using db
+    const users = await fragments.user.db.find("users", (b) =>
+      b.whereIndex("idx_users_all", (eb) => eb("id", "=", userId)),
+    );
+
+    expect(users).toHaveLength(1);
+    expect(users[0]).toMatchObject({
+      id: userId,
+      name: "Direct DB User",
+      email: "direct@example.com",
+    });
+
+    await test.cleanup();
+  });
+
+  it("should expose deps and adapter", async () => {
+    const userFragmentDef = defineFragment<{}>("user-fragment")
+      .extend(withDatabase(userSchema))
+      .withDependencies(() => ({
+        testValue: "test-dependency",
+      }))
+      .providesBaseService(({ deps }) => ({
+        getTestValue: () => deps.testValue,
+      }))
+      .build();
+
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("user", instantiate(userFragmentDef).withConfig({}).withRoutes([]))
+      .build();
+
+    // Test that deps are accessible
+    expect(fragments.user.deps).toBeDefined();
+    expect(fragments.user.deps.testValue).toBe("test-dependency");
+    expect(fragments.user.deps.db).toBeDefined();
+    expect(fragments.user.deps.schema).toBeDefined();
+
+    // Test that adapter is accessible
+    expect(test.adapter).toBeDefined();
+    expect(test.adapter.createQueryEngine).toBeDefined();
+
+    await test.cleanup();
+  });
+
+  it("should support callRoute with database operations", async () => {
+    // This is a simpler test that verifies callRoute exists and can be called.
+    // For now, we just verify that the method exists and is callable.
+    const userFragmentDef = defineFragment<{}>("user-fragment")
+      .extend(withDatabase(userSchema))
+      .providesBaseService(() => ({}))
+      .build();
+
+    const createUserRoute = defineRoute({
+      method: "POST",
+      path: "/users",
+      inputSchema: z.object({
+        name: z.string(),
+        email: z.string(),
+      }),
+      outputSchema: z.object({
+        id: z.string(),
+        name: z.string(),
+        email: z.string(),
+      }),
+      handler: async ({ input }, { json }) => {
+        const body = await input.valid();
+        return json({ ...body, id: "123" });
+      },
+    });
+
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment(
+        "user",
+        instantiate(userFragmentDef).withConfig({}).withRoutes([createUserRoute]),
+      )
+      .build();
+
+    const response = await fragments.user.callRoute("POST", "/users", {
+      body: { name: "Test User", email: "test@example.com" },
+    });
+
+    assert(response.type === "json");
+    expect(response.data).toMatchObject({
+      id: "123",
+      name: "Test User",
+      email: "test@example.com",
+    });
+
+    await test.cleanup();
+  });
+
+  it("should use actual config during schema extraction", async () => {
+    // Test that the builder uses the actual config provided via .withConfig()
+    // This is important for fragments like Stripe that need API keys to initialize dependencies
+    interface RequiredConfigFragmentConfig {
+      apiKey: string;
+      apiSecret: string;
+    }
+
+    const requiredConfigFragmentDef = defineFragment<RequiredConfigFragmentConfig>(
+      "required-config-fragment",
+    )
+      .extend(withDatabase(userSchema))
+      .withDependencies(({ config }) => {
+        // This should receive the actual config, not an empty mock
+        return {
+          client: { key: config.apiKey, secret: config.apiSecret },
+          apiKey: config.apiKey,
+        };
+      })
+      .providesBaseService(({ deps }) => ({
+        getApiKey: () => deps.apiKey,
+        createUser: async (data: { name: string; email: string }) => {
+          const id = await deps.db.create("users", data);
+          return { ...data, id: id.valueOf() };
+        },
+      }))
+      .build();
+
+    const { fragments, test } = await buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment(
+        "requiredConfig",
+        instantiate(requiredConfigFragmentDef)
+          .withConfig({
+            apiKey: "test-key",
+            apiSecret: "test-secret",
+          })
+          .withRoutes([]),
+      )
+      .build();
+
+    // Verify the fragment was created with actual config
+    expect(fragments.requiredConfig.deps.apiKey).toBe("test-key");
+    expect(fragments.requiredConfig.deps.client).toEqual({
+      key: "test-key",
+      secret: "test-secret",
+    });
+
+    // Verify database operations work
+    const user = await fragments.requiredConfig.services.createUser({
+      name: "Config Test User",
+      email: "config@example.com",
+    });
+
+    expect(user).toMatchObject({
+      id: expect.any(String),
+      name: "Config Test User",
+      email: "config@example.com",
+    });
+
+    await test.cleanup();
+  });
+
+  it("should provide helpful error when config is missing", async () => {
+    // Test that we get a helpful error when required config is not provided
+    const badFragmentDef = defineFragment<{ apiKey: string }>("bad-fragment")
+      .extend(withDatabase(userSchema))
+      .withDependencies(({ config }) => {
+        // This will throw if apiKey is undefined
+        if (!config.apiKey) {
+          throw new Error("API key is required");
+        }
+        return {
+          apiKey: config.apiKey,
+        };
+      })
+      .providesBaseService(() => ({}))
+      .build();
+
+    // Intentionally omit the required config to test error handling
+    const buildPromise = buildDatabaseFragmentsTest()
+      .withTestAdapter({ type: "kysely-sqlite" })
+      .withFragment("bad", instantiate(badFragmentDef).withRoutes([]))
+      .build();
+
+    await expect(buildPromise).rejects.toThrow(/Failed to extract schema from fragment/);
+    await expect(buildPromise).rejects.toThrow(/API key is required/);
+  });
+});