@fragno-dev/db 0.3.0 → 0.4.1

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"}

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

@@ -0,0 +1,146 @@
+import { DbNow } from "../query/db-now.js";
+import { FragnoId } from "../schema/create.js";
+import { RetryPolicy } from "../query/unit-of-work/retry-policy.js";
+import { ExecuteTxOptions, HandlerTxBuilder } from "../query/unit-of-work/execute-unit-of-work.js";
+import "../fragments/internal-fragment.js";
+import { DurableHooksLoggerConfig } from "./durable-hooks-logger.js";
+import "../query/unit-of-work/unit-of-work.js";
+
+//#region src/hooks/hooks.d.ts
+
+/**
+ * Context available in hook functions via `this`.
+ * Contains the idempotency key for idempotency and database access.
+ */
+interface HookContext {
+  /**
+   * Unique idempotency key for this transaction.
+   * Use this for idempotency checks in your hook implementation.
+   */
+  idempotencyKey: string;
+  /**
+   * Hook event identifier (versioned FragnoId).
+   */
+  hookId: FragnoId;
+  /**
+   * Hook name for this event.
+   */
+  hookName: string;
+  /**
+   * Current status of the hook event.
+   */
+  status: HookStatus;
+  /**
+   * Attempt count for this hook event.
+   */
+  attempts: number;
+  /**
+   * Maximum attempts configured for this hook event.
+   */
+  maxAttempts: number;
+  /**
+   * Timestamp of the last attempt (if any).
+   */
+  lastAttemptAt: Date | null;
+  /**
+   * Next scheduled retry timestamp (if any).
+   */
+  nextRetryAt: Date | null;
+  /**
+   * When the hook event was created.
+   */
+  createdAt: Date;
+  /**
+   * Create a handler transaction builder to run atomic operations.
+   */
+  handlerTx: HookHandlerTx;
+}
+declare const hookStatusValues: readonly ["pending", "processing", "completed", "failed"];
+type HookStatus = (typeof hookStatusValues)[number];
+/**
+ * A hook function signature.
+ * Hooks receive a typed payload and access context via `this`.
+ */
+type HookFn<TPayload = unknown> = (payload: TPayload) => void | Promise<void>;
+/**
+ * Map of hook names to hook functions.
+ * Used for type-safe hook definitions and triggering.
+ */
+type HooksMap = Record<string, HookFn<any>>;
+/**
+ * Extract the payload type from a hook function.
+ */
+type HookPayload<T> = T extends HookFn<infer P> ? P : never;
+/**
+ * Options for triggering a hook.
+ */
+interface TriggerHookOptions {
+  /**
+   * Optional retry policy override for this specific hook trigger.
+   * If not provided, uses the default retry policy.
+   */
+  retryPolicy?: RetryPolicy;
+  /**
+   * Optional hook event ID. When provided, the hook insert will fail if a hook
+   * with the same ID already exists.
+   */
+  id?: string | FragnoId;
+  /**
+   * Absolute time for the first attempt. If in the future, the hook is
+   * scheduled for that time; if in the past, it runs immediately.
+   */
+  processAt?: Date | DbNow;
+}
+/**
+ * Internal representation of a triggered hook.
+ * Stored in the Unit of Work before execution.
+ */
+interface TriggeredHook {
+  namespace: string;
+  hookName: string;
+  payload: unknown;
+  options?: TriggerHookOptions;
+}
+type StuckHookProcessingTimeoutMinutes = number | false;
+type StuckHookProcessingEvent = {
+  id: FragnoId;
+  hookName: string;
+  attempts: number;
+  maxAttempts: number;
+  lastAttemptAt: Date | null;
+  nextRetryAt: Date | null;
+};
+type StuckHookProcessingInfo = {
+  namespace: string;
+  timeoutMinutes: number;
+  events: StuckHookProcessingEvent[];
+};
+type DurableHooksProcessingOptions = {
+  /**
+   * Re-queue hooks that have been in `processing` for at least this many minutes.
+   * Use `false` to disable stuck-processing recovery entirely.
+   * Values <= 0 are treated as `false`.
+   *
+   * Default: 10 minutes.
+   */
+  stuckProcessingTimeoutMinutes?: StuckHookProcessingTimeoutMinutes;
+  /**
+   * Automatically schedule hook processing after successful mutations.
+   * Defaults to true. Set false to disable auto scheduling (manual drain only).
+   */
+  autoSchedule?: boolean;
+  /**
+   * Called when stuck processing hooks are detected and re-queued.
+   * Invoked after the hooks are moved back to `pending`.
+   */
+  onStuckProcessingHooks?: (info: StuckHookProcessingInfo) => void;
+  /**
+   * Durable hooks logging controls.
+   * Defaults: enabled=true, level="warn".
+   */
+  logging?: DurableHooksLoggerConfig;
+};
+type HookHandlerTx = (execOptions?: Omit<ExecuteTxOptions, "createUnitOfWork">) => HandlerTxBuilder<readonly [], [], [], unknown, unknown, false, false, false, false, HooksMap>;
+//#endregion
+export { DurableHooksProcessingOptions, HookContext, HookFn, HookHandlerTx, HookPayload, HooksMap, StuckHookProcessingEvent, StuckHookProcessingInfo, StuckHookProcessingTimeoutMinutes, TriggerHookOptions, TriggeredHook };
+//# sourceMappingURL=hooks.d.ts.map

