@procedures/store 0.0.0-stage → 0.1.0

package/dist/storage/factory.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Procedure Storage Factory
+ *
+ * Factory functions for creating storage-backed procedure registries.
+ */
+import type { Client } from "@procedures/client";
+import type { CollectionStorage } from "@procedures/collections";
+import type { HybridStorageOptions } from "./hybrid.js";
+import { ProcedureRegistry } from "@procedures/client";
+import type { SerializedProcedure, SyncedRegistryOptions, HandlerLoader } from "./types.js";
+import { SyncedProcedureRegistry } from "./synced-registry.js";
+/**
+ * Configuration for creating a synced procedure registry.
+ */
+export interface CreateSyncedRegistryConfig {
+    /**
+     * Storage type to use.
+     * - "memory": In-memory only (fast, volatile)
+     * - "api": Remote storage via client procedures
+     * - "hybrid": Local cache + remote sync
+     */
+    type: "memory" | "api" | "hybrid";
+    /**
+     * Universal client instance (required for "api" and "hybrid" types).
+     */
+    client?: Client | undefined;
+    /**
+     * The collection of the core collection procedures on the server: the calls go to
+     * `collections.<collection>.<operation>`.
+     * @default "procedures"
+     */
+    collection?: string | undefined;
+    /**
+     * The service of the calls, for a server with other paths. The default is
+     * `collections.<collection>`.
+     */
+    service?: string | undefined;
+    /**
+     * Additional options for hybrid storage.
+     */
+    hybridOptions?: Partial<HybridStorageOptions> | undefined;
+    /**
+     * Options for the synced registry.
+     */
+    registryOptions?: Partial<SyncedRegistryOptions> | undefined;
+    /**
+     * Base registry to wrap.
+     * @default PROCEDURE_REGISTRY (global singleton)
+     */
+    baseRegistry?: ProcedureRegistry | undefined;
+    /**
+     * Custom handler loader.
+     * @default Dynamic import loader
+     */
+    handlerLoader?: HandlerLoader | undefined;
+}
+/**
+ * Create a synced procedure registry with the specified storage backend.
+ *
+ * @param config - Configuration for the registry
+ * @returns SyncedProcedureRegistry instance
+ *
+ * @example
+ * ```typescript
+ * // In-memory only (for testing)
+ * const registry = createSyncedRegistry({ type: 'memory' });
+ *
+ * // API storage (remote persistence)
+ * const registry = createSyncedRegistry({
+ *   type: 'api',
+ *   client: myClient,
+ *   service: 'procedures',
+ * });
+ *
+ * // Hybrid storage (offline-first)
+ * const registry = createSyncedRegistry({
+ *   type: 'hybrid',
+ *   client: myClient,
+ *   service: 'procedures',
+ *   hybridOptions: {
+ *     writeStrategy: 'write-through',
+ *     conflictResolution: 'remote',
+ *   },
+ * });
+ * ```
+ */
+export declare function createSyncedRegistry(config: CreateSyncedRegistryConfig): SyncedProcedureRegistry;
+/**
+ * Create an in-memory synced registry.
+ * Useful for testing or when persistence isn't needed.
+ *
+ * @param baseRegistry - Base registry to wrap
+ * @returns SyncedProcedureRegistry with in-memory storage
+ */
+export declare function createMemorySyncedRegistry(baseRegistry?: ProcedureRegistry): SyncedProcedureRegistry;
+/**
+ * Create an API-backed synced registry.
+ *
+ * @param client - Universal client instance
+ * @param collection - The collection of the core collection procedures on the server
+ * @param baseRegistry - Base registry to wrap
+ * @returns SyncedProcedureRegistry with API storage
+ */
+export declare function createApiSyncedRegistry(client: Client, collection?: string, baseRegistry?: ProcedureRegistry): SyncedProcedureRegistry;
+/**
+ * Create a hybrid synced registry (offline-first).
+ *
+ * @param client - Universal client instance
+ * @param collection - The collection of the core collection procedures on the server
+ * @param options - Hybrid storage options
+ * @param baseRegistry - Base registry to wrap
+ * @returns SyncedProcedureRegistry with hybrid storage
+ */
+export declare function createHybridSyncedRegistry(client: Client, collection?: string, options?: Partial<HybridStorageOptions>, baseRegistry?: ProcedureRegistry): SyncedProcedureRegistry;
+/**
+ * Create a synced registry with a custom storage backend.
+ *
+ * @param storage - Custom CollectionStorage implementation
+ * @param options - Registry options
+ * @param baseRegistry - Base registry to wrap
+ * @returns SyncedProcedureRegistry with custom storage
+ *
+ * @example
+ * ```typescript
+ * // Use MongoDB storage
+ * const mongoStorage = new MongoCollectionStorage<SerializedProcedure>(
+ *   mongoClient,
+ *   'procedures'
+ * );
+ * const registry = createCustomSyncedRegistry(mongoStorage);
+ * ```
+ */
+export declare function createCustomSyncedRegistry(storage: CollectionStorage<SerializedProcedure>, options?: Partial<SyncedRegistryOptions>, baseRegistry?: ProcedureRegistry): SyncedProcedureRegistry;
+//# sourceMappingURL=factory.d.ts.map

