@fragno-dev/db 0.1.14 → 0.2.0

package/dist/adapters/shared/uow-operation-compiler.js

@@ -0,0 +1,105 @@
+import "../../query/cursor.js";
+import { createTableNameMapper } from "./table-name-mapper.js";
+
+//#region src/adapters/shared/uow-operation-compiler.ts
+/**
+* Abstract base class for Unit of Work operation compilers
+*
+* This class provides a structure and utilities for implementing UOW compilers
+* for different ORM/query builders (Kysely, Drizzle, etc.).
+*
+* Subclasses must implement the abstract methods for each operation type,
+* and can use the provided utility methods for common tasks.
+*
+* @template TCompiledQuery - The type of compiled query for the target ORM
+*/
+var UOWOperationCompiler = class {
+	#driverConfig;
+	#mapperFactory;
+	constructor(driverConfig, mapperFactory) {
+		this.#driverConfig = driverConfig;
+		this.#mapperFactory = mapperFactory;
+	}
+	get driverConfig() {
+		return this.#driverConfig;
+	}
+	get mapperFactory() {
+		return this.#mapperFactory;
+	}
+	/**
+	* Get the mapper for a specific operation based on its namespace
+	*/
+	getMapperForOperation(namespace) {
+		return this.#mapperFactory ? this.#mapperFactory(namespace) : namespace ? createTableNameMapper(namespace) : void 0;
+	}
+	/**
+	* Get a table from a schema by name
+	* @throws Error if table is not found
+	*/
+	getTable(schema, tableName) {
+		const table = schema.tables[tableName];
+		if (!table) throw new Error(`Invalid table name ${tableName}.`);
+		return table;
+	}
+	/**
+	* Get the version to check for a given ID and checkVersion flag
+	* @returns The version to check or undefined if no check is required
+	* @throws Error if the ID is a string and checkVersion is true
+	*/
+	getVersionToCheck(id, checkVersion) {
+		if (!checkVersion) return;
+		if (typeof id === "string") throw new Error(`Cannot use checkVersion with a string ID. Version checking requires a FragnoId with version information.`);
+		return id.version;
+	}
+	/**
+	* Extract external ID from FragnoId or string
+	*/
+	getExternalId(id) {
+		return typeof id === "string" ? id : id.externalId;
+	}
+	/**
+	* Get the physical table name for an operation, applying namespace mapping if needed
+	*/
+	getPhysicalTableName(logicalName, namespace) {
+		const mapper = this.getMapperForOperation(namespace);
+		return mapper ? mapper.toPhysical(logicalName) : logicalName;
+	}
+};
+/**
+* Creates a UOWCompiler from a UOWOperationCompiler by dispatching operations
+* to the appropriate specific compilation methods based on operation type.
+*
+* @template TCompiledQuery - The type of compiled query for the target ORM
+* @param operationCompiler - The operation compiler to wrap
+* @returns A UOWCompiler instance that delegates to the operation compiler
+*/
+function createUOWCompilerFromOperationCompiler(operationCompiler) {
+	return {
+		compileRetrievalOperation(op) {
+			switch (op.type) {
+				case "count": return operationCompiler.compileCount(op);
+				case "find": return operationCompiler.compileFind(op);
+				default: {
+					const exhaustiveCheck = op;
+					throw new Error(`Unknown retrieval operation type: ${exhaustiveCheck.type}`);
+				}
+			}
+		},
+		compileMutationOperation(op) {
+			switch (op.type) {
+				case "create": return operationCompiler.compileCreate(op);
+				case "update": return operationCompiler.compileUpdate(op);
+				case "delete": return operationCompiler.compileDelete(op);
+				case "check": return operationCompiler.compileCheck(op);
+				default: {
+					const exhaustiveCheck = op;
+					throw new Error(`Unknown mutation operation type: ${exhaustiveCheck.type}`);
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+export { UOWOperationCompiler, createUOWCompilerFromOperationCompiler };
+//# sourceMappingURL=uow-operation-compiler.js.map

package/dist/adapters/shared/uow-operation-compiler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uow-operation-compiler.js","names":["#driverConfig","#mapperFactory","exhaustiveCheck: never"],"sources":["../../../src/adapters/shared/uow-operation-compiler.ts"],"sourcesContent":["import type { AnyColumn, AnySchema, AnyTable, FragnoId } from \"../../schema/create\";\nimport type { Condition } from \"../../query/condition-builder\";\nimport type {\n  CompiledMutation,\n  RetrievalOperation,\n  MutationOperation,\n  UOWCompiler,\n} from \"../../query/unit-of-work/unit-of-work\";\nimport { Cursor } from \"../../query/cursor\";\nimport type { DriverConfig } from \"../generic-sql/driver-config\";\nimport { createTableNameMapper, type TableNameMapper } from \"./table-name-mapper\";\n\n/**\n * Options for compiling a find operation with cursor pagination\n */\nexport interface FindCompilationOptions {\n  /** Index columns used for ordering */\n  indexColumns: AnyColumn[];\n  /** Order direction for the index */\n  orderDirection: \"asc\" | \"desc\";\n  /** User-provided where condition */\n  userWhere: Condition | boolean | undefined;\n  /** Cursor string or Cursor object for pagination (after) */\n  after?: string | Cursor;\n  /** Cursor string or Cursor object for pagination (before) */\n  before?: string | Cursor;\n  /** Page size for pagination */\n  pageSize?: number;\n  /** Whether this is a high-level cursor API call (affects limit calculation) */\n  withCursor?: boolean;\n  /** Driver config for cursor serialization */\n  driverConfig: DriverConfig;\n}\n\n/**\n * Result of cursor condition building\n */\nexport interface CursorConditionResult {\n  /** The combined where condition (user where + cursor condition) */\n  where: Condition | undefined;\n  /** The effective limit to use (may be pageSize + 1 for cursor detection) */\n  limit: number | undefined;\n}\n\n/**\n * Abstract base class for Unit of Work operation compilers\n *\n * This class provides a structure and utilities for implementing UOW compilers\n * for different ORM/query builders (Kysely, Drizzle, etc.).\n *\n * Subclasses must implement the abstract methods for each operation type,\n * and can use the provided utility methods for common tasks.\n *\n * @template TCompiledQuery - The type of compiled query for the target ORM\n */\nexport abstract class UOWOperationCompiler<TCompiledQuery> {\n  #driverConfig: DriverConfig;\n  #mapperFactory?: (namespace: string | undefined) => TableNameMapper | undefined;\n\n  constructor(\n    driverConfig: DriverConfig,\n    mapperFactory?: (namespace: string | undefined) => TableNameMapper | undefined,\n  ) {\n    this.#driverConfig = driverConfig;\n    this.#mapperFactory = mapperFactory;\n  }\n\n  protected get driverConfig(): DriverConfig {\n    return this.#driverConfig;\n  }\n\n  protected get mapperFactory():\n    | ((namespace: string | undefined) => TableNameMapper | undefined)\n    | undefined {\n    return this.#mapperFactory;\n  }\n\n  abstract compileCount(\n    op: RetrievalOperation<AnySchema> & { type: \"count\" },\n  ): TCompiledQuery | null;\n\n  abstract compileFind(op: RetrievalOperation<AnySchema> & { type: \"find\" }): TCompiledQuery | null;\n\n  /**\n   * Compile a create operation\n   */\n  abstract compileCreate(\n    op: MutationOperation<AnySchema> & { type: \"create\" },\n  ): CompiledMutation<TCompiledQuery> | null;\n\n  abstract compileUpdate(\n    op: MutationOperation<AnySchema> & { type: \"update\" },\n  ): CompiledMutation<TCompiledQuery> | null;\n\n  abstract compileDelete(\n    op: MutationOperation<AnySchema> & { type: \"delete\" },\n  ): CompiledMutation<TCompiledQuery> | null;\n\n  abstract compileCheck(\n    op: MutationOperation<AnySchema> & { type: \"check\" },\n  ): CompiledMutation<TCompiledQuery> | null;\n\n  // ==================== Utility Methods ====================\n\n  /**\n   * Get the mapper for a specific operation based on its namespace\n   */\n  protected getMapperForOperation(namespace: string | undefined): TableNameMapper | undefined {\n    return this.#mapperFactory\n      ? this.#mapperFactory(namespace)\n      : namespace\n        ? createTableNameMapper(namespace)\n        : undefined;\n  }\n\n  /**\n   * Get a table from a schema by name\n   * @throws Error if table is not found\n   */\n  protected getTable(schema: AnySchema, tableName: string): AnyTable {\n    const table = schema.tables[tableName];\n    if (!table) {\n      throw new Error(`Invalid table name ${tableName}.`);\n    }\n    return table;\n  }\n\n  /**\n   * Get the version to check for a given ID and checkVersion flag\n   * @returns The version to check or undefined if no check is required\n   * @throws Error if the ID is a string and checkVersion is true\n   */\n  protected getVersionToCheck(id: FragnoId | string, checkVersion: boolean): number | undefined {\n    if (!checkVersion) {\n      return undefined;\n    }\n\n    if (typeof id === \"string\") {\n      throw new Error(\n        `Cannot use checkVersion with a string ID. Version checking requires a FragnoId with version information.`,\n      );\n    }\n\n    return id.version;\n  }\n\n  /**\n   * Extract external ID from FragnoId or string\n   */\n  protected getExternalId(id: FragnoId | string): string {\n    return typeof id === \"string\" ? id : id.externalId;\n  }\n\n  /**\n   * Get the physical table name for an operation, applying namespace mapping if needed\n   */\n  protected getPhysicalTableName(logicalName: string, namespace: string | undefined): string {\n    const mapper = this.getMapperForOperation(namespace);\n    return mapper ? mapper.toPhysical(logicalName) : logicalName;\n  }\n}\n\n/**\n * Creates a UOWCompiler from a UOWOperationCompiler by dispatching operations\n * to the appropriate specific compilation methods based on operation type.\n *\n * @template TCompiledQuery - The type of compiled query for the target ORM\n * @param operationCompiler - The operation compiler to wrap\n * @returns A UOWCompiler instance that delegates to the operation compiler\n */\nexport function createUOWCompilerFromOperationCompiler<TCompiledQuery>(\n  operationCompiler: UOWOperationCompiler<TCompiledQuery>,\n): UOWCompiler<TCompiledQuery> {\n  return {\n    compileRetrievalOperation(op: RetrievalOperation<AnySchema>): TCompiledQuery | null {\n      switch (op.type) {\n        case \"count\":\n          return operationCompiler.compileCount(op);\n        case \"find\":\n          return operationCompiler.compileFind(op);\n        default: {\n          const exhaustiveCheck: never = op;\n          throw new Error(\n            `Unknown retrieval operation type: ${(exhaustiveCheck as RetrievalOperation<AnySchema>).type}`,\n          );\n        }\n      }\n    },\n\n    compileMutationOperation(\n      op: MutationOperation<AnySchema>,\n    ): CompiledMutation<TCompiledQuery> | null {\n      switch (op.type) {\n        case \"create\":\n          return operationCompiler.compileCreate(op);\n        case \"update\":\n          return operationCompiler.compileUpdate(op);\n        case \"delete\":\n          return operationCompiler.compileDelete(op);\n        case \"check\":\n          return operationCompiler.compileCheck(op);\n        default: {\n          const exhaustiveCheck: never = op;\n          throw new Error(\n            `Unknown mutation operation type: ${(exhaustiveCheck as MutationOperation<AnySchema>).type}`,\n          );\n        }\n      }\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAuDA,IAAsB,uBAAtB,MAA2D;CACzD;CACA;CAEA,YACE,cACA,eACA;AACA,QAAKA,eAAgB;AACrB,QAAKC,gBAAiB;;CAGxB,IAAc,eAA6B;AACzC,SAAO,MAAKD;;CAGd,IAAc,gBAEA;AACZ,SAAO,MAAKC;;;;;CAiCd,AAAU,sBAAsB,WAA4D;AAC1F,SAAO,MAAKA,gBACR,MAAKA,cAAe,UAAU,GAC9B,YACE,sBAAsB,UAAU,GAChC;;;;;;CAOR,AAAU,SAAS,QAAmB,WAA6B;EACjE,MAAM,QAAQ,OAAO,OAAO;AAC5B,MAAI,CAAC,MACH,OAAM,IAAI,MAAM,sBAAsB,UAAU,GAAG;AAErD,SAAO;;;;;;;CAQT,AAAU,kBAAkB,IAAuB,cAA2C;AAC5F,MAAI,CAAC,aACH;AAGF,MAAI,OAAO,OAAO,SAChB,OAAM,IAAI,MACR,2GACD;AAGH,SAAO,GAAG;;;;;CAMZ,AAAU,cAAc,IAA+B;AACrD,SAAO,OAAO,OAAO,WAAW,KAAK,GAAG;;;;;CAM1C,AAAU,qBAAqB,aAAqB,WAAuC;EACzF,MAAM,SAAS,KAAK,sBAAsB,UAAU;AACpD,SAAO,SAAS,OAAO,WAAW,YAAY,GAAG;;;;;;;;;;;AAYrD,SAAgB,uCACd,mBAC6B;AAC7B,QAAO;EACL,0BAA0B,IAA0D;AAClF,WAAQ,GAAG,MAAX;IACE,KAAK,QACH,QAAO,kBAAkB,aAAa,GAAG;IAC3C,KAAK,OACH,QAAO,kBAAkB,YAAY,GAAG;IAC1C,SAAS;KACP,MAAMC,kBAAyB;AAC/B,WAAM,IAAI,MACR,qCAAsC,gBAAkD,OACzF;;;;EAKP,yBACE,IACyC;AACzC,WAAQ,GAAG,MAAX;IACE,KAAK,SACH,QAAO,kBAAkB,cAAc,GAAG;IAC5C,KAAK,SACH,QAAO,kBAAkB,cAAc,GAAG;IAC5C,KAAK,SACH,QAAO,kBAAkB,cAAc,GAAG;IAC5C,KAAK,QACH,QAAO,kBAAkB,aAAa,GAAG;IAC3C,SAAS;KACP,MAAMA,kBAAyB;AAC/B,WAAM,IAAI,MACR,oCAAqC,gBAAiD,OACvF;;;;EAIR"}

package/dist/db-fragment-definition-builder.d.ts

@@ -0,0 +1,186 @@
+import { AnySchema } from "./schema/create.js";
+import { AwaitedPromisesInObject, ExecuteRestrictedUnitOfWorkOptions } from "./query/unit-of-work/execute-unit-of-work.js";
+import { HookContext, HookFn, HooksMap } from "./hooks/hooks.js";
+import { IUnitOfWork, TypedUnitOfWork } from "./query/unit-of-work/unit-of-work.js";
+import { SimpleQueryInterface } from "./query/simple-query-interface.js";
+import { DatabaseAdapter } from "./adapters/adapters.js";
+import { AnyFragnoInstantiatedFragment, FragmentDefinition, FragmentDefinitionBuilder, FragnoPublicConfig, RequestThisContext, ServiceConstructorFn } from "@fragno-dev/core";
+
+//#region src/db-fragment-definition-builder.d.ts
+
+/**
+ * Extended FragnoPublicConfig that includes a database adapter.
+ * Use this type when creating fragments with database support.
+ */
+type FragnoPublicConfigWithDatabase = FragnoPublicConfig & {
+  databaseAdapter: DatabaseAdapter<any>;
+};
+/**
+ * Implicit dependencies that database fragments get automatically.
+ * These are injected without requiring explicit configuration.
+ */
+type ImplicitDatabaseDependencies<TSchema extends AnySchema> = {
+  /**
+   * Database query engine for the fragment's schema.
+   */
+  db: SimpleQueryInterface<TSchema>;
+  /**
+   * The schema definition for this fragment.
+   */
+  schema: TSchema;
+  /**
+   * The database namespace for this fragment.
+   */
+  namespace: string;
+  /**
+   * Create a new Unit of Work for database operations.
+   */
+  createUnitOfWork: () => IUnitOfWork;
+};
+/**
+ * Service context for database fragments - provides restricted UOW access without execute methods.
+ */
+type DatabaseServiceContext<THooks extends HooksMap> = RequestThisContext & {
+  /**
+   * Get a typed, restricted Unit of Work for the given schema.
+   * @param schema - Schema to get a typed view for
+   * @returns TypedUnitOfWork (restricted version without execute methods)
+   */
+  uow<TSchema extends AnySchema>(schema: TSchema): TypedUnitOfWork<TSchema, [], unknown, THooks>;
+};
+/**
+ * Handler context for database fragments - provides UOW execution with automatic retry support.
+ */
+type DatabaseHandlerContext<THooks extends HooksMap = {}> = RequestThisContext & {
+  /**
+   * Execute a Unit of Work with explicit phase control and automatic retry support.
+   * This method provides an API where users call forSchema to create a schema-specific
+   * UOW, then call executeRetrieve() and executeMutate() to execute the phases. The entire
+   * callback is re-executed on optimistic concurrency conflicts, ensuring retries work properly.
+   * Automatically provides the UOW factory from context.
+   * Promises in the returned object are awaited 1 level deep.
+   *
+   * @param callback - Async function that receives a context with forSchema, executeRetrieve, executeMutate, nonce, and currentAttempt
+   * @param options - Optional configuration for retry policy and abort signal
+   * @returns Promise resolving to the callback's return value with promises awaited 1 level deep
+   * @throws Error if retries are exhausted or callback throws an error
+   *
+   * @example
+   * ```ts
+   * const result = await this.uow(async ({ forSchema, executeRetrieve, executeMutate, nonce, currentAttempt }) => {
+   *   const uow = forSchema(schema);
+   *   const userId = uow.create("users", { name: "John" });
+   *
+   *   // Execute retrieval phase
+   *   await executeRetrieve();
+   *
+   *   const profileId = uow.create("profiles", { userId });
+   *
+   *   // Execute mutation phase
+   *   await executeMutate();
+   *
+   *   return { userId, profileId };
+   * });
+   * ```
+   */
+  uow<TResult>(callback: (context: {
+    forSchema: <TSchema extends AnySchema, H extends HooksMap = THooks>(schema: TSchema, hooks?: H) => TypedUnitOfWork<TSchema, [], unknown, H>;
+    executeRetrieve: () => Promise<void>;
+    executeMutate: () => Promise<void>;
+    nonce: string;
+    currentAttempt: number;
+  }) => Promise<TResult> | TResult, options?: Omit<ExecuteRestrictedUnitOfWorkOptions, "createUnitOfWork">): Promise<AwaitedPromisesInObject<TResult>>;
+};
+/**
+ * Database fragment context provided to user callbacks.
+ */
+type DatabaseFragmentContext<TSchema extends AnySchema> = {
+  /**
+   * Database adapter instance.
+   */
+  databaseAdapter: DatabaseAdapter<any>;
+  /**
+   * ORM query engine for the fragment's schema.
+   */
+  db: SimpleQueryInterface<TSchema>;
+};
+/**
+ * Storage type for database fragments - stores the Unit of Work.
+ */
+type DatabaseRequestStorage = {
+  uow: IUnitOfWork;
+};
+/**
+ * Builder for database fragments that wraps the core fragment builder
+ * and provides database-specific functionality.
+ *
+ * Database fragments always require FragnoPublicConfigWithDatabase (which includes databaseAdapter).
+ */
+declare class DatabaseFragmentDefinitionBuilder<TSchema extends AnySchema, TConfig, TDeps, TBaseServices, TServices, TServiceDependencies, TPrivateServices, THooks extends HooksMap = {}, TServiceThisContext extends RequestThisContext = DatabaseHandlerContext, THandlerThisContext extends RequestThisContext = DatabaseHandlerContext, TLinkedFragments extends Record<string, AnyFragnoInstantiatedFragment> = {}> {
+  #private;
+  constructor(baseBuilder: FragmentDefinitionBuilder<TConfig, FragnoPublicConfigWithDatabase, TDeps, TBaseServices, TServices, TServiceDependencies, TPrivateServices, TServiceThisContext, THandlerThisContext, DatabaseRequestStorage, TLinkedFragments>, schema: TSchema, namespace?: string, hooksFactory?: (context: {
+    config: TConfig;
+    options: FragnoPublicConfigWithDatabase;
+  }) => THooks);
+  /**
+   * Define dependencies for this database fragment.
+   * The context includes database adapter and ORM instance.
+   */
+  withDependencies<TNewDeps>(fn: (context: {
+    config: TConfig;
+    options: FragnoPublicConfigWithDatabase;
+    db: SimpleQueryInterface<TSchema>;
+    databaseAdapter: DatabaseAdapter<any>;
+  }) => TNewDeps): DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TNewDeps & ImplicitDatabaseDependencies<TSchema>, {}, {}, TServiceDependencies, {}, THooks, TServiceThisContext, THandlerThisContext, TLinkedFragments>;
+  providesBaseService<TNewService>(fn: ServiceConstructorFn<TConfig, FragnoPublicConfigWithDatabase, TDeps, TServiceDependencies, TPrivateServices, TNewService, TServiceThisContext>): DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TDeps, TNewService, TServices, TServiceDependencies, TPrivateServices, THooks, TServiceThisContext, THandlerThisContext, TLinkedFragments>;
+  providesService<TServiceName extends string, TService>(serviceName: TServiceName, fn: ServiceConstructorFn<TConfig, FragnoPublicConfigWithDatabase, TDeps, TServiceDependencies, TPrivateServices, TService, TServiceThisContext>): DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TDeps, TBaseServices, TServices & { [K in TServiceName]: TService }, TServiceDependencies, TPrivateServices, THooks, TServiceThisContext, THandlerThisContext, TLinkedFragments>;
+  /**
+   * Provide a private service that is only accessible to the fragment author.
+   * Private services are NOT exposed on the fragment instance, but can be used
+   * when defining other services (baseServices, namedServices, and other privateServices).
+   * Private services are instantiated in order, so earlier private services are available
+   * to later ones.
+   */
+  providesPrivateService<TServiceName extends string, TService>(serviceName: TServiceName, fn: ServiceConstructorFn<TConfig, FragnoPublicConfigWithDatabase, TDeps, TServiceDependencies, TPrivateServices, TService, TServiceThisContext>): DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TDeps, TBaseServices, TServices, TServiceDependencies, TPrivateServices & { [K in TServiceName]: TService }, THooks, TServiceThisContext, THandlerThisContext, TLinkedFragments>;
+  /**
+   * Define durable hooks for this fragment.
+   * Hooks are automatically persisted and retried on failure.
+   *
+   * @param fn - Function that receives defineHook helper and returns a hooks map
+   * @returns Builder with hooks type set
+   *
+   * @example
+   * ```ts
+   * .provideHooks(({ defineHook, config }) => ({
+   *   onSubscribe: defineHook(async function (payload: { email: string }) {
+   *     // 'this' context available (HookServiceContext with nonce)
+   *     await config.onSubscribe?.(payload.email);
+   *   }),
+   * }))
+   * ```
+   */
+  provideHooks<TNewHooks extends HooksMap>(fn: (context: {
+    config: TConfig;
+    options: FragnoPublicConfigWithDatabase;
+    defineHook: <TPayload>(hook: (this: HookContext, payload: TPayload) => void | Promise<void>) => HookFn<TPayload>;
+  }) => TNewHooks): DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TDeps, TBaseServices, TServices, TServiceDependencies, TPrivateServices, TNewHooks, DatabaseServiceContext<TNewHooks>, THandlerThisContext, TLinkedFragments>;
+  /**
+   * Declare that this fragment uses a required service provided by the runtime.
+   * Delegates to the base builder.
+   */
+  usesService<TServiceName extends string, TService>(serviceName: TServiceName): DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TDeps, TBaseServices, TServices, TServiceDependencies & { [K in TServiceName]: TService }, TPrivateServices, THooks, TServiceThisContext, THandlerThisContext, TLinkedFragments>;
+  /**
+   * Declare that this fragment uses an optional service provided by the runtime.
+   * Delegates to the base builder.
+   */
+  usesOptionalService<TServiceName extends string, TService>(serviceName: TServiceName): DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TDeps, TBaseServices, TServices, TServiceDependencies & { [K in TServiceName]: TService | undefined }, TPrivateServices, THooks, TServiceThisContext, THandlerThisContext, TLinkedFragments>;
+  /**
+   * Build the final database fragment definition.
+   * This includes the request context setup for UnitOfWork management.
+   * Note: TDeps already includes ImplicitDatabaseDependencies from withDatabase().
+   */
+  build(): FragmentDefinition<TConfig, FragnoPublicConfigWithDatabase, TDeps, TBaseServices, TServices, TServiceDependencies, TPrivateServices, DatabaseServiceContext<THooks>, DatabaseHandlerContext<THooks>, DatabaseRequestStorage, TLinkedFragments>;
+}
+//#endregion
+export { DatabaseFragmentContext, DatabaseFragmentDefinitionBuilder, DatabaseHandlerContext, DatabaseRequestStorage, DatabaseServiceContext, FragnoPublicConfigWithDatabase, ImplicitDatabaseDependencies };
+//# sourceMappingURL=db-fragment-definition-builder.d.ts.map

package/dist/db-fragment-definition-builder.d.ts.map

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

package/dist/db-fragment-definition-builder.js

@@ -0,0 +1,207 @@
+import "./query/unit-of-work/unit-of-work.js";
+import { executeRestrictedUnitOfWork } from "./query/unit-of-work/execute-unit-of-work.js";
+import { prepareHookMutations, processHooks } from "./hooks/hooks.js";
+
+//#region src/db-fragment-definition-builder.ts
+/**
+* Create database context from options.
+* This extracts the database adapter and creates the ORM instance.
+*/
+function createDatabaseContext(options, schema, namespace) {
+	const databaseAdapter = options.databaseAdapter;
+	if (!databaseAdapter) throw new Error("Database fragment requires a database adapter to be provided in options.databaseAdapter");
+	return {
+		databaseAdapter,
+		db: databaseAdapter.createQueryEngine(schema, namespace)
+	};
+}
+/**
+* Builder for database fragments that wraps the core fragment builder
+* and provides database-specific functionality.
+*
+* Database fragments always require FragnoPublicConfigWithDatabase (which includes databaseAdapter).
+*/
+var DatabaseFragmentDefinitionBuilder = class DatabaseFragmentDefinitionBuilder {
+	#baseBuilder;
+	#schema;
+	#namespace;
+	#hooksFactory;
+	constructor(baseBuilder, schema, namespace, hooksFactory) {
+		this.#baseBuilder = baseBuilder;
+		this.#schema = schema;
+		this.#namespace = namespace ?? baseBuilder.name;
+		this.#hooksFactory = hooksFactory;
+	}
+	/**
+	* Define dependencies for this database fragment.
+	* The context includes database adapter and ORM instance.
+	*/
+	withDependencies(fn) {
+		const wrappedFn = (context) => {
+			const dbContext = createDatabaseContext(context.options, this.#schema, this.#namespace);
+			const userDeps = fn({
+				config: context.config,
+				options: context.options,
+				db: dbContext.db,
+				databaseAdapter: dbContext.databaseAdapter
+			});
+			const createUow = () => dbContext.db.createUnitOfWork();
+			const implicitDeps = {
+				db: dbContext.db,
+				schema: this.#schema,
+				namespace: this.#namespace,
+				createUnitOfWork: createUow
+			};
+			return {
+				...userDeps,
+				...implicitDeps
+			};
+		};
+		return new DatabaseFragmentDefinitionBuilder(this.#baseBuilder.withDependencies(wrappedFn), this.#schema, this.#namespace, this.#hooksFactory);
+	}
+	providesBaseService(fn) {
+		return new DatabaseFragmentDefinitionBuilder(this.#baseBuilder.providesBaseService(fn), this.#schema, this.#namespace, this.#hooksFactory);
+	}
+	providesService(serviceName, fn) {
+		return new DatabaseFragmentDefinitionBuilder(this.#baseBuilder.providesService(serviceName, fn), this.#schema, this.#namespace, this.#hooksFactory);
+	}
+	/**
+	* Provide a private service that is only accessible to the fragment author.
+	* Private services are NOT exposed on the fragment instance, but can be used
+	* when defining other services (baseServices, namedServices, and other privateServices).
+	* Private services are instantiated in order, so earlier private services are available
+	* to later ones.
+	*/
+	providesPrivateService(serviceName, fn) {
+		return new DatabaseFragmentDefinitionBuilder(this.#baseBuilder.providesPrivateService(serviceName, fn), this.#schema, this.#namespace, this.#hooksFactory);
+	}
+	/**
+	* Define durable hooks for this fragment.
+	* Hooks are automatically persisted and retried on failure.
+	*
+	* @param fn - Function that receives defineHook helper and returns a hooks map
+	* @returns Builder with hooks type set
+	*
+	* @example
+	* ```ts
+	* .provideHooks(({ defineHook, config }) => ({
+	*   onSubscribe: defineHook(async function (payload: { email: string }) {
+	*     // 'this' context available (HookServiceContext with nonce)
+	*     await config.onSubscribe?.(payload.email);
+	*   }),
+	* }))
+	* ```
+	*/
+	provideHooks(fn) {
+		const defineHook = (hook) => {
+			return hook;
+		};
+		const hooksFactory = (context) => {
+			return fn({
+				config: context.config,
+				options: context.options,
+				defineHook
+			});
+		};
+		const newBuilder = new DatabaseFragmentDefinitionBuilder(this.#baseBuilder, this.#schema, this.#namespace);
+		newBuilder.#hooksFactory = hooksFactory;
+		return newBuilder;
+	}
+	/**
+	* Declare that this fragment uses a required service provided by the runtime.
+	* Delegates to the base builder.
+	*/
+	usesService(serviceName) {
+		return new DatabaseFragmentDefinitionBuilder(this.#baseBuilder.usesService(serviceName), this.#schema, this.#namespace, this.#hooksFactory);
+	}
+	/**
+	* Declare that this fragment uses an optional service provided by the runtime.
+	* Delegates to the base builder.
+	*/
+	usesOptionalService(serviceName) {
+		return new DatabaseFragmentDefinitionBuilder(this.#baseBuilder.usesOptionalService(serviceName), this.#schema, this.#namespace, this.#hooksFactory);
+	}
+	/**
+	* Build the final database fragment definition.
+	* This includes the request context setup for UnitOfWork management.
+	* Note: TDeps already includes ImplicitDatabaseDependencies from withDatabase().
+	*/
+	build() {
+		const baseDef = this.#baseBuilder.build();
+		const dependencies = (context) => {
+			let userDeps;
+			try {
+				userDeps = baseDef.dependencies?.(context);
+			} catch (error) {
+				if (process.env["FRAGNO_INIT_DRY_RUN"] === "true") {
+					console.warn("Warning: Failed to initialize user dependencies in dry run mode:", error instanceof Error ? error.message : String(error));
+					userDeps = {};
+				} else throw error;
+			}
+			const { db } = createDatabaseContext(context.options, this.#schema, this.#namespace);
+			const implicitDeps = {
+				db,
+				schema: this.#schema,
+				namespace: this.#namespace,
+				createUnitOfWork: () => db.createUnitOfWork()
+			};
+			return {
+				...userDeps,
+				...implicitDeps
+			};
+		};
+		const builderWithStorage = this.#baseBuilder.withExternalRequestStorage(({ options }) => {
+			return createDatabaseContext(options, this.#schema, this.#namespace).databaseAdapter.contextStorage;
+		}).withRequestStorage(({ options }) => {
+			return { uow: createDatabaseContext(options, this.#schema, this.#namespace).db.createUnitOfWork() };
+		});
+		const internalFragmentFactory = baseDef.linkedFragments?.["_fragno_internal"];
+		return {
+			...builderWithStorage.withThisContext(({ storage, config, options }) => {
+				const hooksConfig = this.#hooksFactory ? {
+					hooks: this.#hooksFactory({
+						config,
+						options
+					}),
+					namespace: this.#namespace,
+					internalFragment: internalFragmentFactory({
+						config,
+						options
+					})
+				} : void 0;
+				function forSchema(schema) {
+					const uow$1 = storage.getStore()?.uow;
+					if (!uow$1) throw new Error("No UnitOfWork in context. Service must be called within a route handler OR using `withUnitOfWork`.");
+					return uow$1.restrict().forSchema(schema);
+				}
+				const serviceContext = { uow: forSchema };
+				async function uow(callback, execOptions) {
+					const currentStorage = storage.getStore();
+					if (!currentStorage) throw new Error("No storage in context. Handler must be called within a request context.");
+					const wrappedCallback = async (context) => {
+						return callback(context);
+					};
+					return executeRestrictedUnitOfWork(wrappedCallback, {
+						...execOptions,
+						createUnitOfWork: () => {
+							currentStorage.uow.reset();
+							if (hooksConfig) currentStorage.uow.registerSchema(hooksConfig.internalFragment.$internal.deps.schema, hooksConfig.internalFragment.$internal.deps.namespace);
+							return currentStorage.uow;
+						},
+						onBeforeMutate: hooksConfig ? (uow$1) => prepareHookMutations(uow$1, hooksConfig) : void 0,
+						onSuccess: hooksConfig ? () => processHooks(hooksConfig) : void 0
+					});
+				}
+				return {
+					serviceContext,
+					handlerContext: { uow }
+				};
+			}).build(),
+			dependencies
+		};
+	}
+};
+
+//#endregion
+export { DatabaseFragmentDefinitionBuilder };
+//# sourceMappingURL=db-fragment-definition-builder.js.map

package/dist/db-fragment-definition-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-fragment-definition-builder.js","names":["#baseBuilder","#schema","#namespace","#hooksFactory","implicitDeps: ImplicitDatabaseDependencies<TSchema>","uow","serviceContext: DatabaseServiceContext<THooks>"],"sources":["../src/db-fragment-definition-builder.ts"],"sourcesContent":["import type { AnySchema } from \"./schema/create\";\nimport type { SimpleQueryInterface } from \"./query/simple-query-interface\";\nimport type { DatabaseAdapter } from \"./adapters/adapters\";\nimport type { IUnitOfWork } from \"./query/unit-of-work/unit-of-work\";\nimport { TypedUnitOfWork, UnitOfWork } from \"./query/unit-of-work/unit-of-work\";\nimport type {\n  RequestThisContext,\n  FragnoPublicConfig,\n  AnyFragnoInstantiatedFragment,\n} from \"@fragno-dev/core\";\nimport {\n  FragmentDefinitionBuilder,\n  type FragmentDefinition,\n  type ServiceConstructorFn,\n} from \"@fragno-dev/core\";\nimport {\n  executeRestrictedUnitOfWork,\n  type AwaitedPromisesInObject,\n  type ExecuteRestrictedUnitOfWorkOptions,\n} from \"./query/unit-of-work/execute-unit-of-work\";\nimport {\n  prepareHookMutations,\n  processHooks,\n  type HooksMap,\n  type HookFn,\n  type HookContext,\n} from \"./hooks/hooks\";\nimport type { InternalFragmentInstance } from \"./fragments/internal-fragment\";\n\n/**\n * Extended FragnoPublicConfig that includes a database adapter.\n * Use this type when creating fragments with database support.\n */\nexport type FragnoPublicConfigWithDatabase = FragnoPublicConfig & {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  databaseAdapter: DatabaseAdapter<any>;\n};\n\n/**\n * Implicit dependencies that database fragments get automatically.\n * These are injected without requiring explicit configuration.\n */\nexport type ImplicitDatabaseDependencies<TSchema extends AnySchema> = {\n  /**\n   * Database query engine for the fragment's schema.\n   */\n  db: SimpleQueryInterface<TSchema>;\n  /**\n   * The schema definition for this fragment.\n   */\n  schema: TSchema;\n  /**\n   * The database namespace for this fragment.\n   */\n  namespace: string;\n  /**\n   * Create a new Unit of Work for database operations.\n   */\n  createUnitOfWork: () => IUnitOfWork;\n};\n\n/**\n * Service context for database fragments - provides restricted UOW access without execute methods.\n */\nexport type DatabaseServiceContext<THooks extends HooksMap> = RequestThisContext & {\n  /**\n   * Get a typed, restricted Unit of Work for the given schema.\n   * @param schema - Schema to get a typed view for\n   * @returns TypedUnitOfWork (restricted version without execute methods)\n   */\n  uow<TSchema extends AnySchema>(schema: TSchema): TypedUnitOfWork<TSchema, [], unknown, THooks>;\n};\n\n/**\n * Handler context for database fragments - provides UOW execution with automatic retry support.\n */\nexport type DatabaseHandlerContext<THooks extends HooksMap = {}> = RequestThisContext & {\n  /**\n   * Execute a Unit of Work with explicit phase control and automatic retry support.\n   * This method provides an API where users call forSchema to create a schema-specific\n   * UOW, then call executeRetrieve() and executeMutate() to execute the phases. The entire\n   * callback is re-executed on optimistic concurrency conflicts, ensuring retries work properly.\n   * Automatically provides the UOW factory from context.\n   * Promises in the returned object are awaited 1 level deep.\n   *\n   * @param callback - Async function that receives a context with forSchema, executeRetrieve, executeMutate, nonce, and currentAttempt\n   * @param options - Optional configuration for retry policy and abort signal\n   * @returns Promise resolving to the callback's return value with promises awaited 1 level deep\n   * @throws Error if retries are exhausted or callback throws an error\n   *\n   * @example\n   * ```ts\n   * const result = await this.uow(async ({ forSchema, executeRetrieve, executeMutate, nonce, currentAttempt }) => {\n   *   const uow = forSchema(schema);\n   *   const userId = uow.create(\"users\", { name: \"John\" });\n   *\n   *   // Execute retrieval phase\n   *   await executeRetrieve();\n   *\n   *   const profileId = uow.create(\"profiles\", { userId });\n   *\n   *   // Execute mutation phase\n   *   await executeMutate();\n   *\n   *   return { userId, profileId };\n   * });\n   * ```\n   */\n  uow<TResult>(\n    callback: (context: {\n      forSchema: <TSchema extends AnySchema, H extends HooksMap = THooks>(\n        schema: TSchema,\n        hooks?: H,\n      ) => TypedUnitOfWork<TSchema, [], unknown, H>;\n      executeRetrieve: () => Promise<void>;\n      executeMutate: () => Promise<void>;\n      nonce: string;\n      currentAttempt: number;\n    }) => Promise<TResult> | TResult,\n    options?: Omit<ExecuteRestrictedUnitOfWorkOptions, \"createUnitOfWork\">,\n  ): Promise<AwaitedPromisesInObject<TResult>>;\n};\n\n/**\n * Database fragment context provided to user callbacks.\n */\nexport type DatabaseFragmentContext<TSchema extends AnySchema> = {\n  /**\n   * Database adapter instance.\n   */\n  databaseAdapter: DatabaseAdapter<any>; // eslint-disable-line @typescript-eslint/no-explicit-any\n  /**\n   * ORM query engine for the fragment's schema.\n   */\n  db: SimpleQueryInterface<TSchema>;\n};\n\n/**\n * Create database context from options.\n * This extracts the database adapter and creates the ORM instance.\n */\nfunction createDatabaseContext<TSchema extends AnySchema>(\n  options: FragnoPublicConfigWithDatabase,\n  schema: TSchema,\n  namespace: string,\n): DatabaseFragmentContext<TSchema> {\n  const databaseAdapter = options.databaseAdapter;\n\n  if (!databaseAdapter) {\n    throw new Error(\n      \"Database fragment requires a database adapter to be provided in options.databaseAdapter\",\n    );\n  }\n\n  const db = databaseAdapter.createQueryEngine(schema, namespace);\n\n  return { databaseAdapter, db };\n}\n\n/**\n * Storage type for database fragments - stores the Unit of Work.\n */\nexport type DatabaseRequestStorage = {\n  uow: IUnitOfWork;\n};\n\n/**\n * Builder for database fragments that wraps the core fragment builder\n * and provides database-specific functionality.\n *\n * Database fragments always require FragnoPublicConfigWithDatabase (which includes databaseAdapter).\n */\nexport class DatabaseFragmentDefinitionBuilder<\n  TSchema extends AnySchema,\n  TConfig,\n  TDeps,\n  TBaseServices,\n  TServices,\n  TServiceDependencies,\n  TPrivateServices,\n  THooks extends HooksMap = {},\n  TServiceThisContext extends RequestThisContext = DatabaseHandlerContext,\n  THandlerThisContext extends RequestThisContext = DatabaseHandlerContext,\n  TLinkedFragments extends Record<string, AnyFragnoInstantiatedFragment> = {},\n> {\n  // Store the base builder - we'll replace its storage and context setup when building\n  #baseBuilder: FragmentDefinitionBuilder<\n    TConfig,\n    FragnoPublicConfigWithDatabase,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDependencies,\n    TPrivateServices,\n    TServiceThisContext,\n    THandlerThisContext,\n    DatabaseRequestStorage,\n    TLinkedFragments\n  >;\n  #schema: TSchema;\n  #namespace: string;\n  #hooksFactory?: (context: { config: TConfig; options: FragnoPublicConfigWithDatabase }) => THooks;\n\n  constructor(\n    baseBuilder: FragmentDefinitionBuilder<\n      TConfig,\n      FragnoPublicConfigWithDatabase,\n      TDeps,\n      TBaseServices,\n      TServices,\n      TServiceDependencies,\n      TPrivateServices,\n      TServiceThisContext,\n      THandlerThisContext,\n      DatabaseRequestStorage,\n      TLinkedFragments\n    >,\n    schema: TSchema,\n    namespace?: string,\n    hooksFactory?: (context: {\n      config: TConfig;\n      options: FragnoPublicConfigWithDatabase;\n    }) => THooks,\n  ) {\n    this.#baseBuilder = baseBuilder;\n    this.#schema = schema;\n    this.#namespace = namespace ?? baseBuilder.name;\n    this.#hooksFactory = hooksFactory;\n  }\n\n  /**\n   * Define dependencies for this database fragment.\n   * The context includes database adapter and ORM instance.\n   */\n  withDependencies<TNewDeps>(\n    fn: (context: {\n      config: TConfig;\n      options: FragnoPublicConfigWithDatabase;\n      db: SimpleQueryInterface<TSchema>;\n      databaseAdapter: DatabaseAdapter<any>; // eslint-disable-line @typescript-eslint/no-explicit-any\n    }) => TNewDeps,\n  ): DatabaseFragmentDefinitionBuilder<\n    TSchema,\n    TConfig,\n    TNewDeps & ImplicitDatabaseDependencies<TSchema>,\n    {},\n    {},\n    TServiceDependencies,\n    {},\n    THooks,\n    TServiceThisContext,\n    THandlerThisContext,\n    TLinkedFragments\n  > {\n    // Wrap user function to inject DB context\n    const wrappedFn = (context: { config: TConfig; options: FragnoPublicConfigWithDatabase }) => {\n      const dbContext = createDatabaseContext(context.options, this.#schema, this.#namespace);\n\n      // Call user function with enriched context\n      const userDeps = fn({\n        config: context.config,\n        options: context.options,\n        db: dbContext.db,\n        databaseAdapter: dbContext.databaseAdapter,\n      });\n\n      // Create implicit dependencies\n      const createUow = () => dbContext.db.createUnitOfWork();\n      const implicitDeps: ImplicitDatabaseDependencies<TSchema> = {\n        db: dbContext.db,\n        schema: this.#schema,\n        namespace: this.#namespace,\n        createUnitOfWork: createUow,\n      };\n\n      return {\n        ...userDeps,\n        ...implicitDeps,\n      };\n    };\n\n    // Create new base builder with wrapped function\n    const newBaseBuilder = this.#baseBuilder.withDependencies(wrappedFn);\n\n    return new DatabaseFragmentDefinitionBuilder(\n      newBaseBuilder,\n      this.#schema,\n      this.#namespace,\n      this.#hooksFactory,\n    );\n  }\n\n  providesBaseService<TNewService>(\n    fn: ServiceConstructorFn<\n      TConfig,\n      FragnoPublicConfigWithDatabase,\n      TDeps,\n      TServiceDependencies,\n      TPrivateServices,\n      TNewService,\n      TServiceThisContext\n    >,\n  ): DatabaseFragmentDefinitionBuilder<\n    TSchema,\n    TConfig,\n    TDeps,\n    TNewService,\n    TServices,\n    TServiceDependencies,\n    TPrivateServices,\n    THooks,\n    TServiceThisContext,\n    THandlerThisContext,\n    TLinkedFragments\n  > {\n    const newBaseBuilder = this.#baseBuilder.providesBaseService<TNewService>(fn);\n\n    return new DatabaseFragmentDefinitionBuilder(\n      newBaseBuilder,\n      this.#schema,\n      this.#namespace,\n      this.#hooksFactory,\n    );\n  }\n\n  providesService<TServiceName extends string, TService>(\n    serviceName: TServiceName,\n    fn: ServiceConstructorFn<\n      TConfig,\n      FragnoPublicConfigWithDatabase,\n      TDeps,\n      TServiceDependencies,\n      TPrivateServices,\n      TService,\n      TServiceThisContext\n    >,\n  ): DatabaseFragmentDefinitionBuilder<\n    TSchema,\n    TConfig,\n    TDeps,\n    TBaseServices,\n    TServices & { [K in TServiceName]: TService },\n    TServiceDependencies,\n    TPrivateServices,\n    THooks,\n    TServiceThisContext,\n    THandlerThisContext,\n    TLinkedFragments\n  > {\n    const newBaseBuilder = this.#baseBuilder.providesService<TServiceName, TService>(\n      serviceName,\n      fn,\n    );\n\n    return new DatabaseFragmentDefinitionBuilder(\n      newBaseBuilder,\n      this.#schema,\n      this.#namespace,\n      this.#hooksFactory,\n    );\n  }\n\n  /**\n   * Provide a private service that is only accessible to the fragment author.\n   * Private services are NOT exposed on the fragment instance, but can be used\n   * when defining other services (baseServices, namedServices, and other privateServices).\n   * Private services are instantiated in order, so earlier private services are available\n   * to later ones.\n   */\n  providesPrivateService<TServiceName extends string, TService>(\n    serviceName: TServiceName,\n    fn: ServiceConstructorFn<\n      TConfig,\n      FragnoPublicConfigWithDatabase,\n      TDeps,\n      TServiceDependencies,\n      TPrivateServices,\n      TService,\n      TServiceThisContext\n    >,\n  ): DatabaseFragmentDefinitionBuilder<\n    TSchema,\n    TConfig,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDependencies,\n    TPrivateServices & { [K in TServiceName]: TService },\n    THooks,\n    TServiceThisContext,\n    THandlerThisContext,\n    TLinkedFragments\n  > {\n    const newBaseBuilder = this.#baseBuilder.providesPrivateService<TServiceName, TService>(\n      serviceName,\n      fn,\n    );\n\n    return new DatabaseFragmentDefinitionBuilder(\n      newBaseBuilder,\n      this.#schema,\n      this.#namespace,\n      this.#hooksFactory,\n    );\n  }\n\n  /**\n   * Define durable hooks for this fragment.\n   * Hooks are automatically persisted and retried on failure.\n   *\n   * @param fn - Function that receives defineHook helper and returns a hooks map\n   * @returns Builder with hooks type set\n   *\n   * @example\n   * ```ts\n   * .provideHooks(({ defineHook, config }) => ({\n   *   onSubscribe: defineHook(async function (payload: { email: string }) {\n   *     // 'this' context available (HookServiceContext with nonce)\n   *     await config.onSubscribe?.(payload.email);\n   *   }),\n   * }))\n   * ```\n   */\n  provideHooks<TNewHooks extends HooksMap>(\n    fn: (context: {\n      config: TConfig;\n      options: FragnoPublicConfigWithDatabase;\n      defineHook: <TPayload>(\n        hook: (this: HookContext, payload: TPayload) => void | Promise<void>,\n      ) => HookFn<TPayload>;\n    }) => TNewHooks,\n  ): DatabaseFragmentDefinitionBuilder<\n    TSchema,\n    TConfig,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDependencies,\n    TPrivateServices,\n    TNewHooks,\n    DatabaseServiceContext<TNewHooks>,\n    THandlerThisContext,\n    TLinkedFragments\n  > {\n    const defineHook = <TPayload>(\n      hook: (this: HookContext, payload: TPayload) => void | Promise<void>,\n    ): HookFn<TPayload> => {\n      return hook;\n    };\n\n    // Store the hooks factory - it will be called in build() with config/options\n    const hooksFactory = (context: {\n      config: TConfig;\n      options: FragnoPublicConfigWithDatabase;\n    }) => {\n      return fn({\n        config: context.config,\n        options: context.options,\n        defineHook,\n      });\n    };\n\n    // Create new builder with hooks factory stored\n    // Cast is safe: we're only changing THooks and TServiceThisContext type parameters\n    const newBuilder = new DatabaseFragmentDefinitionBuilder(\n      this.#baseBuilder,\n      this.#schema,\n      this.#namespace,\n    ) as unknown as DatabaseFragmentDefinitionBuilder<\n      TSchema,\n      TConfig,\n      TDeps,\n      TBaseServices,\n      TServices,\n      TServiceDependencies,\n      TPrivateServices,\n      TNewHooks,\n      DatabaseServiceContext<TNewHooks>,\n      THandlerThisContext,\n      TLinkedFragments\n    >;\n\n    newBuilder.#hooksFactory = hooksFactory;\n\n    return newBuilder;\n  }\n\n  /**\n   * Declare that this fragment uses a required service provided by the runtime.\n   * Delegates to the base builder.\n   */\n  usesService<TServiceName extends string, TService>(\n    serviceName: TServiceName,\n  ): DatabaseFragmentDefinitionBuilder<\n    TSchema,\n    TConfig,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDependencies & { [K in TServiceName]: TService },\n    TPrivateServices,\n    THooks,\n    TServiceThisContext,\n    THandlerThisContext,\n    TLinkedFragments\n  > {\n    const newBaseBuilder = this.#baseBuilder.usesService<TServiceName, TService>(serviceName);\n\n    return new DatabaseFragmentDefinitionBuilder(\n      newBaseBuilder,\n      this.#schema,\n      this.#namespace,\n      this.#hooksFactory,\n    );\n  }\n\n  /**\n   * Declare that this fragment uses an optional service provided by the runtime.\n   * Delegates to the base builder.\n   */\n  usesOptionalService<TServiceName extends string, TService>(\n    serviceName: TServiceName,\n  ): DatabaseFragmentDefinitionBuilder<\n    TSchema,\n    TConfig,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDependencies & { [K in TServiceName]: TService | undefined },\n    TPrivateServices,\n    THooks,\n    TServiceThisContext,\n    THandlerThisContext,\n    TLinkedFragments\n  > {\n    const newBaseBuilder = this.#baseBuilder.usesOptionalService<TServiceName, TService>(\n      serviceName,\n    );\n\n    return new DatabaseFragmentDefinitionBuilder(\n      newBaseBuilder,\n      this.#schema,\n      this.#namespace,\n      this.#hooksFactory,\n    );\n  }\n\n  /**\n   * Build the final database fragment definition.\n   * This includes the request context setup for UnitOfWork management.\n   * Note: TDeps already includes ImplicitDatabaseDependencies from withDatabase().\n   */\n  build(): FragmentDefinition<\n    TConfig,\n    FragnoPublicConfigWithDatabase,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDependencies,\n    TPrivateServices,\n    DatabaseServiceContext<THooks>,\n    DatabaseHandlerContext<THooks>,\n    DatabaseRequestStorage,\n    TLinkedFragments\n  > {\n    const baseDef = this.#baseBuilder.build();\n\n    // Ensure dependencies callback always exists for database fragments\n    // If no user dependencies were defined, create a minimal one that only adds implicit deps\n    const dependencies = (context: {\n      config: TConfig;\n      options: FragnoPublicConfigWithDatabase;\n    }): TDeps => {\n      // In dry run mode, allow user deps to fail gracefully.\n      // This is critical for database fragments because the CLI needs access to the schema\n      // even when user dependencies (like API clients) can't be initialized.\n      // Without this, if user deps fail, we'd lose the implicit database dependencies\n      // (including schema), and the CLI couldn't extract schema information.\n      let userDeps;\n      try {\n        userDeps = baseDef.dependencies?.(context);\n      } catch (error) {\n        if (process.env[\"FRAGNO_INIT_DRY_RUN\"] === \"true\") {\n          console.warn(\n            \"Warning: Failed to initialize user dependencies in dry run mode:\",\n            error instanceof Error ? error.message : String(error),\n          );\n          userDeps = {};\n        } else {\n          throw error;\n        }\n      }\n\n      const { db } = createDatabaseContext(context.options, this.#schema, this.#namespace);\n\n      const implicitDeps: ImplicitDatabaseDependencies<TSchema> = {\n        db,\n        schema: this.#schema,\n        namespace: this.#namespace,\n        createUnitOfWork: () => db.createUnitOfWork(),\n      };\n\n      return {\n        ...userDeps,\n        ...implicitDeps,\n      } as TDeps;\n    };\n\n    // Use the adapter's shared context storage (all fragments using the same adapter share this storage)\n    const builderWithExternalStorage = this.#baseBuilder.withExternalRequestStorage(\n      ({ options }) => {\n        const dbContext = createDatabaseContext(options, this.#schema, this.#namespace);\n        return dbContext.databaseAdapter.contextStorage;\n      },\n    );\n\n    // Set up request storage to initialize the Unit of Work\n    const builderWithStorage = builderWithExternalStorage.withRequestStorage(\n      ({ options }): DatabaseRequestStorage => {\n        // Create database context - needed here to create the UOW\n        const dbContextForStorage = createDatabaseContext(options, this.#schema, this.#namespace);\n\n        // Create a new Unit of Work for this request\n        const uow: IUnitOfWork = dbContextForStorage.db.createUnitOfWork();\n\n        return { uow };\n      },\n    );\n\n    // Get the internal fragment factory from linked fragments (added by withDatabase)\n    // Cast is safe: withDatabase() guarantees this fragment exists and has the correct type\n    const internalFragmentFactory = baseDef.linkedFragments?.[\"_fragno_internal\"] as (context: {\n      config: TConfig;\n      options: FragnoPublicConfigWithDatabase;\n    }) => InternalFragmentInstance;\n\n    const builderWithContext = builderWithStorage.withThisContext<\n      DatabaseServiceContext<THooks>,\n      DatabaseHandlerContext<THooks>\n    >(({ storage, config, options }) => {\n      // Create hooks config if hooks factory is defined\n      const hooksConfig = this.#hooksFactory\n        ? {\n            hooks: this.#hooksFactory({ config, options }),\n            namespace: this.#namespace,\n            internalFragment: internalFragmentFactory({ config, options }),\n          }\n        : undefined;\n\n      function forSchema<TSchema extends AnySchema>(\n        schema: TSchema,\n      ): TypedUnitOfWork<TSchema, [], unknown, THooks> {\n        const uow = storage.getStore()?.uow;\n        if (!uow) {\n          throw new Error(\n            \"No UnitOfWork in context. Service must be called within a route handler OR using `withUnitOfWork`.\",\n          );\n        }\n\n        return uow.restrict().forSchema<TSchema, THooks>(schema);\n      }\n\n      const serviceContext: DatabaseServiceContext<THooks> = {\n        uow: forSchema,\n      };\n\n      async function uow<TResult>(\n        callback: (context: {\n          forSchema: <S extends AnySchema, H extends HooksMap = THooks>(\n            schema: S,\n            hooks?: H,\n          ) => TypedUnitOfWork<S, [], unknown, H>;\n          executeRetrieve: () => Promise<void>;\n          executeMutate: () => Promise<void>;\n          nonce: string;\n          currentAttempt: number;\n        }) => Promise<TResult> | TResult,\n        execOptions?: Omit<\n          ExecuteRestrictedUnitOfWorkOptions,\n          \"createUnitOfWork\" | \"onBeforeMutate\" | \"onSuccess\"\n        >,\n      ): Promise<AwaitedPromisesInObject<TResult>> {\n        const currentStorage = storage.getStore();\n        if (!currentStorage) {\n          throw new Error(\n            \"No storage in context. Handler must be called within a request context.\",\n          );\n        }\n\n        const wrappedCallback = async (context: {\n          forSchema: <S extends AnySchema, H extends HooksMap = THooks>(\n            schema: S,\n            hooks?: H,\n          ) => TypedUnitOfWork<S, [], unknown, H>;\n          executeRetrieve: () => Promise<void>;\n          executeMutate: () => Promise<void>;\n          nonce: string;\n          currentAttempt: number;\n        }): Promise<TResult> => {\n          return callback(context);\n        };\n\n        return executeRestrictedUnitOfWork(wrappedCallback, {\n          ...execOptions,\n          createUnitOfWork: () => {\n            currentStorage.uow.reset();\n            // Register internal schema for hook mutations\n            if (hooksConfig) {\n              currentStorage.uow.registerSchema(\n                hooksConfig.internalFragment.$internal.deps.schema,\n                hooksConfig.internalFragment.$internal.deps.namespace,\n              );\n            }\n            return currentStorage.uow as UnitOfWork;\n          },\n          onBeforeMutate: hooksConfig ? (uow) => prepareHookMutations(uow, hooksConfig) : undefined,\n          onSuccess: hooksConfig ? () => processHooks(hooksConfig) : undefined,\n        });\n      }\n\n      const handlerContext: DatabaseHandlerContext<THooks> = {\n        uow,\n      };\n\n      return { serviceContext, handlerContext };\n    });\n\n    // Build the final definition\n    const finalDef = builderWithContext.build();\n\n    // Return the complete definition with proper typing and dependencies\n    return {\n      ...finalDef,\n      dependencies,\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/fragments/internal-fragment.d.ts

@@ -0,0 +1,53 @@
+import { AnyColumn, AnyRelation, Column, FragnoId, IdColumn, Index, Schema, Table } from "../schema/create.js";
+import { RetryPolicy } from "../query/unit-of-work/retry-policy.js";
+import { DatabaseHandlerContext, DatabaseRequestStorage, DatabaseServiceContext, FragnoPublicConfigWithDatabase, ImplicitDatabaseDependencies } from "../db-fragment-definition-builder.js";
+import * as _fragno_dev_core0 from "@fragno-dev/core";
+import { InstantiatedFragmentFromDefinition } from "@fragno-dev/core";
+
+//#region src/fragments/internal-fragment.d.ts
+declare const internalFragmentDef: _fragno_dev_core0.FragmentDefinition<{}, FragnoPublicConfigWithDatabase, ImplicitDatabaseDependencies<Schema<Record<"fragno_db_settings", Table<Record<string, AnyColumn> & Record<"id", IdColumn<"varchar(30)", string | FragnoId | null, FragnoId>> & Record<"key", Column<"string", string, string>> & Record<"value", Column<"string", string, string>>, Record<string, AnyRelation>, Record<string, Index<AnyColumn[], readonly string[]>> & Record<"unique_key", Index<readonly [Column<"string", string, string>] & AnyColumn[], readonly ["key"]>>>> & Record<"fragno_hooks", Table<Record<string, AnyColumn> & Record<"id", IdColumn<"varchar(30)", string | FragnoId | null, FragnoId>> & Record<"namespace", Column<"string", string, string>> & Record<"hookName", Column<"string", string, string>> & Record<"payload", Column<"json", unknown, unknown>> & Record<"status", Column<"string", string, string>> & Record<"attempts", Column<"integer", number | null, number>> & Record<"maxAttempts", Column<"integer", number | null, number>> & Record<"lastAttemptAt", Column<"timestamp", Date | null, Date | null>> & Record<"nextRetryAt", Column<"timestamp", Date | null, Date | null>> & Record<"error", Column<"string", string | null, string | null>> & Record<"createdAt", Column<"timestamp", Date | null, Date>> & Record<"nonce", Column<"string", string, string>>, Record<string, AnyRelation>, Record<string, Index<AnyColumn[], readonly string[]>> & Record<"idx_namespace_status_retry", Index<readonly [Column<"string", string, string>, Column<"string", string, string>, Column<"timestamp", Date | null, Date | null>] & AnyColumn[], readonly ["namespace", "status", "nextRetryAt"]>> & Record<"idx_nonce", Index<readonly [Column<"string", string, string>] & AnyColumn[], readonly ["nonce"]>>>>>>, {}, {
+  settingsService: {
+    get(namespace: string, key: string): Promise<{
+      id: FragnoId;
+      key: string;
+      value: string;
+    } | undefined>;
+    set(namespace: string, key: string, value: string): Promise<void>;
+    delete(id: FragnoId): Promise<void>;
+  };
+} & {
+  hookService: {
+    /**
+     * Get pending hook events for processing.
+     * Returns all pending events for the given namespace that are ready to be processed.
+     */
+    getPendingHookEvents(namespace: string): Promise<{
+      id: FragnoId;
+      hookName: string;
+      payload: unknown;
+      attempts: number;
+      maxAttempts: number;
+      nonce: string;
+    }[]>;
+    /**
+     * Mark a hook event as completed.
+     */
+    markHookCompleted(eventId: FragnoId): void;
+    /**
+     * Mark a hook event as failed and schedule next retry.
+     */
+    markHookFailed(eventId: FragnoId, error: string, attempts: number, retryPolicy: RetryPolicy): void;
+    /**
+     * Mark a hook event as processing (to prevent concurrent execution).
+     */
+    markHookProcessing(eventId: FragnoId): void;
+  };
+}, {}, {}, DatabaseServiceContext<{}>, DatabaseHandlerContext<{}>, DatabaseRequestStorage, {}>;
+/**
+ * Type representing an instantiated internal fragment.
+ * This is the fragment that manages Fragno's internal settings table.
+ */
+type InternalFragmentInstance = InstantiatedFragmentFromDefinition<typeof internalFragmentDef>;
+//#endregion
+export { InternalFragmentInstance, internalFragmentDef };
+//# sourceMappingURL=internal-fragment.d.ts.map