package/dist/browser/hooks/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","names":[],"sources":["../../../src/hooks/hooks.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;AAgBA;;AAiBU,UAjBO,WAAA,CAiBP;EAYO;;;;EAYS,cAAA,EAAA,MAAA;EAGb;AAEb;AAgBA;EAOY,MAAA,EA5DF,QA4DU;EAKR;;;EAA6C,QAAA,EAAA,MAAA;EAAC;AAK1D;;EAUgB,MAAA,EAxEN,UAwEM;EAKF;;;EAOG,QAAA,EAAA,MAAa;EAyElB;AAEZ;;EAKiB,WAAA,EAAA,MAAA;EACF;;AAGf;EAMY,aAAA,EAlKK,IAkKL,GAAA,IAAA;EAQsB;;;EAeE,WAAA,EArLrB,IAqLqB,GAAA,IAAA;EAGxB;;;EAE6E,SAAA,EAtL5E,IAsL4E;EAApF;;;aAlLQ;;cAGA;KAED,UAAA,WAAqB;;;;;KAgBrB,uCAAuC,oBAAoB;;;;;KAO3D,QAAA,GAAW,eAAe;;;;KAK1B,iBAAiB,UAAU,kBAAkB;;;;UAKxC,kBAAA;;;;;gBAKD;;;;;gBAKA;;;;;cAKF,OAAO;;;;;;UAOJ,aAAA;;;;YAIL;;KAqEA,iCAAA;KAEA,wBAAA;MACN;;;;iBAIW;eACF;;KAGH,uBAAA;;;UAGF;;KAGE,6BAAA;;;;;;;;kCAQsB;;;;;;;;;;kCAUA;;;;;YAKtB;;KAGA,aAAA,kBACI,KAAK,0CAChB,oFAAoF"}

package/dist/browser/id.js

@@ -0,0 +1 @@
+import "@fragno-dev/core";

package/dist/browser/internal/adapter-registry.d.ts

@@ -0,0 +1,4 @@
+import "../sync/types.js";
+import "../fragments/internal-fragment.js";
+import "../adapters/adapters.js";
+import "./outbox-state.js";

package/dist/browser/internal/outbox-state.d.ts

@@ -0,0 +1,2 @@
+import "../outbox/outbox.js";
+import "../adapters/adapters.js";

package/dist/browser/mod.d.ts