package/dist/storage/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/storage/factory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAIjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAsB,MAAM,oBAAoB,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5F,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAO/D;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,IAAI,EAAE,QAAQ,GAAG,KAAK,GAAG,QAAQ,CAAC;IAElC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEhC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7B;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,SAAS,CAAC;IAE1D;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG,SAAS,CAAC;IAE7D;;;OAGG;IACH,YAAY,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAE7C;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;CAC3C;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,0BAA0B,GAAG,uBAAuB,CA6DhG;AAMD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,YAAY,GAAE,iBAAsC,GACnD,uBAAuB,CAKzB;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,UAAU,SAAe,EACzB,YAAY,GAAE,iBAAsC,GACnD,uBAAuB,CAOzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,UAAU,SAAe,EACzB,OAAO,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,EACvC,YAAY,GAAE,iBAAsC,GACnD,uBAAuB,CAQzB;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,EAC/C,OAAO,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,EACxC,YAAY,GAAE,iBAAsC,GACnD,uBAAuB,CAKzB"}

package/dist/storage/factory.js

@@ -0,0 +1,166 @@
+/**
+ * Procedure Storage Factory
+ *
+ * Factory functions for creating storage-backed procedure registries.
+ */
+import { InMemoryStorage } from "@procedures/collections";
+import { ApiStorage } from "./api.js";
+import { HybridStorage } from "./hybrid.js";
+import { ProcedureRegistry, PROCEDURE_REGISTRY } from "@procedures/client";
+import { SyncedProcedureRegistry } from "./synced-registry.js";
+import { getSerializedKey } from "./serialization.js";
+// =============================================================================
+// Factory Function
+// =============================================================================
+/**
+ * Create a synced procedure registry with the specified storage backend.
+ *
+ * @param config - Configuration for the registry
+ * @returns SyncedProcedureRegistry instance
+ *
+ * @example
+ * ```typescript
+ * // In-memory only (for testing)
+ * const registry = createSyncedRegistry({ type: 'memory' });
+ *
+ * // API storage (remote persistence)
+ * const registry = createSyncedRegistry({
+ *   type: 'api',
+ *   client: myClient,
+ *   service: 'procedures',
+ * });
+ *
+ * // Hybrid storage (offline-first)
+ * const registry = createSyncedRegistry({
+ *   type: 'hybrid',
+ *   client: myClient,
+ *   service: 'procedures',
+ *   hybridOptions: {
+ *     writeStrategy: 'write-through',
+ *     conflictResolution: 'remote',
+ *   },
+ * });
+ * ```
+ */
+export function createSyncedRegistry(config) {
+    const { type, client, collection = "procedures", service, hybridOptions, registryOptions = {}, baseRegistry = PROCEDURE_REGISTRY, 
+    // No loader unless the caller gives one: stored records load as stubs. (Before, the default
+    // imported any module a stored record named: BUGS-2026-07 M11, deep dive CORE-7.)
+    handlerLoader, } = config;
+    // Validate client is provided for api/hybrid
+    if ((type === "api" || type === "hybrid") && !client) {
+        throw new Error(`Client is required for storage type: ${type}`);
+    }
+    // Create the appropriate storage backend
+    let storage;
+    switch (type) {
+        case "memory":
+            storage = new InMemoryStorage();
+            break;
+        case "api":
+            storage = new ApiStorage(client, {
+                collection,
+                ...(service !== undefined && { service }),
+            });
+            break;
+        case "hybrid": {
+            const remoteStorage = new ApiStorage(client, {
+                collection,
+                ...(service !== undefined && { service }),
+            });
+            storage = new HybridStorage(remoteStorage, {
+                writeStrategy: hybridOptions?.writeStrategy ?? "write-through",
+                conflictResolution: hybridOptions?.conflictResolution ?? "local",
+                // A procedure record has no id: its key is its path (deep dive DATA-9)
+                keyOf: getSerializedKey,
+                ...hybridOptions,
+            });
+            break;
+        }
+        default:
+            throw new Error(`Unknown storage type: ${type}`);
+    }
+    // Create and return the synced registry
+    return new SyncedProcedureRegistry(baseRegistry, storage, {
+        ...registryOptions,
+        handlerLoader,
+    });
+}
+// =============================================================================
+// Convenience Functions
+// =============================================================================
+/**
+ * Create an in-memory synced registry.
+ * Useful for testing or when persistence isn't needed.
+ *
+ * @param baseRegistry - Base registry to wrap
+ * @returns SyncedProcedureRegistry with in-memory storage
+ */
+export function createMemorySyncedRegistry(baseRegistry = PROCEDURE_REGISTRY) {
+    return createSyncedRegistry({
+        type: "memory",
+        baseRegistry,
+    });
+}
+/**
+ * Create an API-backed synced registry.
+ *
+ * @param client - Universal client instance
+ * @param collection - The collection of the core collection procedures on the server
+ * @param baseRegistry - Base registry to wrap
+ * @returns SyncedProcedureRegistry with API storage
+ */
+export function createApiSyncedRegistry(client, collection = "procedures", baseRegistry = PROCEDURE_REGISTRY) {
+    return createSyncedRegistry({
+        type: "api",
+        client,
+        collection,
+        baseRegistry,
+    });
+}
+/**
+ * Create a hybrid synced registry (offline-first).
+ *
+ * @param client - Universal client instance
+ * @param collection - The collection of the core collection procedures on the server
+ * @param options - Hybrid storage options
+ * @param baseRegistry - Base registry to wrap
+ * @returns SyncedProcedureRegistry with hybrid storage
+ */
+export function createHybridSyncedRegistry(client, collection = "procedures", options, baseRegistry = PROCEDURE_REGISTRY) {
+    return createSyncedRegistry({
+        type: "hybrid",
+        client,
+        collection,
+        hybridOptions: options,
+        baseRegistry,
+    });
+}
+// =============================================================================
+// Custom Storage Factory
+// =============================================================================
+/**
+ * Create a synced registry with a custom storage backend.
+ *
+ * @param storage - Custom CollectionStorage implementation
+ * @param options - Registry options
+ * @param baseRegistry - Base registry to wrap
+ * @returns SyncedProcedureRegistry with custom storage
+ *
+ * @example
+ * ```typescript
+ * // Use MongoDB storage
+ * const mongoStorage = new MongoCollectionStorage<SerializedProcedure>(
+ *   mongoClient,
+ *   'procedures'
+ * );
+ * const registry = createCustomSyncedRegistry(mongoStorage);
+ * ```
+ */
+export function createCustomSyncedRegistry(storage, options, baseRegistry = PROCEDURE_REGISTRY) {
+    // No default loader: see createSyncedRegistry
+    return new SyncedProcedureRegistry(baseRegistry, storage, {
+        ...options,
+    });
+}
+//# sourceMappingURL=factory.js.map

