@fragno-dev/db 0.2.2 → 0.4.1

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

@@ -0,0 +1,237 @@
+import { AnySchema } from "./schema/create.js";
+import { AwaitedPromisesInObject, ExecuteTxOptions, ExtractServiceFinalResults, HandlerTxBuilder, ServiceTxBuilder, TxResult } from "./query/unit-of-work/execute-unit-of-work.js";
+import { SyncCommandRegistry, SyncCommandTargetRegistration } from "./sync/types.js";
+import { InternalFragmentInstance } from "./fragments/internal-fragment.js";
+import { DurableHooksProcessingOptions, HookContext, HookFn, HooksMap } from "./hooks/hooks.js";
+import { IUnitOfWork } from "./query/unit-of-work/unit-of-work.js";
+import { DatabaseAdapter } from "./adapters/adapters.js";
+import { AnyRouteOrFactory, BoundServices, FragmentDefinition, FragmentDefinitionBuilder, FragnoPublicConfig, RequestThisContext, ServiceConstructorFn } from "@fragno-dev/core";
+
+//#region src/db-fragment-definition-builder.d.ts
+type RegistrySchemaInfo = {
+  name: string;
+  namespace: string | null;
+  version: number;
+  tables: string[];
+};
+type RegistryFragmentMeta = {
+  name: string;
+  mountRoute: string;
+};
+type ExtractServiceFinalResultOrSingle<T> = T extends readonly (TxResult<unknown, unknown> | undefined)[] ? AwaitedPromisesInObject<ExtractServiceFinalResults<T>> : T extends undefined ? undefined : AwaitedPromisesInObject<ExtractServiceFinalResults<readonly [T]>>[0];
+type RegistryResolver = {
+  getRegistryForAdapterSync: <TUOWConfig>(adapter: DatabaseAdapter<TUOWConfig>) => {
+    registerSchema: (schema: RegistrySchemaInfo, fragment: RegistryFragmentMeta, options?: {
+      outboxEnabled?: boolean;
+    }) => void;
+    registerSyncCommands: (registration: SyncCommandTargetRegistration) => void;
+  };
+  getInternalFragment: <TUOWConfig>(adapter: DatabaseAdapter<TUOWConfig>) => InternalFragmentInstance;
+};
+type HooksFactoryContext<TConfig> = {
+  config: TConfig;
+  options: FragnoPublicConfigWithDatabase;
+  deps: unknown;
+  services: unknown;
+  serviceDeps: unknown;
+};
+/**
+ * Extended FragnoPublicConfig for database fragments.
+ * If databaseAdapter is omitted and better-sqlite3 is available, a default SQLite adapter is used.
+ */
+type FragnoPublicConfigWithDatabase = FragnoPublicConfig & {
+  databaseAdapter?: DatabaseAdapter<any>;
+  /**
+   * Optional guard to limit database roundtrips per request (primarily for tests).
+   * When enabled, retrieve-only and mutate-only handlerTx().execute() calls are
+   * counted separately (one of each by default).
+   * Applied only for route handlers (not inContext).
+   */
+  dbRoundtripGuard?: boolean | DbRoundtripGuardConfig;
+  /**
+   * Optional outbox configuration for this fragment.
+   */
+  outbox?: {
+    enabled?: boolean;
+  };
+  /**
+   * Optional durable hooks processing configuration.
+   */
+  durableHooks?: DurableHooksProcessingOptions;
+  /**
+   * Optional override for database namespace. If provided (including null), it is used as-is
+   * without sanitization — the caller is responsible for providing a valid namespace.
+   * When omitted, defaults to a sanitized version of schema.name.
+   */
+  databaseNamespace?: string | null;
+};
+/**
+ * Configuration for limiting database roundtrips per request.
+ */
+type DbRoundtripGuardConfig = {
+  /**
+   * Maximum allowed retrieve-only and mutate-only handlerTx().execute() calls per request.
+   * Each type is tracked separately.
+   * Defaults to 1 when the guard is enabled.
+   */
+  maxRoundtrips?: number;
+};
+/**
+ * Implicit dependencies that database fragments get automatically.
+ * These are injected without requiring explicit configuration.
+ */
+type ImplicitDatabaseDependencies<TSchema extends AnySchema> = {
+  /**
+   * Database adapter instance.
+   */
+  databaseAdapter: DatabaseAdapter<any>;
+  /**
+   * The schema definition for this fragment.
+   */
+  schema: TSchema;
+  /**
+   * The database namespace for this fragment.
+   */
+  namespace: string | null;
+  /**
+   * 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 & {
+  /**
+   * Create a service-level transaction builder using the fluent API.
+   * Returns a builder that can be chained with withServiceCalls, retrieve,
+   * transformRetrieve, mutate, transform, and build.
+   *
+   * @example
+   * ```ts
+   * return this.serviceTx(schema)
+   *   .withServiceCalls(() => [otherService.getData()])
+   *   .retrieve((uow) => uow.find("users", ...))
+   *   .transformRetrieve(([users]) => users[0])
+   *   .mutate(({ uow, retrieveResult, serviceIntermediateResult }) =>
+   *     uow.create("records", { ... })
+   *   )
+   *   .transform(({ mutateResult, serviceResult }) => ({ id: mutateResult }))
+   *   .build();
+   * ```
+   */
+  serviceTx<TSchema extends AnySchema>(schema: TSchema): ServiceTxBuilder<TSchema, readonly [], [], [], unknown, unknown, false, false, false, false, THooks>;
+};
+/**
+ * Handler context for database fragments - provides UOW execution with automatic retry support.
+ */
+type DatabaseHandlerContext<THooks extends HooksMap = {}> = RequestThisContext & {
+  /**
+   * Create a handler-level transaction builder using the fluent API.
+   * Returns a builder that can be chained with withServiceCalls, retrieve,
+   * transformRetrieve, mutate, transform, and execute.
+   *
+   * @example
+   * ```ts
+   * const result = await this.handlerTx()
+   *   .withServiceCalls(() => [userService.getUser(id)])
+   *   .mutate(({ forSchema, idempotencyKey, currentAttempt, serviceIntermediateResult }) => {
+   *     return forSchema(ordersSchema).create("orders", { ... });
+   *   })
+   *   .transform(({ mutateResult, serviceResult }) => ({ ... }))
+   *   .execute();
+   * ```
+   */
+  handlerTx(options?: Omit<ExecuteTxOptions, "createUnitOfWork">): HandlerTxBuilder<readonly [], [], [], unknown, unknown, false, false, false, false, THooks>;
+  /**
+   * Execute multiple service calls in a handler context and return their final results.
+   */
+  callServices<TServiceCalls extends TxResult<unknown, unknown> | undefined | readonly (TxResult<unknown, unknown> | undefined)[]>(
+  /**
+   * Factory to create service calls inside the active context.
+   */
+  serviceCalls: () => TServiceCalls): Promise<ExtractServiceFinalResultOrSingle<TServiceCalls>>;
+};
+/**
+ * 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 use FragnoPublicConfigWithDatabase and default the adapter when possible.
+ */
+declare class DatabaseFragmentDefinitionBuilder<TSchema extends AnySchema, TConfig, TDeps, TBaseServices, TServices, TServiceDependencies, TPrivateServices, THooks extends HooksMap = {}, TServiceThisContext extends RequestThisContext = DatabaseHandlerContext, THandlerThisContext extends RequestThisContext = DatabaseHandlerContext, TInternalRoutes extends readonly AnyRouteOrFactory[] = readonly []> {
+  #private;
+  constructor(baseBuilder: FragmentDefinitionBuilder<TConfig, FragnoPublicConfigWithDatabase, TDeps, TBaseServices, TServices, TServiceDependencies, TPrivateServices, TServiceThisContext, THandlerThisContext, DatabaseRequestStorage, TInternalRoutes>, schema: TSchema, hooksFactory?: (context: HooksFactoryContext<TConfig>) => THooks, syncRegistry?: SyncCommandRegistry, registryResolver?: RegistryResolver);
+  /**
+   * Define dependencies for this database fragment.
+   * The context includes the database adapter.
+   */
+  withDependencies<TNewDeps>(fn: (context: {
+    config: TConfig;
+    options: FragnoPublicConfigWithDatabase;
+    databaseAdapter: DatabaseAdapter<any>;
+  }) => TNewDeps): DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TNewDeps & ImplicitDatabaseDependencies<TSchema>, {}, {}, TServiceDependencies, {}, THooks, TServiceThisContext, THandlerThisContext, TInternalRoutes>;
+  providesBaseService<TNewService>(fn: ServiceConstructorFn<TConfig, FragnoPublicConfigWithDatabase, TDeps, TServiceDependencies, TPrivateServices, TNewService, TServiceThisContext>): DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TDeps, TNewService, TServices, TServiceDependencies, TPrivateServices, THooks, TServiceThisContext, THandlerThisContext, TInternalRoutes>;
+  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, TInternalRoutes>;
+  /**
+   * 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, TInternalRoutes>;
+  /**
+   * 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 idempotencyKey)
+   *     await config.onSubscribe?.(payload.email);
+   *   }),
+   * }))
+   * ```
+   */
+  provideHooks<TNewHooks extends HooksMap>(fn: (context: {
+    config: TConfig;
+    options: FragnoPublicConfigWithDatabase;
+    deps: TDeps;
+    services: BoundServices<TBaseServices & TServices>;
+    serviceDeps: TServiceDependencies;
+    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, TInternalRoutes>;
+  /**
+   * Register sync command definitions for this fragment.
+   */
+  withSyncCommands(registry: SyncCommandRegistry): DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TDeps, TBaseServices, TServices, TServiceDependencies, TPrivateServices, THooks, TServiceThisContext, THandlerThisContext, TInternalRoutes>;
+  /**
+   * 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, TInternalRoutes>;
+  /**
+   * 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, TInternalRoutes>;
+  /**
+   * 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, TInternalRoutes>;
+}
+//#endregion
+export { DatabaseFragmentDefinitionBuilder, DatabaseHandlerContext, DatabaseRequestStorage, DatabaseServiceContext, DbRoundtripGuardConfig, FragnoPublicConfigWithDatabase, ImplicitDatabaseDependencies };
+//# sourceMappingURL=db-fragment-definition-builder.d.ts.map

package/dist/browser/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":";;;;;;;;;;KAkDK,kBAAA;EAAA,IAAA,EAAA,MAAA;EAOA,SAAA,EAAA,MAAA,GAAA,IAAoB;EAKpB,OAAA,EAAA,MAAA;EAAuC,MAAA,EAAA,MAAA,EAAA;CACxC;KANC,oBAAA,GASkD;EAA3B,IAAA,EAAA,MAAA;EAAxB,UAAA,EAAA,MAAA;CACA;KALC,iCAO8D,CAAA,CAAA,CAAA,GAPvB,CAOuB,SAAA,SAAA,CAN/D,QAM+D,CAAA,OAAA,EAAA,OAAA,CAAA,GAAA,SAAA,CAAA,EAAA,GAH/D,uBAG+D,CAHvC,0BAGuC,CAHZ,CAGY,CAAA,CAAA,GAF/D,CAE+D,SAAA,SAAA,GAAA,SAAA,GAA7D,uBAA6D,CAArC,0BAAqC,CAAA,SAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;KAE9D,gBAAA,GAFyB;EAAxB,yBAAA,EAAA,CAAA,UAAA,CAAA,CAAA,OAAA,EAG6C,eAH7C,CAG6D,UAH7D,CAAA,EAAA,GAAA;IAAuB,cAAA,EAAA,CAAA,MAAA,EAKf,kBALe,EAAA,QAAA,EAMb,oBANa,EAAA,OAGsC,CAHtC,EAAA;MAExB,aAAgB,CAAA,EAAA,OAAA;IAC8C,CAAA,EAAA,GAAA,IAAA;IAAhB,oBAAA,EAAA,CAAA,YAAA,EAMV,6BANU,EAAA,GAAA,IAAA;EAErC,CAAA;EACE,mBAAA,EAAA,CAAA,UAAA,CAAA,CAAA,OAAA,EAMH,eANG,CAMa,UANb,CAAA,EAAA,GAOT,wBAPS;CAGyB;KAOpC,mBAJwB,CAAA,OAAA,CAAA,GAAA;EAAhB,MAAA,EAKH,OALG;EACN,OAAA,EAKI,8BALJ;EAAwB,IAAA,EAAA,OAAA;EAG1B,QAAA,EAAA,OAAA;EAwBO,WAAA,EAAA,OAAA;CAAiC;;;;;AA+BjC,KA/BA,8BAAA,GAAiC,kBA+BX,GAAA;EAatB,eAAA,CAAA,EA1CQ,eA0CoB,CAAA,GAAA,CAAA;EAAiB;;;;;AAsBzD;EAAkD,gBAAA,CAAA,EAAA,OAAA,GAzDnB,sBAyDmB;EAAY;;;EAsB1D,MAAA,CAAA,EAAA;IAUA,OAAA,CAAA,EAAA,OAAA;EAXC,CAAA;EAAgB;AAkBrB;;EAAmE,YAAA,CAAA,EAtFlD,6BAsFkD;EAkBhD;;;;;EAUD,iBAAA,CAAA,EAAA,MAAA,GAAA,IAAA;CAKM;;;;AACZ,KA5GA,sBAAA,GA4GA;EA6UA;AAUZ;;;;EASmD,aAAA,CAAA,EAAA,MAAA;CACrB;;;;;AA0BxB,KA1dM,4BA0dN,CAAA,gBA1dmD,SA0dnD,CAAA,GAAA;EACA;;;EAGA,eAAA,EA1da,eA0db,CAAA,GAAA,CAAA;EACA;;;EAGA,MAAA,EA1dI,OA0dJ;EAXW;;;EAcY,SAAA,EAAA,MAAA,GAAA,IAAA;EAAiC;;;EAiBhD,gBAAA,EAAA,GAAA,GAteY,WAseZ;CACC;;;;AAKX,KAteQ,sBAseR,CAAA,eAte8C,QAse9C,CAAA,GAte0D,kBAse1D,GAAA;EACA;;;;;;;;;;;;;;;;;;EA6DA,SAAA,CAAA,gBAjhBwB,SAihBxB,CAAA,CAAA,MAAA,EAhhBQ,OAghBR,CAAA,EA/gBC,gBA+gBD,CA9gBA,OA8gBA,EAAA,SAAA,EAAA,EAAA,EACA,EAAA,EACA,EAAA,OAAA,EAAA,OAAA,EAAA,KAAA,EAAA,KAAA,EAAA,KAAA,EAAA,KAAA,EAtgBA,MAsgBA,CAAA;CACA;;;;AAIA,KApgBQ,sBAogBR,CAAA,eApgB8C,QAogB9C,GAAA,CAAA,CAAA,CAAA,GApgB+D,kBAogB/D,GAAA;EACA;;;;;;;;;;;;;;;;EA8BA,SAAA,CAAA,OAAA,CAAA,EAjhBU,IAihBV,CAjhBe,gBAihBf,EAAA,kBAAA,CAAA,CAAA,EAhhBC,gBAghBD,CAAA,SAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,OAAA,EAAA,OAAA,EAAA,KAAA,EAAA,KAAA,EAAA,KAAA,EAAA,KAAA,EAhhBqF,MAghBrF,CAAA;EAAoB;;;EAEpB,YAAA,CAAA,sBA3gBI,QA2gBJ,CAAA,OAAA,EAAA,OAAA,CAAA,GAAA,SAAA,GAAA,SAAA,CAzgBc,QAygBd,CAAA,OAAA,EAAA,OAAA,CAAA,GAAA,SAAA,CAAA,EAAA,CAAA;EACA;;;EAGA,YAAA,EAAA,GAAA,GAxgBoB,aAwgBpB,CAAA,EAvgBC,OAugBD,CAvgBS,iCAugBT,CAvgB2C,aAugB3C,CAAA,CAAA;CAXC;;;;AAiDD,KAhOQ,sBAAA,GAgOR;EACA,GAAA,EAhOG,WAgOH;CACA;;;;;;;AAKA,cA7NS,iCA6NT,CAAA,gBA5Nc,SA4Nd,EAAA,OAAA,EAAA,KAAA,EAAA,aAAA,EAAA,SAAA,EAAA,oBAAA,EAAA,gBAAA,EAAA,eArNa,QAqNb,GAAA,CAAA,CAAA,EAAA,4BApN0B,kBAoN1B,GApN+C,sBAoN/C,EAAA,4BAnN0B,kBAmN1B,GAnN+C,sBAmN/C,EAAA,wBAAA,SAlN+B,iBAkN/B,EAAA,GAAA,SAAA,EAAA,CAAA,CAAA;EAXC,CAAA,OAAA;EA4C4B,WAAA,CAAA,WAAA,EA7NhB,yBA6NgB,CA5N3B,OA4N2B,EA3N3B,8BA2N2B,EA1N3B,KA0N2B,EAzN3B,aAyN2B,EAxN3B,SAwN2B,EAvN3B,oBAuN2B,EAtN3B,gBAsN2B,EArN3B,mBAqN2B,EApN3B,mBAoN2B,EAnN3B,sBAmN2B,EAlN3B,eAkN2B,CAAA,EAAA,MAAA,EAhNrB,OAgNqB,EAAA,YAAA,CAAA,EAAA,CAAA,OAAA,EA/MJ,mBA+MI,CA/MgB,OA+MhB,CAAA,EAAA,GA/M6B,MA+M7B,EAAA,YAAA,CAAA,EA9Md,mBA8Mc,EAAA,gBAAA,CAAA,EA7MV,gBA6MU;EAEnB;;;;EAGgC,gBAAA,CAAA,QAAA,CAAA,CAAA,EAAA,EAAA,CAAA,OAAA,EAAA;IAA9B,MAAA,EAnMF,OAmME;IACG,OAAA,EAnMJ,8BAmMI;IAEE,eAAA,EApME,eAoMF,CAAA,GAAA,CAAA;EAAsB,CAAA,EAAA,GAnMjC,QAmMiC,CAAA,EAlMtC,iCAkMsC,CAjMvC,OAiMuC,EAhMvC,OAgMuC,EA/LvC,QA+LuC,GA/L5B,4BA+L4B,CA/LC,OA+LD,CAAA,EAAA,CAAA,CAAA,EAAA,CAAA,CAAA,EA5LvC,oBA4LuC,EAAA,CAAA,CAAA,EA1LvC,MA0LuC,EAzLvC,mBAyLuC,EAxLvC,mBAwLuC,EAvLvC,eAuLuC,CAAA;EAAoB,mBAAA,CAAA,WAAA,CAAA,CAAA,EAAA,EA7IvD,oBA6IuD,CA5IzD,OA4IyD,EA3IzD,8BA2IyD,EA1IzD,KA0IyD,EAzIzD,oBAyIyD,EAxIzD,gBAwIyD,EAvIzD,WAuIyD,EAtIzD,mBAsIyD,CAAA,CAAA,EApI1D,iCAoI0D,CAnI3D,OAmI2D,EAlI3D,OAkI2D,EAjI3D,KAiI2D,EAhI3D,WAgI2D,EA/H3D,SA+H2D,EA9H3D,oBA8H2D,EA7H3D,gBA6H2D,EA5H3D,MA4H2D,EA3H3D,mBA2H2D,EA1H3D,mBA0H2D,EAzH3D,eAyH2D,CAAA;EAC7C,eAAA,CAAA,qBAAA,MAAA,EAAA,QAAA,CAAA,CAAA,WAAA,EA5GD,YA4GC,EAAA,EAAA,EA3GV,oBA2GU,CA1GZ,OA0GY,EAzGZ,8BAyGY,EAxGZ,KAwGY,EAvGZ,oBAuGY,EAtGZ,gBAsGY,EArGZ,QAqGY,EApGZ,mBAoGY,CAAA,CAAA,EAlGb,iCAkGa,CAjGd,OAiGc,EAhGd,OAgGc,EA/Fd,KA+Fc,EA9Fd,aA8Fc,EA7Fd,SA6Fc,GAAA,QA7FM,YA6Fb,GA7F4B,QA6F5B,EACD,EA7FN,oBA6FM,EA5FN,gBA4FM,EA3FN,MA2FM,EA1FN,mBA0FM,EAzFN,mBAyFM,EAxFN,eAwFM,CAAA;EAEN;;;;;;;EAOA,sBAAA,CAAA,qBAAA,MAAA,EAAA,QAAA,CAAA,CAAA,WAAA,EAzEa,YAyEb,EAAA,EAAA,EAxEI,oBAwEJ,CAvEE,OAuEF,EAtEE,8BAsEF,EArEE,KAqEF,EApEE,oBAoEF,EAnEE,gBAmEF,EAlEE,QAkEF,EAjEE,mBAiEF,CAAA,CAAA,EA/DC,iCA+DD,CA9DA,OA8DA,EA7DA,OA6DA,EA5DA,KA4DA,EA3DA,aA2DA,EA1DA,SA0DA,EAzDA,oBAyDA,EAxDA,gBAwDA,GAAA,QAxD2B,YAyDJ,GAzDmB,QAyDnB,EAAvB,EAxDA,MAwDA,EAvDA,mBAuDA,EAtDA,mBAsDA,EArDA,eAqDA,CAAA;EACA;;;;;;;;;;;;;;;;;EAwFA,YAAA,CAAA,kBA7G6B,QA6G7B,CAAA,CAAA,EAAA,EAAA,CAAA,OAAA,EAAA;IACA,MAAA,EA5GU,OA4GV;IACA,OAAA,EA5GW,8BA4GX;IACA,IAAA,EA5GQ,KA4GR;IACA,QAAA,EA5GY,aA4GZ,CA5G0B,aA4G1B,GA5G0C,SA4G1C,CAAA;IACA,WAAA,EA5Ge,oBA4Gf;IAA+B,UAAA,EAAA,CAAA,QAAA,CAAA,CAAA,IAAA,EAAA,CAAA,IAAA,EA1Gd,WA0Gc,EAAA,OAAA,EA1GQ,QA0GR,EAAA,GAAA,IAAA,GA1G4B,OA0G5B,CAAA,IAAA,CAAA,EAAA,GAzGxB,MAyGwB,CAzGjB,QAyGiB,CAAA;EAAe,CAAA,EAAA,GAxGxC,SAwGwC,CAAA,EAvG7C,iCAuG6C,CAtG9C,OAsG8C,EArG9C,OAqG8C,EApG9C,KAoG8C,EAnG9C,aAmG8C,EAlG9C,SAkG8C,EAjG9C,oBAiG8C,EAhG9C,gBAgG8C,EA/F9C,SA+F8C,EA9F9C,sBA8F8C,CA9FvB,SA8FuB,CAAA,EA7F9C,mBA6F8C,EA5F9C,eA4F8C,CAAA;EAC9C;;;EAGA,gBAAA,CAAA,QAAA,EA7CU,mBA6CV,CAAA,EA5CC,iCA4CD,CA3CA,OA2CA,EA1CA,OA0CA,EAzCA,KAyCA,EAxCA,aAwCA,EAvCA,SAuCA,EAtCA,oBAsCA,EArCA,gBAqCA,EApCA,MAoCA,EAnCA,mBAmCA,EAlCA,mBAkCA,EAjCA,eAiCA,CAAA;EACA;;;;EAqBA,WAAA,CAAA,qBAAA,MAAA,EAAA,QAAA,CAAA,CAAA,WAAA,EAjCa,YAiCb,CAAA,EAhCC,iCAgCD,CA/BA,OA+BA,EA9BA,OA8BA,EA7BA,KA6BA,EA5BA,aA4BA,EA3BA,SA2BA,EA1BA,oBA0BA,GAAA,QA1B+B,YA2B/B,GA3B8C,QA2B9C,EACA,EA3BA,gBA2BA,EA1BA,MA0BA,EAzBA,mBAyBA,EAxBA,mBAwBA,EAvBA,eAuBA,CAAA;EACA;;;;EAEA,mBAAA,CAAA,qBAAA,MAAA,EAAA,QAAA,CAAA,CAAA,WAAA,EARa,YAQb,CAAA,EAPC,iCAOD,CANA,OAMA,EALA,OAKA,EAJA,KAIA,EAHA,aAGA,EAFA,SAEA,EADA,oBACA,GAAA,QAD+B,YAE/B,GAF8C,QAE9C,GAAA,SAAA,EACA,EAFA,gBAEA,EADA,MACA,EAAA,mBAAA,EACA,mBADA,EAEA,eAFA,CAAA;EACA;;;;;EAwBA,KAAA,CAAA,CAAA,EAHO,kBAGP,CAFA,OAEA,EADA,8BACA,EAAA,KAAA,EACA,aADA,EAEA,SAFA,EAGA,oBAHA,EAIA,gBAJA,EAKA,sBALA,CAKuB,MALvB,CAAA,EAMA,sBANA,CAMuB,MANvB,CAAA,EAOA,sBAPA,EAQA,eARA,CAAA"}

package/dist/browser/durable-hooks.d.ts

@@ -0,0 +1,3 @@
+import "./fragments/internal-fragment.js";
+import "./hooks/hooks.js";
+import { AnyFragnoInstantiatedDatabaseFragment } from "./mod2.js";

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

@@ -0,0 +1,317 @@
+import { DbNow } from "../query/db-now.js";
+import { AnyColumn, AnyRelation, Column, FragnoId, IdColumn, Index, Schema, Table } from "../schema/create.js";
+import { Cursor } from "../query/cursor.js";
+import { RetryPolicy } from "../query/unit-of-work/retry-policy.js";
+import { TxResult } from "../query/unit-of-work/execute-unit-of-work.js";
+import { DatabaseHandlerContext, DatabaseRequestStorage, DatabaseServiceContext, FragnoPublicConfigWithDatabase, ImplicitDatabaseDependencies } from "../db-fragment-definition-builder.js";
+import "./internal-fragment.schema.js";
+import "../mod2.js";
+import * as _fragno_dev_core0 from "@fragno-dev/core";
+import { InstantiatedFragmentFromDefinition } from "@fragno-dev/core";
+
+//#region src/fragments/internal-fragment.d.ts
+type AdapterRegistry = {
+  listSchemas: () => Array<{
+    name: string;
+    namespace: string | null;
+    version: number;
+    tables: string[];
+  }>;
+  listOutboxFragments: () => Array<{
+    name: string;
+    mountRoute: string;
+  }>;
+  isOutboxEnabled: () => boolean;
+  resolveSyncCommand: (fragmentName: string, schemaName: string, commandName: string) => {
+    command: unknown;
+    namespace: string | null;
+  } | undefined;
+};
+type InternalFragmentConfig = {
+  registry?: AdapterRegistry;
+};
+declare const internalFragmentDef: _fragno_dev_core0.FragmentDefinition<InternalFragmentConfig, FragnoPublicConfigWithDatabase, ImplicitDatabaseDependencies<Schema<{
+  fragno_db_settings: Table<Record<"id", IdColumn<"varchar(128)", 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"]>>>;
+  fragno_hooks: Table<Record<"id", IdColumn<"varchar(128)", 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", (DbNow | Date) | null, Date | null>> & Record<"nextRetryAt", Column<"timestamp", (DbNow | Date) | null, Date | null>> & Record<"error", Column<"string", string | null, string | null>> & Record<"createdAt", Column<"timestamp", (DbNow | Date) | null, Date>> & Record<"nonce", Column<"string", string, string>>, Record<string, AnyRelation>, Record<string, Index<AnyColumn[], readonly string[]>> & Record<"idx_namespace_created_at", Index<readonly [Column<"string", string, string>, Column<"timestamp", (DbNow | Date) | null, Date>, IdColumn<"varchar(128)", string | FragnoId | null, FragnoId>] & AnyColumn[], readonly ["namespace", "createdAt", "id"]>>>;
+  fragno_db_outbox: Table<Record<"id", IdColumn<"varchar(128)", string | FragnoId | null, FragnoId>> & Record<"versionstamp", Column<"string", string, string>> & Record<"uowId", Column<"string", string, string>> & Record<"payload", Column<"json", unknown, unknown>> & Record<"refMap", Column<"json", unknown, unknown>> & Record<"createdAt", Column<"timestamp", (DbNow | Date) | null, Date>>, Record<string, AnyRelation>, Record<string, Index<AnyColumn[], readonly string[]>> & Record<"idx_outbox_versionstamp", Index<readonly [Column<"string", string, string>] & AnyColumn[], readonly ["versionstamp"]>> & Record<"idx_outbox_uow", Index<readonly [Column<"string", string, string>] & AnyColumn[], readonly ["uowId"]>>>;
+  fragno_db_outbox_mutations: Table<Record<"id", IdColumn<"varchar(128)", string | FragnoId | null, FragnoId>> & Record<"entryVersionstamp", Column<"string", string, string>> & Record<"mutationVersionstamp", Column<"string", string, string>> & Record<"uowId", Column<"string", string, string>> & Record<"schema", Column<"string", string, string>> & Record<"table", Column<"string", string, string>> & Record<"externalId", Column<"string", string, string>> & Record<"op", Column<"string", string, string>> & Record<"createdAt", Column<"timestamp", (DbNow | Date) | null, Date>>, Record<string, AnyRelation>, Record<string, Index<AnyColumn[], readonly string[]>> & Record<"idx_outbox_mutations_entry", Index<readonly [Column<"string", string, string>] & AnyColumn[], readonly ["entryVersionstamp"]>> & Record<"idx_outbox_mutations_key", Index<readonly [Column<"string", string, string>, Column<"string", string, string>, Column<"string", string, string>, Column<"string", string, string>] & AnyColumn[], readonly ["schema", "table", "externalId", "entryVersionstamp"]>> & Record<"idx_outbox_mutations_uow", Index<readonly [Column<"string", string, string>] & AnyColumn[], readonly ["uowId"]>>>;
+  fragno_db_sync_requests: Table<Record<"id", IdColumn<"varchar(128)", string | FragnoId | null, FragnoId>> & Record<"requestId", Column<"string", string, string>> & Record<"status", Column<"string", string, string>> & Record<"confirmedCommandIds", Column<"json", unknown, unknown>> & Record<"conflictCommandId", Column<"string", string | null, string | null>> & Record<"baseVersionstamp", Column<"string", string | null, string | null>> & Record<"lastVersionstamp", Column<"string", string | null, string | null>> & Record<"createdAt", Column<"timestamp", (DbNow | Date) | null, Date>>, Record<string, AnyRelation>, Record<string, Index<AnyColumn[], readonly string[]>> & Record<"idx_sync_request_id", Index<readonly [Column<"string", string, string>] & AnyColumn[], readonly ["requestId"]>>>;
+}>>, {}, {
+  settingsService: {
+    /**
+     * Get a setting by namespace and key.
+     */
+    get(namespace: string, key: string): TxResult<{
+      id: FragnoId;
+      key: string;
+      value: string;
+    } | undefined, {
+      id: FragnoId;
+      key: string;
+      value: string;
+    } | undefined>;
+    /**
+     * Set a setting value by namespace and key.
+     */
+    set(namespace: string, key: string, value: string): TxResult<void, {
+      id: FragnoId;
+      key: string;
+      value: string;
+    } | null>;
+    /**
+     * Set a setting value only if it does not already exist.
+     */
+    setIfMissing(namespace: string, key: string, value: string): TxResult<void, {
+      id: FragnoId;
+      key: string;
+      value: string;
+    } | null>;
+    /**
+     * Delete a setting by ID.
+     */
+    delete(id: FragnoId): TxResult<void, 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): TxResult<{
+      id: FragnoId;
+      hookName: string;
+      payload: unknown;
+      status: "pending" | "processing" | "completed" | "failed";
+      attempts: number;
+      maxAttempts: number;
+      lastAttemptAt: Date | null;
+      nextRetryAt: Date | null;
+      createdAt: Date;
+      idempotencyKey: string;
+    }[], {
+      id: FragnoId;
+      hookName: string;
+      payload: unknown;
+      status: "pending" | "processing" | "completed" | "failed";
+      attempts: number;
+      maxAttempts: number;
+      lastAttemptAt: Date | null;
+      nextRetryAt: Date | null;
+      createdAt: Date;
+      idempotencyKey: string;
+    }[]>;
+    /**
+     * Claim pending hook events for processing.
+     * Returns ready events and marks them as processing in the same transaction.
+     */
+    claimPendingHookEvents(namespace: string): TxResult<{
+      status: "processing";
+      id: FragnoId;
+      hookName: string;
+      payload: unknown;
+      attempts: number;
+      maxAttempts: number;
+      lastAttemptAt: Date | null;
+      nextRetryAt: Date | null;
+      createdAt: Date;
+      idempotencyKey: string;
+    }[], {
+      id: FragnoId;
+      hookName: string;
+      payload: unknown;
+      status: "pending" | "processing" | "completed" | "failed";
+      attempts: number;
+      maxAttempts: number;
+      lastAttemptAt: Date | null;
+      nextRetryAt: Date | null;
+      createdAt: Date;
+      idempotencyKey: string;
+    }[]>;
+    /**
+     * Claim stale processing hook events for processing.
+     * Returns ready events and marks them as processing in the same transaction.
+     */
+    claimStuckProcessingHookEvents(namespace: string, staleBefore: DbNow): TxResult<{
+      events: {
+        id: FragnoId;
+        hookName: string;
+        payload: unknown;
+        status: "pending" | "processing" | "completed" | "failed";
+        attempts: number;
+        maxAttempts: number;
+        idempotencyKey: string;
+        lastAttemptAt: Date | null;
+        nextRetryAt: Date | null;
+        createdAt: Date;
+      }[];
+      stuckEvents: {
+        id: FragnoId;
+        hookName: string;
+        attempts: number;
+        maxAttempts: number;
+        lastAttemptAt: Date | null;
+        nextRetryAt: Date | null;
+      }[];
+    }, {
+      id: FragnoId;
+      hookName: string;
+      payload: unknown;
+      status: "pending" | "processing" | "completed" | "failed";
+      attempts: number;
+      maxAttempts: number;
+      idempotencyKey: string;
+      lastAttemptAt: Date | null;
+      nextRetryAt: Date | null;
+      createdAt: Date;
+    }[]>;
+    /**
+     * Get the earliest pending hook wake time for a namespace.
+     * Optionally considers processing hooks becoming stale when timeoutMinutes is provided.
+     */
+    getNextHookWakeAt(namespace: string, timeoutMinutes?: number | false): TxResult<Date | null, Date | null>;
+    /**
+     * Mark a hook event as failed and schedule next retry.
+     */
+    markHookFailed(eventId: FragnoId, error: string, attempts: number, retryPolicy: RetryPolicy): TxResult<void, void>;
+    /**
+     * Mark a hook event as processing (to prevent concurrent execution).
+     */
+    markHookProcessing(eventId: FragnoId): TxResult<void, void>;
+    /**
+     * Get a hook event by ID (for testing/verification purposes).
+     */
+    getHookById(eventId: FragnoId): TxResult<{
+      status: "pending" | "processing" | "completed" | "failed";
+      id: FragnoId;
+      namespace: string;
+      hookName: string;
+      payload: unknown;
+      attempts: number;
+      maxAttempts: number;
+      lastAttemptAt: Date | null;
+      nextRetryAt: Date | null;
+      error: string | null;
+      createdAt: Date;
+      nonce: string;
+    } | undefined, {
+      status: "pending" | "processing" | "completed" | "failed";
+      id: FragnoId;
+      namespace: string;
+      hookName: string;
+      payload: unknown;
+      attempts: number;
+      maxAttempts: number;
+      lastAttemptAt: Date | null;
+      nextRetryAt: Date | null;
+      error: string | null;
+      createdAt: Date;
+      nonce: string;
+    } | undefined>;
+    /**
+     * Get hook events for a namespace in newest-first order with pagination.
+     */
+    getHooksByNamespacePage(namespace: string, options?: {
+      cursor?: Cursor | string;
+      pageSize?: number;
+    }): TxResult<{
+      items: {
+        status: "pending" | "processing" | "completed" | "failed";
+        id: FragnoId;
+        namespace: string;
+        hookName: string;
+        payload: unknown;
+        attempts: number;
+        maxAttempts: number;
+        lastAttemptAt: Date | null;
+        nextRetryAt: Date | null;
+        error: string | null;
+        createdAt: Date;
+        nonce: string;
+      }[];
+      cursor: Cursor | undefined;
+      hasNextPage: boolean;
+    }, {
+      items: {
+        status: "pending" | "processing" | "completed" | "failed";
+        id: FragnoId;
+        namespace: string;
+        hookName: string;
+        payload: unknown;
+        attempts: number;
+        maxAttempts: number;
+        lastAttemptAt: Date | null;
+        nextRetryAt: Date | null;
+        error: string | null;
+        createdAt: Date;
+        nonce: string;
+      }[];
+      cursor: Cursor | undefined;
+      hasNextPage: boolean;
+    }>;
+    /**
+     * Get all hook events for a namespace (for testing/verification purposes).
+     */
+    getHooksByNamespace(namespace: string): TxResult<{
+      status: "pending" | "processing" | "completed" | "failed";
+      id: FragnoId;
+      namespace: string;
+      hookName: string;
+      payload: unknown;
+      attempts: number;
+      maxAttempts: number;
+      lastAttemptAt: Date | null;
+      nextRetryAt: Date | null;
+      error: string | null;
+      createdAt: Date;
+      nonce: string;
+    }[], {
+      status: "pending" | "processing" | "completed" | "failed";
+      id: FragnoId;
+      namespace: string;
+      hookName: string;
+      payload: unknown;
+      attempts: number;
+      maxAttempts: number;
+      lastAttemptAt: Date | null;
+      nextRetryAt: Date | null;
+      error: string | null;
+      createdAt: Date;
+      nonce: string;
+    }[]>;
+  };
+} & {
+  outboxService: {
+    /**
+     * List outbox entries ordered by versionstamp (ascending).
+     */
+    list({
+      afterVersionstamp,
+      limit
+    }?: {
+      afterVersionstamp?: string;
+      limit?: number;
+    }): TxResult<{
+      id: FragnoId;
+      versionstamp: string;
+      uowId: string;
+      payload: unknown;
+      refMap: {} | undefined;
+      createdAt: Date;
+    }[], {
+      id: FragnoId;
+      versionstamp: string;
+      uowId: string;
+      payload: unknown;
+      refMap: {} | undefined;
+      createdAt: Date;
+    }[]>;
+  };
+}, {}, {}, DatabaseServiceContext<{}>, DatabaseHandlerContext<{}>, DatabaseRequestStorage, readonly []>;
+/**
+ * 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

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

@@ -0,0 +1 @@
+{"version":3,"file":"internal-fragment.d.ts","names":[],"sources":["../../../src/fragments/internal-fragment.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;KAsBK,eAAA;qBACgB;;;;IADhB,MAAA,EAAA,MAAe,EAAA;EAyCR,CAAA,CAAA;EAiCC,mBAAA,EAAA,GAogBH,GAvkBmB,KAukBnB,CAAA;IApgBsB,IAAA,EAAA,MAAA;IAAA,UAAA,EAAA,MAAA;;;;;;;;KAjCpB,sBAAA;aACC;;cAgCA,uCAAmB,mBAAA,wBAAA,gCAAA;;;;;;;;;;;yCA6BM;UAAR;;;;UAAA;;;;;;;;;;;;;;;;;;;;;;;eA0Db,WAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mEAwG4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2EAmEK,SAAA,aAAA;;;;4BAkG5C,wDAAwD,cAAW;IApWjE;;;IA6BM,kBAAA,CAAA,OAAA,EA+WJ,QA/WI,CAAA,EA+WI,QA/WJ,CAAA,IAAA,EAAA,IAAA,CAAA;;;;yBA4XX;MAlUV,MAAA,EAAA,SAAA,GAAA,YAAA,GAAA,WAAA,GAAA,QAAA;MAAQ,EAAA,UAAA;;;;;;;;;;;;;;;;;;;MAwG4C,aAAA,MAAA,GAAA,IAAA;;;;;;;;;;eAiPzC;;;MA9K8C,KAAA,EAAA;QAAA,MAAA,EAAA,SAAA,GAAA,YAAA,GAAA,WAAA,GAAA,QAAA;QAAA,EAAA,UAAA;QAkG5C,SAAA,EAAA,MAAA;QAAwD,QAAA,EAAA,MAAA;QAAW,OAAA,EAAA,OAAA;QAwC/D,QAAA,EAAA,MAAA;QAAQ,WAAA,EAAA,MAAA;QAaf,aAAA,MAAA,GAAA,IAAA;;;;;;;;;;QAuBC,MAAA,EAAA,SAAA,GAAA,YAAA,GAAA,WAAA,GAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAhbI,MAAA;IAAA,CAAA,EAAA,EAAA;MA0gBpB,MAAA,EAAA,SAAA,GAAwB,YAC3B,GAAA,WAAA,GAAA,QAD8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA3B,wBAAA,GAA2B,0CAC9B"}

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

@@ -0,0 +1 @@
+import "../mod2.js";

package/dist/browser/hooks/durable-hooks-logger.d.ts

@@ -0,0 +1,10 @@
+//#region src/hooks/durable-hooks-logger.d.ts
+
+type DurableHooksLogLevel = "off" | "error" | "warn" | "info" | "debug";
+type DurableHooksLoggerConfig = {
+  enabled?: boolean;
+  level?: DurableHooksLogLevel;
+};
+//#endregion
+export { DurableHooksLoggerConfig };
+//# sourceMappingURL=durable-hooks-logger.d.ts.map

package/dist/browser/hooks/durable-hooks-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-hooks-logger.d.ts","names":[],"sources":["../../../src/hooks/durable-hooks-logger.ts"],"sourcesContent":[],"mappings":";;AAmBY,KAFA,oBAAA,GAEwB,KAAA,GAAA,OAE1B,GAAA,MAAA,GAAA,MAAoB,GAAA,OAAA;KAFlB,wBAAA;;UAEF"}