@@ -0,0 +1,15 @@
+import { DbInterval, DbIntervalInput, DbNow, dbInterval, dbNow } from "./query/db-now.js";
+import { Cursor, CursorData, CursorResult, createCursorFromRecord, decodeCursor } from "./query/cursor.js";
+import { BuilderTransformContextWithMutate, BuilderTransformContextWithoutMutate, ExtractServiceFinalResults, ExtractServiceRetrieveResults, HandlerBuilderMutateContext, HandlerTxBuilder, ServiceBuilderMutateContext, ServiceTxBuilder, TxResult, createHandlerTxBuilder, createServiceTxBuilder } from "./query/unit-of-work/execute-unit-of-work.js";
+import { SubmitAppliedResponse, SubmitConflictReason, SubmitConflictResponse, SubmitRequest, SubmitResponse, SyncCommandDefinition, SyncCommandHandler, SyncCommandRegistry, SyncCommandTxFactory } from "./sync/types.js";
+import { IUnitOfWork, IUnitOfWorkRestricted, TypedUnitOfWork, UOWCompiler, UOWDecoder, UOWExecutor, UnitOfWork, createUnitOfWork } from "./query/unit-of-work/unit-of-work.js";
+import { withDatabase as withDatabase$1 } from "./with-database.js";
+import { defineSyncCommands } from "./sync/commands.js";
+import { migrate as migrate$1 } from "./mod2.js";
+
+//#region src/browser/mod.d.ts
+declare const withDatabase: typeof withDatabase$1;
+declare const migrate: typeof migrate$1;
+//#endregion
+export { type BuilderTransformContextWithMutate, type BuilderTransformContextWithoutMutate, Cursor, type CursorData, type CursorResult, type DbInterval, type DbIntervalInput, type DbNow, type ExtractServiceFinalResults, type ExtractServiceRetrieveResults, type HandlerBuilderMutateContext, HandlerTxBuilder, type IUnitOfWork, type IUnitOfWorkRestricted, type ServiceBuilderMutateContext, ServiceTxBuilder, type SubmitAppliedResponse, type SubmitConflictReason, type SubmitConflictResponse, type SubmitRequest, type SubmitResponse, type SyncCommandDefinition, type SyncCommandHandler, type SyncCommandRegistry, type SyncCommandTxFactory, type TxResult, TypedUnitOfWork, type UOWCompiler, type UOWDecoder, type UOWExecutor, UnitOfWork, createCursorFromRecord, createHandlerTxBuilder, createServiceTxBuilder, createUnitOfWork, dbInterval, dbNow, decodeCursor, defineSyncCommands, migrate, withDatabase };
+//# sourceMappingURL=mod.d.ts.map

package/dist/browser/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","names":[],"sources":["../../src/browser/mod.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;cA4Ca,qBAAqB;cAIrB,gBAAgB"}

package/dist/browser/mod.js

@@ -0,0 +1,17 @@
+import { HandlerTxBuilder, ServiceTxBuilder, createHandlerTxBuilder, createServiceTxBuilder } from "./query/unit-of-work/execute-unit-of-work.js";
+import { dbInterval, dbNow } from "./query/db-now.js";
+import { Cursor, createCursorFromRecord, decodeCursor } from "./query/cursor.js";
+import { TypedUnitOfWork, UnitOfWork, createUnitOfWork } from "./query/unit-of-work/unit-of-work.js";
+import { defineSyncCommands } from "./sync/commands.js";
+
+//#region src/browser/mod.ts
+const withDatabase = () => {
+	throw new Error("withDatabase is not available in browser builds.");
+};
+const migrate = async () => {
+	throw new Error("migrate is not available in browser builds.");
+};
+
+//#endregion
+export { Cursor, HandlerTxBuilder, ServiceTxBuilder, TypedUnitOfWork, UnitOfWork, createCursorFromRecord, createHandlerTxBuilder, createServiceTxBuilder, createUnitOfWork, dbInterval, dbNow, decodeCursor, defineSyncCommands, migrate, withDatabase };
+//# sourceMappingURL=mod.js.map