package/dist/storage/factory.js.map

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

package/dist/storage/hybrid.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Hybrid Storage Implementation
+ *
+ * Combines local cache (InMemoryStorage) with remote persistence (ApiStorage).
+ * Provides fast local reads with remote backup and sync.
+ *
+ * Features:
+ * - Local cache for fast reads, with a remote read on a miss
+ * - Write-through or write-back strategies
+ * - Automatic sync on initialization
+ * - Conflict resolution
+ * - Offline operation queue
+ */
+import type { CollectionStorage, StorageMetadata } from "@procedures/collections";
+/**
+ * Conflict resolution strategy.
+ */
+export type ConflictResolution = "local" | "remote" | "merge" | "error";
+/**
+ * Write strategy for hybrid storage.
+ */
+export type WriteStrategy = "write-through" | "write-back";
+/**
+ * Hybrid storage configuration options.
+ */
+export interface HybridStorageOptions {
+    /**
+     * Write strategy
+     * - write-through: Write to both local and remote immediately
+     * - write-back: Write to local immediately, sync to remote later
+     * @default "write-through"
+     */
+    writeStrategy?: WriteStrategy;
+    /**
+     * Conflict resolution strategy
+     * - local: Local changes win
+     * - remote: Remote changes win
+     * - merge: Custom merge function (requires mergeFn)
+     * - error: Throw error on conflict
+     * @default "remote"
+     */
+    conflictResolution?: ConflictResolution;
+    /**
+     * Custom merge function for conflict resolution.
+     * Only used when conflictResolution is "merge".
+     *
+     * @param local - Local version
+     * @param remote - Remote version
+     * @returns Merged value
+     */
+    mergeFn?: <T>(local: T, remote: T) => T;
+    /**
+     * The key of a remote item, for the local cache. The default reads a string `id` field. Give
+     * a function for items with another key, for example `getSerializedKey` for procedure records.
+     */
+    keyOf?: (item: any) => string | undefined;
+    /**
+     * Automatic sync interval in milliseconds (for write-back mode).
+     * Set to 0 to disable automatic sync.
+     * @default 5000 (5 seconds)
+     */
+    syncInterval?: number;
+    /**
+     * Initialize by syncing from remote on construction.
+     * @default true
+     */
+    syncOnInit?: boolean;
+    /**
+     * Maximum offline operations to queue.
+     * @default 1000
+     */
+    maxOfflineOps?: number;
+    /**
+     * Enable offline operation queue.
+     * When remote is unavailable, operations are queued and retried.
+     * @default true
+     */
+    offlineQueue?: boolean;
+}
+/**
+ * Hybrid storage combining local cache with remote persistence.
+ *
+ * @example
+ * ```typescript
+ * const client = new Client({
+ *   transport: new HttpTransport({ baseUrl: "https://api.example.com" })
+ * });
+ *
+ * const remote = new ApiStorage(client, { collection: "users" });
+ * const hybrid = new HybridStorage(remote, {
+ *   writeStrategy: "write-through",
+ *   conflictResolution: "remote",
+ *   syncInterval: 5000
+ * });
+ *
+ * // Fast local reads
+ * const user = await hybrid.get("123"); // From cache, or from the remote on a miss
+ *
+ * // Writes go to both local and remote
+ * await hybrid.set("123", { name: "John" });
+ * ```
+ */
+export declare class HybridStorage<T> implements CollectionStorage<T> {
+    private local;
+    private remote;
+    private options;
+    private offlineOps;
+    private syncTimer;
+    private isOnline;
+    /** A counter of local writes for each id, so a sync does not restore an older remote value */
+    private readonly writeVersions;
+    private clearVersion;
+    /** The running sync: syncs run one at a time */
+    private syncChain;
+    private stats;
+    constructor(remote: CollectionStorage<T>, options?: HybridStorageOptions);
+    /**
+     * The local item, or else the remote item (which the cache then keeps). When the remote
+     * cannot answer, the storage is offline and the result is undefined.
+     */
+    get(id: string): Promise<T | undefined>;
+    getAll(): Promise<T[]>;
+    find(predicate: (item: T) => boolean): Promise<T[]>;
+    has(id: string): Promise<boolean>;
+    size(): Promise<number>;
+    set(id: string, value: T): Promise<void>;
+    delete(id: string): Promise<boolean>;
+    clear(): Promise<void>;
+    setBatch(items: Array<[string, T]>): Promise<void>;
+    deleteBatch(ids: string[]): Promise<number>;
+    getBatch(ids: string[]): Promise<Map<string, T>>;
+    /**
+     * Sync all data from remote to local.
+     * Handles conflicts according to conflict resolution strategy.
+     *
+     * - Each remote item goes into the cache under `keyOf(item)`.
+     * - A local item that the remote does not have is removed, unless a queued local operation
+     *   changes it (the remote deleted it).
+     * - An id that a local write changed during the sync keeps the local value: the remote value
+     *   is older.
+     * - Syncs run one at a time.
+     */
+    syncFromRemote(): Promise<void>;
+    /**
+     * Sync all pending offline operations to remote.
+     * Processes queued operations in order. When one fails, it and the later operations stay in
+     * the queue: the operations that reached the remote are not sent again.
+     */
+    syncToRemote(): Promise<void>;
+    /**
+     * Force a full sync (both directions).
+     */
+    sync(): Promise<void>;
+    close(): Promise<void>;
+    getMetadata(): Promise<StorageMetadata>;
+    private pullRemote;
+    private pushQueue;
+    /** Run syncs one at a time. */
+    private serialize;
+    private localIds;
+    private bump;
+    private versionOf;
+    private hasPendingOp;
+    /**
+     * Resolve conflict between local and remote versions.
+     */
+    private resolveConflict;
+    /**
+     * Queue operation for later sync.
+     */
+    private queueOperation;
+    /**
+     * Execute a queued operation against remote storage.
+     */
+    private executeOperation;
+    /**
+     * Handle remote operation failure.
+     */
+    private handleRemoteFailure;
+    /**
+     * Start periodic background sync.
+     */
+    private startPeriodicSync;
+    /**
+     * Get current online status.
+     */
+    isRemoteOnline(): boolean;
+    /**
+     * Get pending offline operations count.
+     */
+    getPendingOpsCount(): number;
+}
+//# sourceMappingURL=hybrid.d.ts.map

package/dist/storage/hybrid.d.ts.map

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