@fragno-dev/db 0.1.14 → 0.1.15

package/src/schema/serialize.ts

@@ -337,8 +337,16 @@ export function deserialize(value: unknown, col: AnyColumn, provider: SQLProvide
 
 /**
  * Encode to driver value
+ *
+ * @param skipDriverConversions - Skip driver-level type conversions (Date->number, boolean->0/1, bigint->Buffer).
+ *                                 Set to true when using ORMs like Drizzle that handle these conversions internally.
  */
-export function serialize(value: unknown, col: AnyColumn, provider: SQLProvider) {
+export function serialize(
+  value: unknown,
+  col: AnyColumn,
+  provider: SQLProvider,
+  skipDriverConversions = false,
+) {
   if (value === null) {
     return null;
   }
@@ -373,18 +381,21 @@ export function serialize(value: unknown, col: AnyColumn, provider: SQLProvider)
     return JSON.stringify(value);
   }
 
-  if (provider === "sqlite" && value instanceof Date) {
-    return value.getTime();
-  }
+  // Skip driver-specific type conversions when using ORMs that handle them internally
+  if (!skipDriverConversions) {
+    if (provider === "sqlite" && value instanceof Date) {
+      return value.getTime();
+    }
 
-  if (provider === "sqlite" && typeof value === "boolean") {
-    return value ? 1 : 0;
-  }
+    if (provider === "sqlite" && typeof value === "boolean") {
+      return value ? 1 : 0;
+    }
 
-  if (provider === "sqlite" && typeof value === "bigint") {
-    const buf = Buffer.alloc(8);
-    buf.writeBigInt64BE(value);
-    return buf;
+    if (provider === "sqlite" && typeof value === "bigint") {
+      const buf = Buffer.alloc(8);
+      buf.writeBigInt64BE(value);
+      return buf;
+    }
   }
 
   // most drivers accept Buffer

package/src/with-database.ts

@@ -0,0 +1,140 @@
+import type { AnySchema } from "./schema/create";
+import type { RequestThisContext, FragnoPublicConfig } from "@fragno-dev/core";
+import { FragmentDefinitionBuilder, instantiate } from "@fragno-dev/core";
+import {
+  DatabaseFragmentDefinitionBuilder,
+  type DatabaseServiceContext,
+  type DatabaseHandlerContext,
+  type ImplicitDatabaseDependencies,
+  type FragnoPublicConfigWithDatabase,
+  type DatabaseRequestStorage,
+} from "./db-fragment-definition-builder";
+import { internalFragmentDef } from "./fragments/internal-fragment";
+
+/**
+ * Helper to add database support to a fragment builder.
+ * Automatically links the internal fragment and adds ImplicitDatabaseDependencies to the TDeps type.
+ *
+ * @example
+ * ```typescript
+ * // With .extend() - recommended
+ * const def = defineFragment("my-frag")
+ *   .extend(withDatabase(mySchema))
+ *   .withDependencies(...)
+ *   .build();
+ *
+ * // Or as a function wrapper
+ * const def = withDatabase(mySchema)(defineFragment("my-frag"))
+ *   .withDependencies(...)
+ *   .build();
+ * ```
+ */
+export function withDatabase<TSchema extends AnySchema>(
+  schema: TSchema,
+  namespace?: string,
+): <
+  TConfig,
+  TDeps,
+  TBaseServices,
+  TServices,
+  TServiceDeps,
+  TPrivateServices,
+  TServiceThisContext extends RequestThisContext,
+  THandlerThisContext extends RequestThisContext,
+  TRequestStorage,
+>(
+  builder: FragmentDefinitionBuilder<
+    TConfig,
+    FragnoPublicConfig,
+    TDeps,
+    TBaseServices,
+    TServices,
+    TServiceDeps,
+    TPrivateServices,
+    TServiceThisContext,
+    THandlerThisContext,
+    TRequestStorage
+  >,
+) => DatabaseFragmentDefinitionBuilder<
+  TSchema,
+  TConfig,
+  TDeps & ImplicitDatabaseDependencies<TSchema>,
+  TBaseServices,
+  TServices,
+  TServiceDeps,
+  TPrivateServices,
+  DatabaseServiceContext,
+  DatabaseHandlerContext
+> {
+  return <
+    TConfig,
+    TDeps,
+    TBaseServices,
+    TServices,
+    TServiceDeps,
+    TPrivateServices,
+    TServiceThisContext extends RequestThisContext,
+    THandlerThisContext extends RequestThisContext,
+    TRequestStorage,
+  >(
+    builder: FragmentDefinitionBuilder<
+      TConfig,
+      FragnoPublicConfig,
+      TDeps,
+      TBaseServices,
+      TServices,
+      TServiceDeps,
+      TPrivateServices,
+      TServiceThisContext,
+      THandlerThisContext,
+      TRequestStorage
+    >,
+  ) => {
+    // Link the internal fragment to all database fragments (except the internal fragment itself)
+    // No circular dependency: internal-fragment.ts uses DatabaseFragmentDefinitionBuilder directly
+    const isInternalFragment = builder.name === "$fragno-internal-fragment";
+    const builderWithInternal = isInternalFragment
+      ? builder
+      : builder.withLinkedFragment("_fragno_internal", ({ config, options }) => {
+          // Cast is safe: by the time this callback is invoked during fragment instantiation,
+          // the options will be FragnoPublicConfigWithDatabase (enforced by DatabaseFragmentDefinitionBuilder)
+          return instantiate(internalFragmentDef)
+            .withConfig(config as {})
+            .withOptions(options as FragnoPublicConfigWithDatabase)
+            .build();
+        });
+
+    // Cast is safe: we're creating a DatabaseFragmentDefinitionBuilder which internally uses
+    // FragnoPublicConfigWithDatabase, but the input builder uses FragnoPublicConfig.
+    // The database builder's build() method will enforce FragnoPublicConfigWithDatabase at the end.
+    // We also add ImplicitDatabaseDependencies to TDeps so they're available in service constructors.
+    // Note: We discard TRequestStorage here because database fragments manage their own storage (DatabaseRequestStorage).
+    // We set TServiceThisContext to DatabaseServiceContext (restricted) and THandlerThisContext to DatabaseHandlerContext (full).
+    return new DatabaseFragmentDefinitionBuilder<
+      TSchema,
+      TConfig,
+      TDeps & ImplicitDatabaseDependencies<TSchema>,
+      TBaseServices,
+      TServices,
+      TServiceDeps,
+      TPrivateServices,
+      DatabaseServiceContext,
+      DatabaseHandlerContext
+    >(
+      builderWithInternal as unknown as FragmentDefinitionBuilder<
+        TConfig,
+        FragnoPublicConfigWithDatabase,
+        TDeps & ImplicitDatabaseDependencies<TSchema>,
+        TBaseServices,
+        TServices,
+        TServiceDeps,
+        TPrivateServices,
+        DatabaseServiceContext,
+        DatabaseHandlerContext,
+        DatabaseRequestStorage
+      >,
+      schema,
+      namespace,
+    );
+  };
+}

package/tsdown.config.ts

@@ -13,6 +13,7 @@ export default defineConfig({
     "./src/query/unit-of-work.ts",
     "./src/query/cursor.ts",
     "./src/fragment.ts",
+    "./src/db-fragment-definition-builder.ts",
     "./src/migration-engine/generation-engine.ts",
   ],
   dts: true,

package/dist/bind-services.d.ts

@@ -1,7 +0,0 @@
-//#region src/bind-services.d.ts
-type OmitThisParameter<T> = T extends ((this: infer _This, ...args: infer A) => infer R) ? (...args: A) => R : T;
-type BoundServices<T> = { [K in keyof T]: T[K] extends ((...args: never[]) => unknown) ? OmitThisParameter<T[K]> : T[K] extends Record<string, unknown> ? BoundServices<T[K]> : T[K] };
-declare function bindServicesToContext<T extends Record<string, unknown>>(services: T): BoundServices<T>;
-//#endregion
-export { BoundServices, bindServicesToContext };
-//# sourceMappingURL=bind-services.d.ts.map

package/dist/bind-services.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bind-services.d.ts","names":[],"sources":["../src/bind-services.ts"],"sourcesContent":[],"mappings":";KAGK,uBAAuB,yEACd,MAAM,IAChB;AAFC,KAKO,aALU,CAAA,CAAA,CAAA,GAAA,QAAM,MAMd,CANc,GAMV,CANU,CAMR,CANQ,CAAA,UAAA,CAAA,GAAA,IAAA,EAAA,KAAA,EAAA,EAAA,GAAA,OAAA,IAOtB,iBAPsB,CAOJ,CAPI,CAOF,CAPE,CAAA,CAAA,GAQtB,CARsB,CAQpB,CARoB,CAAA,SAQT,MARS,CAAA,MAAA,EAAA,OAAA,CAAA,GASpB,aAToB,CASN,CATM,CASJ,CATI,CAAA,CAAA,GAUpB,CAVoB,CAUlB,CAVkB,CAAA,EACd;AAAM,iBAYJ,qBAZI,CAAA,UAY4B,MAZ5B,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA,CAAA,QAAA,EAaR,CAbQ,CAAA,EAcjB,aAdiB,CAcH,CAdG,CAAA"}

package/dist/bind-services.js

@@ -1,14 +0,0 @@
-import { serviceContext } from "./fragment.js";
-
-//#region src/bind-services.ts
-function bindServicesToContext(services) {
-	const bound = {};
-	for (const [key, value] of Object.entries(services)) if (typeof value === "function") bound[key] = value.bind(serviceContext);
-	else if (value && typeof value === "object" && !Array.isArray(value)) bound[key] = bindServicesToContext(value);
-	else bound[key] = value;
-	return bound;
-}
-
-//#endregion
-export { bindServicesToContext };
-//# sourceMappingURL=bind-services.js.map

package/dist/bind-services.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bind-services.js","names":[],"sources":["../src/bind-services.ts"],"sourcesContent":["import { serviceContext } from \"./fragment\";\n\n// Type helper to remove 'this' parameter from functions\ntype OmitThisParameter<T> = T extends (this: infer _This, ...args: infer A) => infer R\n  ? (...args: A) => R\n  : T;\n\n// Recursively remove 'this' parameter from all functions in an object\nexport type BoundServices<T> = {\n  [K in keyof T]: T[K] extends (...args: never[]) => unknown\n    ? OmitThisParameter<T[K]>\n    : T[K] extends Record<string, unknown>\n      ? BoundServices<T[K]>\n      : T[K];\n};\n\nexport function bindServicesToContext<T extends Record<string, unknown>>(\n  services: T,\n): BoundServices<T> {\n  const bound = {} as BoundServices<T>;\n\n  for (const [key, value] of Object.entries(services)) {\n    if (typeof value === \"function\") {\n      // Bind function to serviceContext\n      bound[key as keyof T] = value.bind(serviceContext) as BoundServices<T>[keyof T];\n    } else if (value && typeof value === \"object\" && !Array.isArray(value)) {\n      // Recursively bind nested service objects\n      bound[key as keyof T] = bindServicesToContext(\n        value as Record<string, unknown>,\n      ) as BoundServices<T>[keyof T];\n    } else {\n      bound[key as keyof T] = value as BoundServices<T>[keyof T];\n    }\n  }\n\n  return bound;\n}\n"],"mappings":";;;AAgBA,SAAgB,sBACd,UACkB;CAClB,MAAM,QAAQ,EAAE;AAEhB,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,SAAS,CACjD,KAAI,OAAO,UAAU,WAEnB,OAAM,OAAkB,MAAM,KAAK,eAAe;UACzC,SAAS,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,MAAM,CAEpE,OAAM,OAAkB,sBACtB,MACD;KAED,OAAM,OAAkB;AAI5B,QAAO"}

package/dist/fragment.d.ts

@@ -1,173 +0,0 @@
-import { AnySchema } from "./schema/create.js";
-import { IUnitOfWorkBase, UnitOfWorkSchemaView } from "./query/unit-of-work.js";
-import { AbstractQuery } from "./query/query.js";
-import { DatabaseAdapter } from "./adapters/adapters.js";
-import { BoundServices, bindServicesToContext } from "./bind-services.js";
-import { AsyncLocalStorage } from "async_hooks";
-import { RequestThisContext } from "@fragno-dev/core/api";
-import { FragmentDefinition, FragnoPublicConfig, RequestInputContext, RequestOutputContext } from "@fragno-dev/core";
-
-//#region src/fragment.d.ts
-declare const uowStorage: AsyncLocalStorage<IUnitOfWorkBase>;
-/**
- * Service context for database fragments, providing access to the Unit of Work.
- */
-interface DatabaseRequestThisContext extends RequestThisContext {
-  /**
-   * Get the Unit of Work from the current context.
-   * @param schema - Optional schema to get a typed view. If not provided, returns the base UOW.
-   * @returns IUnitOfWorkBase if no schema provided, or typed UnitOfWorkSchemaView if schema provided.
-   */
-  getUnitOfWork(): IUnitOfWorkBase;
-  getUnitOfWork<TSchema extends AnySchema>(schema: TSchema): UnitOfWorkSchemaView<TSchema, [], any>;
-}
-declare const serviceContext: DatabaseRequestThisContext;
-declare function withUnitOfWork<T>(uow: IUnitOfWorkBase, callback: () => T): Promise<T>;
-/**
- * Type helper that enforces DatabaseRequestThisContext on all functions in a service object
- */
-type WithDatabaseThis<T> = { [K in keyof T]: T[K] extends ((...args: infer A) => infer R) ? (this: DatabaseRequestThisContext, ...args: A) => R : T[K] extends Record<string, unknown> ? WithDatabaseThis<T[K]> : T[K] };
-/**
- * Route handler type for database fragments with access to Unit of Work.
- */
-type DatabaseRouteHandler = (this: DatabaseRequestThisContext, inputContext: RequestInputContext, outputContext: RequestOutputContext) => Promise<Response>;
-/**
- * Extended FragnoPublicConfig that includes a database adapter.
- * Use this type when creating fragments with database support.
- */
-type FragnoPublicConfigWithDatabase = FragnoPublicConfig & {
-  databaseAdapter: DatabaseAdapter<any>;
-};
-/**
- * Additional context provided to database fragments containing the database adapter and ORM instance.
- */
-type DatabaseFragmentContext<TSchema extends AnySchema> = {
-  databaseAdapter: DatabaseAdapter<any>;
-  orm: AbstractQuery<TSchema>;
-};
-declare class DatabaseFragmentBuilder<const TSchema extends AnySchema, const TConfig, const TDeps = {}, const TServices = {}, const TUsedServices = {}, const TProvidedServices = {}> {
-  #private;
-  readonly $types: {
-    schema: TSchema;
-    config: TConfig;
-    deps: TDeps;
-    services: TServices;
-    usedServices: TUsedServices;
-    providedServices: TProvidedServices;
-  };
-  constructor(options: {
-    name: string;
-    schema?: TSchema;
-    namespace?: string;
-    dependencies?: (context: {
-      config: TConfig;
-      fragnoConfig: FragnoPublicConfig;
-    } & DatabaseFragmentContext<TSchema>) => TDeps;
-    services?: (context: {
-      config: TConfig;
-      fragnoConfig: FragnoPublicConfig;
-      deps: TDeps & TUsedServices;
-      defineService: <T extends Record<string, unknown>>(services: WithDatabaseThis<T>) => WithDatabaseThis<T>;
-    } & DatabaseFragmentContext<TSchema>) => TServices;
-    usedServices?: Record<string, {
-      name: string;
-      required: boolean;
-    }>;
-    providedServices?: Record<string, unknown>;
-  });
-  get $requiredOptions(): FragnoPublicConfigWithDatabase;
-  get definition(): FragmentDefinition<TConfig, TDeps, BoundServices<TServices>, {
-    databaseSchema?: TSchema;
-    databaseNamespace: string;
-  }, BoundServices<TUsedServices>, BoundServices<TProvidedServices>, DatabaseRequestThisContext>;
-  withDatabase<TNewSchema extends AnySchema>(schema: TNewSchema, namespace?: string): DatabaseFragmentBuilder<TNewSchema, TConfig, TDeps, TServices, TUsedServices, TProvidedServices>;
-  withDependencies<TNewDeps>(fn: (context: {
-    config: TConfig;
-    fragnoConfig: FragnoPublicConfig;
-  } & DatabaseFragmentContext<TSchema>) => TNewDeps): DatabaseFragmentBuilder<TSchema, TConfig, TNewDeps, {}, TUsedServices, TProvidedServices>;
-  /**
-   * Declare that this fragment uses a service.
-   * @param serviceName - The name of the service to use
-   * @param options - Optional configuration: { optional: boolean } (defaults to required)
-   */
-  usesService<TServiceName extends string, TService>(serviceName: TServiceName, options?: {
-    optional?: false;
-  }): DatabaseFragmentBuilder<TSchema, TConfig, TDeps, TServices, TUsedServices & { [K in TServiceName]: TService }, TProvidedServices>;
-  usesService<TServiceName extends string, TService>(serviceName: TServiceName, options: {
-    optional: true;
-  }): DatabaseFragmentBuilder<TSchema, TConfig, TDeps, TServices, TUsedServices & { [K in TServiceName]: TService | undefined }, TProvidedServices>;
-  /**
-   * Define services for this fragment (unnamed).
-   * Functions in the service will have access to DatabaseRequestThisContext via `this` if using `defineService`.
-   *
-   * @example
-   * With `this` context:
-   * ```ts
-   * .providesService(({ defineService }) => defineService({
-   *   createUser: function(name: string) {
-   *     const uow = this.getUnitOfWork(mySchema);
-   *     return uow.create('user', { name });
-   *   }
-   * }))
-   * ```
-   *
-   * Without `this` context:
-   * ```ts
-   * .providesService(({ db }) => ({
-   *   createUser: async (name: string) => {
-   *     return db.create('user', { name });
-   *   }
-   * }))
-   * ```
-   */
-  providesService<TNewServices>(fn: (context: {
-    config: TConfig;
-    fragnoConfig: FragnoPublicConfig;
-    deps: TDeps & TUsedServices;
-    db: AbstractQuery<TSchema>;
-    defineService: <T extends Record<string, unknown>>(services: WithDatabaseThis<T>) => WithDatabaseThis<T>;
-  }) => TNewServices): DatabaseFragmentBuilder<TSchema, TConfig, TDeps, TNewServices, TUsedServices, TProvidedServices>;
-  /**
-   * Provide a named service that other fragments can use.
-   * Functions in the service will have access to DatabaseRequestThisContext via `this` if using `defineService`.
-   * You can also pass a service object directly instead of a callback.
-   *
-   * @example
-   * With callback and `this` context:
-   * ```ts
-   * .providesService("myService", ({ defineService }) => defineService({
-   *   createUser: function(name: string) {
-   *     const uow = this.getUnitOfWork(mySchema);
-   *     return uow.create('user', { name });
-   *   }
-   * }))
-   * ```
-   *
-   * With callback, no `this` context:
-   * ```ts
-   * .providesService("myService", ({ db }) => ({
-   *   createUser: async (name: string) => {
-   *     return db.create('user', { name });
-   *   }
-   * }))
-   * ```
-   *
-   * With direct object:
-   * ```ts
-   * .providesService("myService", {
-   *   createUser: async (name: string) => { ... }
-   * })
-   * ```
-   */
-  providesService<TServiceName extends string, TService>(serviceName: TServiceName, fnOrService: ((context: {
-    config: TConfig;
-    fragnoConfig: FragnoPublicConfig;
-    deps: TDeps & TUsedServices;
-    db: AbstractQuery<TSchema>;
-    defineService: <T extends Record<string, unknown>>(services: WithDatabaseThis<T>) => WithDatabaseThis<T>;
-  }) => TService) | TService): DatabaseFragmentBuilder<TSchema, TConfig, TDeps, TServices, TUsedServices, TProvidedServices & { [K in TServiceName]: BoundServices<TService> }>;
-}
-declare function defineFragmentWithDatabase<TConfig = {}>(name: string): DatabaseFragmentBuilder<never, TConfig, {}, {}, {}, {}>;
-//#endregion
-export { type BoundServices, DatabaseFragmentBuilder, DatabaseFragmentContext, DatabaseRequestThisContext, DatabaseRouteHandler, FragnoPublicConfigWithDatabase, bindServicesToContext, defineFragmentWithDatabase, serviceContext, uowStorage, withUnitOfWork };
-//# sourceMappingURL=fragment.d.ts.map

package/dist/fragment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fragment.d.ts","names":[],"sources":["../src/fragment.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/fragment.js

@@ -1,191 +0,0 @@
-import { bindServicesToContext } from "./bind-services.js";
-import { AsyncLocalStorage } from "async_hooks";
-
-//#region src/fragment.ts
-const uowStorage = new AsyncLocalStorage();
-const serviceContext = { getUnitOfWork(schema) {
-	const uow = uowStorage.getStore();
-	if (!uow) throw new Error("No UnitOfWork in context. Service must be called within a route handler.");
-	if (schema) return uow.forSchema(schema);
-	return uow;
-} };
-function withUnitOfWork(uow, callback) {
-	return Promise.resolve(uowStorage.run(uow, callback));
-}
-var DatabaseFragmentBuilder = class DatabaseFragmentBuilder {
-	$types;
-	#name;
-	#schema;
-	#namespace;
-	#dependencies;
-	#services;
-	#usedServices;
-	#providedServices;
-	constructor(options) {
-		this.#name = options.name;
-		this.#schema = options.schema;
-		this.#namespace = options.namespace;
-		this.#dependencies = options.dependencies;
-		this.#services = options.services;
-		this.#usedServices = options.usedServices;
-		this.#providedServices = options.providedServices;
-	}
-	get $requiredOptions() {
-		throw new Error("Type only method. Do not call.");
-	}
-	get definition() {
-		const schema = this.#schema;
-		const namespace = this.#namespace ?? "";
-		const name = this.#name;
-		const dependencies = this.#dependencies;
-		const services = this.#services;
-		const providedServices = this.#providedServices;
-		return {
-			name,
-			dependencies: (config, options) => {
-				const dbContext = this.#createDatabaseContext(options, schema, namespace, name);
-				return dependencies?.({
-					config,
-					fragnoConfig: options,
-					...dbContext
-				}) ?? {};
-			},
-			services: (config, options, deps) => {
-				const dbContext = this.#createDatabaseContext(options, schema, namespace, name);
-				const defineService = (services$1) => services$1;
-				return bindServicesToContext(services?.({
-					config,
-					fragnoConfig: options,
-					deps,
-					defineService,
-					...dbContext
-				}) ?? {});
-			},
-			additionalContext: {
-				databaseSchema: schema,
-				databaseNamespace: namespace
-			},
-			createHandlerWrapper: schema ? (options) => {
-				const { orm } = this.#createDatabaseContext(options, schema, namespace, name);
-				return (handler) => {
-					return async (inputContext, outputContext) => {
-						return withUnitOfWork(orm.createUnitOfWork(), async () => {
-							return handler.bind(serviceContext)(inputContext, outputContext);
-						});
-					};
-				};
-			} : void 0,
-			usedServices: this.#usedServices,
-			providedServices
-		};
-	}
-	#createDatabaseContext(options, schema, namespace, name) {
-		const databaseAdapter = options.databaseAdapter;
-		if (!databaseAdapter) throw new Error(`Fragment '${name}' requires a database adapter in options.databaseAdapter`);
-		if (!schema) throw new Error(`Fragment '${name}' requires a schema. Use withDatabase() to provide one.`);
-		return {
-			databaseAdapter,
-			orm: databaseAdapter.createQueryEngine(schema, namespace)
-		};
-	}
-	withDatabase(schema, namespace) {
-		return new DatabaseFragmentBuilder({
-			name: this.#name,
-			schema,
-			namespace: namespace ?? this.#name + "-db",
-			dependencies: this.#dependencies,
-			services: this.#services,
-			usedServices: this.#usedServices,
-			providedServices: this.#providedServices
-		});
-	}
-	withDependencies(fn) {
-		return new DatabaseFragmentBuilder({
-			name: this.#name,
-			schema: this.#schema,
-			namespace: this.#namespace,
-			dependencies: fn,
-			services: void 0,
-			usedServices: this.#usedServices,
-			providedServices: this.#providedServices
-		});
-	}
-	usesService(serviceName, options) {
-		const isOptional = options?.optional ?? false;
-		return new DatabaseFragmentBuilder({
-			name: this.#name,
-			schema: this.#schema,
-			namespace: this.#namespace,
-			dependencies: this.#dependencies,
-			services: this.#services,
-			usedServices: {
-				...this.#usedServices,
-				[serviceName]: {
-					name: serviceName,
-					required: !isOptional
-				}
-			},
-			providedServices: this.#providedServices
-		});
-	}
-	providesService(...args) {
-		if (args.length === 1) {
-			const [fn] = args;
-			const servicesCallback = (context) => {
-				const defineService = (services) => services;
-				return fn({
-					config: context.config,
-					fragnoConfig: context.fragnoConfig,
-					deps: context.deps,
-					db: context.orm,
-					defineService
-				});
-			};
-			return new DatabaseFragmentBuilder({
-				name: this.#name,
-				schema: this.#schema,
-				namespace: this.#namespace,
-				dependencies: this.#dependencies,
-				services: servicesCallback,
-				usedServices: this.#usedServices,
-				providedServices: this.#providedServices
-			});
-		} else {
-			const [serviceName, fnOrService] = args;
-			const createService = (config, options, deps) => {
-				const dbContext = this.#createDatabaseContext(options, this.#schema, this.#namespace ?? "", this.#name);
-				let implementation;
-				if (typeof fnOrService === "function") {
-					const defineService = (services) => services;
-					implementation = fnOrService({
-						config,
-						fragnoConfig: options,
-						deps,
-						db: dbContext.orm,
-						defineService
-					});
-				} else implementation = fnOrService;
-				return bindServicesToContext(implementation);
-			};
-			return new DatabaseFragmentBuilder({
-				name: this.#name,
-				schema: this.#schema,
-				namespace: this.#namespace,
-				dependencies: this.#dependencies,
-				services: this.#services,
-				usedServices: this.#usedServices,
-				providedServices: {
-					...this.#providedServices,
-					[serviceName]: createService
-				}
-			});
-		}
-	}
-};
-function defineFragmentWithDatabase(name) {
-	return new DatabaseFragmentBuilder({ name });
-}
-
-//#endregion
-export { DatabaseFragmentBuilder, bindServicesToContext, defineFragmentWithDatabase, serviceContext, uowStorage, withUnitOfWork };
-//# sourceMappingURL=fragment.js.map