package/dist/browser/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","names":["withDatabase: typeof withDatabaseType","migrate: typeof migrateType"],"sources":["../../src/browser/mod.ts"],"sourcesContent":["import type { migrate as migrateType } from \"../mod\";\nimport type { withDatabase as withDatabaseType } from \"../with-database\";\n\nexport {\n  createHandlerTxBuilder,\n  createServiceTxBuilder,\n  ServiceTxBuilder,\n  HandlerTxBuilder,\n  type TxResult,\n  type ServiceBuilderMutateContext,\n  type HandlerBuilderMutateContext,\n  type BuilderTransformContextWithMutate,\n  type BuilderTransformContextWithoutMutate,\n  type ExtractServiceRetrieveResults,\n  type ExtractServiceFinalResults,\n} from \"../query/unit-of-work/execute-unit-of-work\";\n\nexport {\n  createUnitOfWork,\n  UnitOfWork,\n  TypedUnitOfWork,\n  type IUnitOfWork,\n  type IUnitOfWorkRestricted,\n  type UOWCompiler,\n  type UOWExecutor,\n  type UOWDecoder,\n} from \"../query/unit-of-work/unit-of-work\";\n\nexport {\n  Cursor,\n  decodeCursor,\n  createCursorFromRecord,\n  type CursorData,\n  type CursorResult,\n} from \"../query/cursor\";\n\nexport {\n  dbNow,\n  dbInterval,\n  type DbNow,\n  type DbInterval,\n  type DbIntervalInput,\n} from \"../query/db-now\";\n\nexport const withDatabase: typeof withDatabaseType = () => {\n  throw new Error(\"withDatabase is not available in browser builds.\");\n};\n\nexport const migrate: typeof migrateType = async () => {\n  throw new Error(\"migrate is not available in browser builds.\");\n};\n\nexport { defineSyncCommands } from \"../sync/commands\";\nexport type {\n  SubmitAppliedResponse,\n  SubmitConflictReason,\n  SubmitConflictResponse,\n  SubmitRequest,\n  SubmitResponse,\n  SyncCommandDefinition,\n  SyncCommandHandler,\n  SyncCommandRegistry,\n  SyncCommandTxFactory,\n} from \"../sync/types\";\n"],"mappings":";;;;;;;AA4CA,MAAaA,qBAA8C;AACzD,OAAM,IAAI,MAAM,mDAAmD;;AAGrE,MAAaC,UAA8B,YAAY;AACrD,OAAM,IAAI,MAAM,8CAA8C"}

package/dist/browser/mod2.d.ts

@@ -0,0 +1,48 @@
+import { DbInterval, DbIntervalInput, DbNow, dbInterval, dbNow } from "./query/db-now.js";
+import { AnySchema } from "./schema/create.js";
+import { Cursor, CursorData, CursorResult, decodeCursor } from "./query/cursor.js";
+import { RetryPolicy } from "./query/unit-of-work/retry-policy.js";
+import { BuilderTransformContextWithMutate, BuilderTransformContextWithoutMutate, ExtractServiceFinalResults, ExtractServiceRetrieveResults, HandlerBuilderMutateContext, HandlerTxBuilder, ServiceBuilderMutateContext, ServiceTxBuilder, TxResult, createHandlerTxBuilder, createServiceTxBuilder } from "./query/unit-of-work/execute-unit-of-work.js";
+import { OutboxEntry, OutboxRefMap } from "./outbox/outbox.js";
+import { SubmitAppliedResponse, SubmitConflictReason, SubmitConflictResponse, SubmitRequest, SubmitResponse, SyncCommandDefinition, SyncCommandHandler, SyncCommandRegistry, SyncCommandTxFactory } from "./sync/types.js";
+import { DatabaseFragmentDefinitionBuilder, DatabaseHandlerContext, DatabaseServiceContext, DbRoundtripGuardConfig, FragnoPublicConfigWithDatabase, ImplicitDatabaseDependencies } from "./db-fragment-definition-builder.js";
+import { InternalFragmentInstance, internalFragmentDef } from "./fragments/internal-fragment.js";
+import { DurableHooksProcessingOptions, HookContext, HookFn, HookHandlerTx, HookPayload, HooksMap, StuckHookProcessingEvent, StuckHookProcessingInfo, StuckHookProcessingTimeoutMinutes, TriggerHookOptions } from "./hooks/hooks.js";
+import { IUnitOfWork, IUnitOfWorkRestricted, TypedUnitOfWork, UOWCompiler, UOWDecoder, UOWExecutor, UnitOfWork, createUnitOfWork } from "./query/unit-of-work/unit-of-work.js";
+import { DatabaseAdapter } from "./adapters/adapters.js";
+import "./adapters/in-memory/index.js";
+import "./internal/adapter-registry.js";
+import { withDatabase } from "./with-database.js";
+import { defineSyncCommands } from "./sync/commands.js";
+import "./durable-hooks.js";
+import { FragnoInstantiatedFragment } from "@fragno-dev/core";
+
+//#region src/mod.d.ts
+
+type AnyFragnoInstantiatedDatabaseFragment<TSchema extends AnySchema = AnySchema> = FragnoInstantiatedFragment<any, ImplicitDatabaseDependencies<TSchema>, any, any, DatabaseHandlerContext, any, FragnoPublicConfigWithDatabase>;
+/**
+ * Helper function to run migrations for a database fragment.
+ * Extracts the database adapter, schema, and namespace from the fragment and runs migrations.
+ * This function:
+ * 1. Ensures the internal settings fragment is migrated first
+ * 2. Retrieves the current database version from the internal fragment
+ * 3. Runs migration from current version to target version
+ *
+ * @param fragment - The instantiated fragment to run migrations for
+ * @throws Error if the fragment doesn't have database support or the adapter doesn't support migrations
+ *
+ * @example
+ * ```typescript
+ * const fragment = instantiate(myFragmentDef)
+ *   .withConfig({})
+ *   .withRoutes([])
+ *   .withOptions({ databaseAdapter: myAdapter })
+ *   .build();
+ *
+ * await migrate(fragment);
+ * ```
+ */
+declare function migrate<TSchema extends AnySchema>(fragment: AnyFragnoInstantiatedDatabaseFragment<TSchema>): Promise<void>;
+//#endregion
+export { AnyFragnoInstantiatedDatabaseFragment, migrate };
+//# sourceMappingURL=mod2.d.ts.map

package/dist/browser/mod2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod2.d.ts","names":[],"sources":["../../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;KAuLY,sDAAsD,YAAY,aAC5E,gCAGE,6BAA6B,oBAK7B,6BAGA;;;;;;;;;;;;;;;;;;;;;;;iBAyBkB,wBAAwB,qBAClC,sCAAsC,WAC/C"}

package/dist/browser/naming/sql-naming.d.ts

@@ -0,0 +1,19 @@
+//#region src/naming/sql-naming.d.ts
+type NamespaceScope = "suffix" | "schema";
+interface SqlNamingStrategy {
+  namespaceScope: NamespaceScope;
+  namespaceToSchema: (namespace: string) => string;
+  tableName: (logicalTable: string, namespace: string | null) => string;
+  columnName: (logicalColumn: string, logicalTable: string) => string;
+  indexName: (logicalIndex: string, logicalTable: string, namespace: string | null) => string;
+  uniqueIndexName: (logicalIndex: string, logicalTable: string, namespace: string | null) => string;
+  foreignKeyName: (params: {
+    logicalTable: string;
+    logicalReferencedTable: string;
+    referenceName: string;
+    namespace: string | null;
+  }) => string;
+}
+//#endregion
+export { SqlNamingStrategy };
+//# sourceMappingURL=sql-naming.d.ts.map

package/dist/browser/naming/sql-naming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-naming.d.ts","names":[],"sources":["../../../src/naming/sql-naming.ts"],"sourcesContent":[],"mappings":";AAIY,KAAA,cAAA,GAAc,QAAA,GAAA,QAAA;AAET,UAAA,iBAAA,CAAiB;kBAChB"}

package/dist/browser/outbox/outbox.d.ts

@@ -0,0 +1,21 @@
+import { FragnoId } from "../schema/create.js";
+import "../query/unit-of-work/unit-of-work.js";
+
+//#region src/outbox/outbox.d.ts
+
+type OutboxRefMap = Record<string, string>;
+type OutboxPayloadSerialized = {
+  json: unknown;
+  meta?: Record<string, unknown>;
+};
+type OutboxEntry = {
+  id: FragnoId;
+  versionstamp: string;
+  uowId: string;
+  payload: OutboxPayloadSerialized;
+  refMap?: OutboxRefMap;
+  createdAt: Date;
+};
+//#endregion
+export { OutboxEntry, OutboxRefMap };
+//# sourceMappingURL=outbox.d.ts.map

package/dist/browser/outbox/outbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.d.ts","names":[],"sources":["../../../src/outbox/outbox.ts"],"sourcesContent":[],"mappings":";;;;;KAgDY,YAAA,GAAe;KAEf,uBAAA;;SAEH;;KAGG,WAAA;MACN;;;WAGK;WACA;aACE"}

package/dist/browser/query/column-defaults.js

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