@decaf-ts/for-fabric 0.0.2

package/lib/esm/client/FabricClientDispatch.d.ts

@@ -0,0 +1,125 @@
+import { Dispatch } from "@decaf-ts/core";
+import { Client } from "@grpc/grpc-js";
+import { FabricClientAdapter } from "./FabricClientAdapter";
+/**
+ * @description Event dispatcher for Hyperledger Fabric chaincode events
+ * @summary Listens for and processes events emitted by Fabric chaincode, dispatching them to registered observers
+ * @template PeerConfig - Configuration type for connecting to a Fabric peer
+ * @param client - gRPC client for connecting to the Fabric network
+ * @class FabricClientDispatch
+ * @example
+ * ```typescript
+ * // Create a new FabricDispatch instance
+ * const client = await FabricAdapter.getClient(peerConfig);
+ * const dispatch = new FabricDispatch(client);
+ *
+ * // Configure the dispatch with peer configuration
+ * dispatch.configure(peerConfig);
+ *
+ * // Register an observer for a specific table and event
+ * dispatch.observe('users', 'create', (id) => {
+ *   console.log(`User created: ${id}`);
+ * });
+ *
+ * // Start listening for events
+ * await dispatch.start();
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant FabricDispatch
+ *   participant Gateway
+ *   participant Network
+ *   participant Chaincode
+ *
+ *   Client->>FabricDispatch: new FabricDispatch(client)
+ *   Client->>FabricDispatch: configure(peerConfig)
+ *   Client->>FabricDispatch: observe(table, event, callback)
+ *   Client->>FabricDispatch: start()
+ *   FabricDispatch->>FabricDispatch: initialize()
+ *   FabricDispatch->>Gateway: getGateway(config, client)
+ *   Gateway->>Network: getNetwork(channel)
+ *   Network->>Network: getChaincodeEvents(chaincodeName)
+ *   FabricDispatch->>FabricDispatch: handleEvents()
+ *   loop For each event
+ *     Chaincode-->>FabricDispatch: ChaincodeEvent
+ *     FabricDispatch->>FabricDispatch: parseEventName(eventName)
+ *     FabricDispatch->>FabricDispatch: parsePayload(payload)
+ *     FabricDispatch->>FabricDispatch: updateObservers(table, event, id)
+ *     FabricDispatch-->>Client: callback(id)
+ *   end
+ */
+export declare class FabricClientDispatch extends Dispatch {
+    protected client: Client;
+    /**
+     * @description Event listening stack for chaincode events
+     */
+    private listeningStack?;
+    /**
+     * @description Text decoder for converting event payloads from bytes to strings
+     */
+    private decoder;
+    /**
+     * @description Creates a new FabricDispatch instance
+     * @summary Initializes a dispatcher for Fabric chaincode events
+     * @param {Client} client - gRPC client for connecting to the Fabric network
+     */
+    constructor(client: Client);
+    /**
+     * @description Closes the event listening connection
+     * @summary Stops listening for chaincode events and releases resources
+     * @return {Promise<void>} Promise that resolves when the connection is closed
+     */
+    close(): Promise<void>;
+    /**
+     * @description Parses event payload from binary format
+     * @summary Converts a Uint8Array containing JSON to an object with an id property
+     * @param {Uint8Array} jsonBytes - The binary payload from the chaincode event
+     * @return {{ id: string }} The parsed payload containing the record ID
+     */
+    private parsePayload;
+    /**
+     * @description Starts observing an adapter
+     * @summary Connects this dispatch to an adapter to monitor its operations
+     * @param {Adapter<any, any, any, any>} observer - The adapter to observe
+     * @return {void}
+     */
+    observe(observer: FabricClientAdapter): void;
+    /**
+     * @description Updates observers about a database event
+     * @summary Notifies observers about a change in the database
+     * @param {string} table - The name of the table where the change occurred
+     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred
+     * @param {any} payload - The event payload
+     * @return {Promise<void>} A promise that resolves when all observers have been notified
+     */
+    updateObservers(table: string, event: string, payload: any): Promise<void>;
+    /**
+     * @description Processes incoming chaincode events
+     * @summary Listens for events from the chaincode and dispatches them to registered observers
+     * @return {Promise<void>} Promise that resolves when event handling stops
+     * @mermaid
+     * sequenceDiagram
+     *   participant FabricDispatch
+     *   participant EventStack
+     *   participant EventParser
+     *   participant Observers
+     *
+     *   FabricDispatch->>FabricDispatch: handleEvents()
+     *   FabricDispatch->>EventStack: for await (const evt of listeningStack)
+     *   EventStack-->>FabricDispatch: ChaincodeEvent
+     *   FabricDispatch->>EventParser: parseEventName(evt.eventName)
+     *   EventParser-->>FabricDispatch: { table, event, owner }
+     *   FabricDispatch->>FabricDispatch: Check if event is for this MSP
+     *   FabricDispatch->>FabricDispatch: parsePayload(evt.payload)
+     *   FabricDispatch->>Observers: updateObservers(table, event, payload.id)
+     *   Observers-->>FabricDispatch: Callbacks executed
+     */
+    protected handleEvents(): Promise<void>;
+    /**
+     * @description Initializes the event listener
+     * @summary Sets up the connection to the Fabric network and starts listening for chaincode events
+     * @return {Promise<void>} Promise that resolves when initialization is complete
+     */
+    protected initialize(): Promise<void>;
+}

package/lib/esm/client/FabricClientDispatch.js

@@ -0,0 +1,182 @@
+import { Adapter, Dispatch, UnsupportedError } from "@decaf-ts/core";
+import { FabricClientAdapter } from "./FabricClientAdapter.js";
+import { InternalError } from "@decaf-ts/db-decorators";
+import { parseEventName } from "./../shared/events.js";
+/**
+ * @description Event dispatcher for Hyperledger Fabric chaincode events
+ * @summary Listens for and processes events emitted by Fabric chaincode, dispatching them to registered observers
+ * @template PeerConfig - Configuration type for connecting to a Fabric peer
+ * @param client - gRPC client for connecting to the Fabric network
+ * @class FabricClientDispatch
+ * @example
+ * ```typescript
+ * // Create a new FabricDispatch instance
+ * const client = await FabricAdapter.getClient(peerConfig);
+ * const dispatch = new FabricDispatch(client);
+ *
+ * // Configure the dispatch with peer configuration
+ * dispatch.configure(peerConfig);
+ *
+ * // Register an observer for a specific table and event
+ * dispatch.observe('users', 'create', (id) => {
+ *   console.log(`User created: ${id}`);
+ * });
+ *
+ * // Start listening for events
+ * await dispatch.start();
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant FabricDispatch
+ *   participant Gateway
+ *   participant Network
+ *   participant Chaincode
+ *
+ *   Client->>FabricDispatch: new FabricDispatch(client)
+ *   Client->>FabricDispatch: configure(peerConfig)
+ *   Client->>FabricDispatch: observe(table, event, callback)
+ *   Client->>FabricDispatch: start()
+ *   FabricDispatch->>FabricDispatch: initialize()
+ *   FabricDispatch->>Gateway: getGateway(config, client)
+ *   Gateway->>Network: getNetwork(channel)
+ *   Network->>Network: getChaincodeEvents(chaincodeName)
+ *   FabricDispatch->>FabricDispatch: handleEvents()
+ *   loop For each event
+ *     Chaincode-->>FabricDispatch: ChaincodeEvent
+ *     FabricDispatch->>FabricDispatch: parseEventName(eventName)
+ *     FabricDispatch->>FabricDispatch: parsePayload(payload)
+ *     FabricDispatch->>FabricDispatch: updateObservers(table, event, id)
+ *     FabricDispatch-->>Client: callback(id)
+ *   end
+ */
+export class FabricClientDispatch extends Dispatch {
+    /**
+     * @description Creates a new FabricDispatch instance
+     * @summary Initializes a dispatcher for Fabric chaincode events
+     * @param {Client} client - gRPC client for connecting to the Fabric network
+     */
+    constructor(client) {
+        super();
+        this.client = client;
+        /**
+         * @description Text decoder for converting event payloads from bytes to strings
+         */
+        this.decoder = new TextDecoder("utf8");
+    }
+    /**
+     * @description Closes the event listening connection
+     * @summary Stops listening for chaincode events and releases resources
+     * @return {Promise<void>} Promise that resolves when the connection is closed
+     */
+    async close() {
+        if (this.listeningStack)
+            this.listeningStack.close();
+    }
+    /**
+     * @description Parses event payload from binary format
+     * @summary Converts a Uint8Array containing JSON to an object with an id property
+     * @param {Uint8Array} jsonBytes - The binary payload from the chaincode event
+     * @return {{ id: string }} The parsed payload containing the record ID
+     */
+    parsePayload(jsonBytes) {
+        const json = this.decoder.decode(jsonBytes);
+        return JSON.parse(json);
+    }
+    /**
+     * @description Starts observing an adapter
+     * @summary Connects this dispatch to an adapter to monitor its operations
+     * @param {Adapter<any, any, any, any>} observer - The adapter to observe
+     * @return {void}
+     */
+    observe(observer) {
+        if (!(observer instanceof FabricClientAdapter))
+            throw new UnsupportedError("Only FabricClientAdapter can be observed by dispatch");
+        this.adapter = observer;
+        this.models = Adapter.models(this.adapter.alias);
+        this.initialize().then(() => this.log.verbose(`Dispatch initialized for ${this.adapter.alias} adapter`));
+    }
+    /**
+     * @description Updates observers about a database event
+     * @summary Notifies observers about a change in the database
+     * @param {string} table - The name of the table where the change occurred
+     * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred
+     * @param {any} payload - The event payload
+     * @return {Promise<void>} A promise that resolves when all observers have been notified
+     */
+    async updateObservers(table, event, payload) {
+        if (!this.adapter) {
+            this.log.verbose(`No adapter observed for dispatch; skipping observer update for ${table}:${event}`);
+            return;
+        }
+        try {
+            await this.adapter.refresh(table, event, payload.id ? payload.id : undefined, payload);
+        }
+        catch (e) {
+            throw new InternalError(`Failed to refresh dispatch: ${e}`);
+        }
+    }
+    /**
+     * @description Processes incoming chaincode events
+     * @summary Listens for events from the chaincode and dispatches them to registered observers
+     * @return {Promise<void>} Promise that resolves when event handling stops
+     * @mermaid
+     * sequenceDiagram
+     *   participant FabricDispatch
+     *   participant EventStack
+     *   participant EventParser
+     *   participant Observers
+     *
+     *   FabricDispatch->>FabricDispatch: handleEvents()
+     *   FabricDispatch->>EventStack: for await (const evt of listeningStack)
+     *   EventStack-->>FabricDispatch: ChaincodeEvent
+     *   FabricDispatch->>EventParser: parseEventName(evt.eventName)
+     *   EventParser-->>FabricDispatch: { table, event, owner }
+     *   FabricDispatch->>FabricDispatch: Check if event is for this MSP
+     *   FabricDispatch->>FabricDispatch: parsePayload(evt.payload)
+     *   FabricDispatch->>Observers: updateObservers(table, event, payload.id)
+     *   Observers-->>FabricDispatch: Callbacks executed
+     */
+    async handleEvents() {
+        if (!this.listeningStack)
+            throw new InternalError(`Event stack not initialized. Ensure that "startListening" is called before attempting this operation.`);
+        if (!this.adapter || !this.adapter.config)
+            throw new InternalError(`No adapter found. should be impossible`);
+        const log = this.log.for(this.handleEvents);
+        log.info(`Listening for incoming events on chaincode "${this.adapter.config.chaincodeName}" on channel "${this.adapter.config.channel}"...`);
+        try {
+            for await (const evt of this.listeningStack) {
+                const { table, event, owner } = parseEventName(evt.eventName);
+                if (owner && owner !== this.adapter.config?.mspId)
+                    continue;
+                const payload = this.parsePayload(evt.payload);
+                try {
+                    await this.updateObservers(table ? table : this.models[0].name, event, payload);
+                }
+                catch (e) {
+                    log.error(`Failed update observables for table ${table} event ${event} id: ${payload.id}: ${e}`);
+                }
+            }
+        }
+        catch (e) {
+            log.error(`Failed to read event for chaincode "${this.adapter.config.chaincodeName}" on channel "${this.adapter.config.channel}": ${e}`);
+            await this.close();
+        }
+    }
+    /**
+     * @description Initializes the event listener
+     * @summary Sets up the connection to the Fabric network and starts listening for chaincode events
+     * @return {Promise<void>} Promise that resolves when initialization is complete
+     */
+    async initialize() {
+        if (!this.adapter)
+            throw new InternalError(`No adapter or config observed for dispatch`);
+        const gateway = await FabricClientAdapter.getGateway(this.adapter.config, this.client);
+        const network = gateway.getNetwork(this.adapter.config.channel);
+        if (!this.adapter)
+            throw new InternalError(`No adapter observed for dispatch`);
+        this.listeningStack = await network.getChaincodeEvents(this.adapter.config.chaincodeName);
+        this.handleEvents();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FabricClientDispatch.js","sourceRoot":"","sources":["../../../src/client/FabricClientDispatch.ts"],"names":[],"mappings":"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","sourcesContent":["import { Adapter, Dispatch, UnsupportedError } from \"@decaf-ts/core\";\nimport { PeerConfig } from \"../shared/types\";\nimport { Client } from \"@grpc/grpc-js\";\nimport { FabricClientAdapter } from \"./FabricClientAdapter\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport {\n  ChaincodeEvent,\n  CloseableAsyncIterable,\n} from \"@hyperledger/fabric-gateway\";\nimport { parseEventName } from \"../shared/events\";\n\n/**\n * @description Event dispatcher for Hyperledger Fabric chaincode events\n * @summary Listens for and processes events emitted by Fabric chaincode, dispatching them to registered observers\n * @template PeerConfig - Configuration type for connecting to a Fabric peer\n * @param client - gRPC client for connecting to the Fabric network\n * @class FabricClientDispatch\n * @example\n * ```typescript\n * // Create a new FabricDispatch instance\n * const client = await FabricAdapter.getClient(peerConfig);\n * const dispatch = new FabricDispatch(client);\n *\n * // Configure the dispatch with peer configuration\n * dispatch.configure(peerConfig);\n *\n * // Register an observer for a specific table and event\n * dispatch.observe('users', 'create', (id) => {\n *   console.log(`User created: ${id}`);\n * });\n *\n * // Start listening for events\n * await dispatch.start();\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant FabricDispatch\n *   participant Gateway\n *   participant Network\n *   participant Chaincode\n *\n *   Client->>FabricDispatch: new FabricDispatch(client)\n *   Client->>FabricDispatch: configure(peerConfig)\n *   Client->>FabricDispatch: observe(table, event, callback)\n *   Client->>FabricDispatch: start()\n *   FabricDispatch->>FabricDispatch: initialize()\n *   FabricDispatch->>Gateway: getGateway(config, client)\n *   Gateway->>Network: getNetwork(channel)\n *   Network->>Network: getChaincodeEvents(chaincodeName)\n *   FabricDispatch->>FabricDispatch: handleEvents()\n *   loop For each event\n *     Chaincode-->>FabricDispatch: ChaincodeEvent\n *     FabricDispatch->>FabricDispatch: parseEventName(eventName)\n *     FabricDispatch->>FabricDispatch: parsePayload(payload)\n *     FabricDispatch->>FabricDispatch: updateObservers(table, event, id)\n *     FabricDispatch-->>Client: callback(id)\n *   end\n */\nexport class FabricClientDispatch extends Dispatch {\n  /**\n   * @description Event listening stack for chaincode events\n   */\n  private listeningStack?: CloseableAsyncIterable<ChaincodeEvent>;\n\n  /**\n   * @description Text decoder for converting event payloads from bytes to strings\n   */\n  private decoder = new TextDecoder(\"utf8\");\n\n  /**\n   * @description Creates a new FabricDispatch instance\n   * @summary Initializes a dispatcher for Fabric chaincode events\n   * @param {Client} client - gRPC client for connecting to the Fabric network\n   */\n  constructor(protected client: Client) {\n    super();\n  }\n\n  /**\n   * @description Closes the event listening connection\n   * @summary Stops listening for chaincode events and releases resources\n   * @return {Promise<void>} Promise that resolves when the connection is closed\n   */\n  override async close() {\n    if (this.listeningStack) this.listeningStack.close();\n  }\n\n  /**\n   * @description Parses event payload from binary format\n   * @summary Converts a Uint8Array containing JSON to an object with an id property\n   * @param {Uint8Array} jsonBytes - The binary payload from the chaincode event\n   * @return {{ id: string }} The parsed payload containing the record ID\n   */\n  private parsePayload(jsonBytes: Uint8Array): { id: string } {\n    const json = this.decoder.decode(jsonBytes);\n    return JSON.parse(json);\n  }\n\n  /**\n   * @description Starts observing an adapter\n   * @summary Connects this dispatch to an adapter to monitor its operations\n   * @param {Adapter<any, any, any, any>} observer - The adapter to observe\n   * @return {void}\n   */\n  override observe(observer: FabricClientAdapter): void {\n    if (!(observer instanceof FabricClientAdapter))\n      throw new UnsupportedError(\n        \"Only FabricClientAdapter can be observed by dispatch\"\n      );\n    this.adapter = observer;\n    this.models = Adapter.models(this.adapter.alias);\n    this.initialize().then(() =>\n      this.log.verbose(\n        `Dispatch initialized for ${this.adapter!.alias} adapter`\n      )\n    );\n  }\n\n  /**\n   * @description Updates observers about a database event\n   * @summary Notifies observers about a change in the database\n   * @param {string} table - The name of the table where the change occurred\n   * @param {OperationKeys|BulkCrudOperationKeys|string} event - The type of operation that occurred\n   * @param {any} payload - The event payload\n   * @return {Promise<void>} A promise that resolves when all observers have been notified\n   */\n  override async updateObservers(\n    table: string,\n    event: string,\n    payload: any\n  ): Promise<void> {\n    if (!this.adapter) {\n      this.log.verbose(\n        `No adapter observed for dispatch; skipping observer update for ${table}:${event}`\n      );\n      return;\n    }\n    try {\n      await this.adapter.refresh(\n        table,\n        event,\n        payload.id ? payload.id : undefined,\n        payload\n      );\n    } catch (e: unknown) {\n      throw new InternalError(`Failed to refresh dispatch: ${e}`);\n    }\n  }\n\n  /**\n   * @description Processes incoming chaincode events\n   * @summary Listens for events from the chaincode and dispatches them to registered observers\n   * @return {Promise<void>} Promise that resolves when event handling stops\n   * @mermaid\n   * sequenceDiagram\n   *   participant FabricDispatch\n   *   participant EventStack\n   *   participant EventParser\n   *   participant Observers\n   *\n   *   FabricDispatch->>FabricDispatch: handleEvents()\n   *   FabricDispatch->>EventStack: for await (const evt of listeningStack)\n   *   EventStack-->>FabricDispatch: ChaincodeEvent\n   *   FabricDispatch->>EventParser: parseEventName(evt.eventName)\n   *   EventParser-->>FabricDispatch: { table, event, owner }\n   *   FabricDispatch->>FabricDispatch: Check if event is for this MSP\n   *   FabricDispatch->>FabricDispatch: parsePayload(evt.payload)\n   *   FabricDispatch->>Observers: updateObservers(table, event, payload.id)\n   *   Observers-->>FabricDispatch: Callbacks executed\n   */\n  protected async handleEvents(): Promise<void> {\n    if (!this.listeningStack)\n      throw new InternalError(\n        `Event stack not initialized. Ensure that \"startListening\" is called before attempting this operation.`\n      );\n\n    if (!this.adapter || !this.adapter.config)\n      throw new InternalError(`No adapter found. should be impossible`);\n\n    const log = this.log.for(this.handleEvents);\n    log.info(\n      `Listening for incoming events on chaincode \"${this.adapter.config.chaincodeName}\" on channel \"${this.adapter.config.channel}\"...`\n    );\n\n    try {\n      for await (const evt of this.listeningStack) {\n        const { table, event, owner } = parseEventName(evt.eventName);\n        if (owner && owner !== this.adapter.config?.mspId) continue;\n        const payload: { id: string } = this.parsePayload(evt.payload);\n        try {\n          await this.updateObservers(\n            table ? table : this.models[0].name,\n            event,\n            payload\n          );\n        } catch (e: unknown) {\n          log.error(\n            `Failed update observables for table ${table} event ${event} id: ${payload.id}: ${e}`\n          );\n        }\n      }\n    } catch (e: any) {\n      log.error(\n        `Failed to read event for chaincode \"${this.adapter.config.chaincodeName}\" on channel \"${this.adapter.config.channel}\": ${e}`\n      );\n      await this.close();\n    }\n  }\n\n  /**\n   * @description Initializes the event listener\n   * @summary Sets up the connection to the Fabric network and starts listening for chaincode events\n   * @return {Promise<void>} Promise that resolves when initialization is complete\n   */\n  protected override async initialize(): Promise<void> {\n    if (!this.adapter)\n      throw new InternalError(`No adapter or config observed for dispatch`);\n    const gateway = await FabricClientAdapter.getGateway(\n      this.adapter.config as PeerConfig,\n      this.client\n    );\n    const network = gateway.getNetwork(this.adapter.config.channel);\n    if (!this.adapter)\n      throw new InternalError(`No adapter observed for dispatch`);\n    this.listeningStack = await network.getChaincodeEvents(\n      this.adapter.config.chaincodeName\n    );\n    this.handleEvents();\n  }\n}\n"]}

package/lib/esm/client/FabricClientRepository.d.ts

@@ -0,0 +1,100 @@
+import { Adapter, Repository } from "@decaf-ts/core";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { MangoQuery } from "@decaf-ts/for-couchdb";
+import { Context } from "@decaf-ts/db-decorators";
+import { FabricFlags } from "../shared";
+/**
+ * @description Repository implementation for Fabric client operations
+ * @summary Extends the generic Repository to prepare context and arguments for CRUD operations executed via a Fabric client Adapter, wiring RepositoryFlags and Fabric-specific overrides.
+ * @template M extends Model - The model type handled by this repository
+ * @param {Adapter<any, MangoQuery, FabricFlags, Context<FabricFlags>>} [adapter] - Optional adapter instance used to execute operations
+ * @param {Constructor<M>} [clazz] - Optional model constructor used by the repository
+ * @return {void}
+ * @class FabricClientRepository
+ * @example
+ * import { Repository } from "@decaf-ts/core";
+ * import { FabricClientRepository } from "@decaf-ts/for-fabric";
+ *
+ * class User extends Model { id!: string; name!: string; }
+ * const repo = new FabricClientRepository<User>();
+ * const created = await repo.create(new User({ id: "1", name: "Alice" }));
+ * const loaded = await repo.read("1");
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Repo as FabricClientRepository
+ *   participant Adapter
+ *   App->>Repo: create(model)
+ *   Repo->>Repo: createPrefix(model, ...args)
+ *   Repo->>Adapter: create(table, id, model, flags)
+ *   Adapter-->>Repo: result
+ *   Repo-->>App: model
+ */
+export declare class FabricClientRepository<M extends Model> extends Repository<M, MangoQuery, Adapter<any, any, MangoQuery, FabricFlags, Context<FabricFlags>>> {
+    constructor(adapter?: Adapter<any, any, MangoQuery, FabricFlags, Context<FabricFlags>>, clazz?: Constructor<M>);
+    /**
+     * @description Prepare arguments and context for create
+     * @summary Builds repository context and ensures the model is instantiated with the repository's class before delegating to the adapter
+     * @param {M} model - The model instance to create
+     * @param {...any[]} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the prepared model and the processed arguments
+     */
+    protected createPrefix(model: M, ...args: any[]): Promise<[M, ...any[]]>;
+    /**
+     * @description Prepare arguments and context for bulk create
+     * @summary Resolves repository context for a createAll operation passing through models and processed arguments
+     * @param {M[]} models - Array of model instances to create
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the models array and processed arguments
+     */
+    protected createAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
+    /**
+     * @description Prepare arguments and context for read
+     * @summary Resolves repository context for a read operation and forwards the key and processed arguments
+     * @param {string} key - The model primary key to read
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the key and processed arguments
+     */
+    protected readPrefix(key: string, ...args: any[]): Promise<any[]>;
+    /**
+     * @description Prepare arguments and context for bulk read
+     * @summary Resolves repository context for a readAll operation and forwards the keys and processed arguments
+     * @param {(string[]|number[])} keys - Array of model primary keys to read
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the keys and processed arguments
+     */
+    protected readAllPrefix(keys: string[] | number[], ...args: any[]): Promise<any[]>;
+    /**
+     * @description Prepare arguments and context for update
+     * @summary Resolves repository context for an update operation and forwards the model and processed arguments
+     * @param {M} model - The model instance to update
+     * @param {...any[]} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the model and processed arguments
+     */
+    protected updatePrefix(model: M, ...args: any[]): Promise<[M, ...args: any[]]>;
+    /**
+     * @description Prepare arguments and context for bulk update
+     * @summary Resolves repository context for an updateAll operation and forwards the models and processed arguments
+     * @param {M[]} models - The model instances to update
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the models and processed arguments
+     */
+    protected updateAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
+    /**
+     * @description Prepare arguments and context for delete
+     * @summary Resolves repository context for a delete operation, ensures the target exists via read, then forwards key and processed arguments
+     * @param {string|number} key - The model primary key to delete
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the key and processed arguments
+     */
+    protected deletePrefix(key: any, ...args: any[]): Promise<any[]>;
+    /**
+     * @description Prepare arguments and context for bulk delete
+     * @summary Resolves repository context for a deleteAll operation, validates existence via readAll, then forwards keys and processed arguments
+     * @param {(string[]|number[])} keys - The model primary keys to delete
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the keys and processed arguments
+     */
+    protected deleteAllPrefix(keys: string[] | number[], ...args: any[]): Promise<any[]>;
+}

package/lib/esm/client/FabricClientRepository.js

@@ -0,0 +1,127 @@
+import { Repository } from "@decaf-ts/core";
+import { Context, OperationKeys, } from "@decaf-ts/db-decorators";
+/**
+ * @description Repository implementation for Fabric client operations
+ * @summary Extends the generic Repository to prepare context and arguments for CRUD operations executed via a Fabric client Adapter, wiring RepositoryFlags and Fabric-specific overrides.
+ * @template M extends Model - The model type handled by this repository
+ * @param {Adapter<any, MangoQuery, FabricFlags, Context<FabricFlags>>} [adapter] - Optional adapter instance used to execute operations
+ * @param {Constructor<M>} [clazz] - Optional model constructor used by the repository
+ * @return {void}
+ * @class FabricClientRepository
+ * @example
+ * import { Repository } from "@decaf-ts/core";
+ * import { FabricClientRepository } from "@decaf-ts/for-fabric";
+ *
+ * class User extends Model { id!: string; name!: string; }
+ * const repo = new FabricClientRepository<User>();
+ * const created = await repo.create(new User({ id: "1", name: "Alice" }));
+ * const loaded = await repo.read("1");
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Repo as FabricClientRepository
+ *   participant Adapter
+ *   App->>Repo: create(model)
+ *   Repo->>Repo: createPrefix(model, ...args)
+ *   Repo->>Adapter: create(table, id, model, flags)
+ *   Adapter-->>Repo: result
+ *   Repo-->>App: model
+ */
+export class FabricClientRepository extends Repository {
+    constructor(adapter, clazz) {
+        super(adapter, clazz);
+    }
+    /**
+     * @description Prepare arguments and context for create
+     * @summary Builds repository context and ensures the model is instantiated with the repository's class before delegating to the adapter
+     * @param {M} model - The model instance to create
+     * @param {...any[]} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the prepared model and the processed arguments
+     */
+    async createPrefix(model, ...args) {
+        const contextArgs = await Context.args(OperationKeys.CREATE, this.class, args, this.adapter, this._overrides || {});
+        model = new this.class(model);
+        return [model, ...contextArgs.args];
+    }
+    /**
+     * @description Prepare arguments and context for bulk create
+     * @summary Resolves repository context for a createAll operation passing through models and processed arguments
+     * @param {M[]} models - Array of model instances to create
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the models array and processed arguments
+     */
+    async createAllPrefix(models, ...args) {
+        const contextArgs = await Context.args(OperationKeys.CREATE, this.class, args, this.adapter, this._overrides || {});
+        return [models, ...contextArgs.args];
+    }
+    /**
+     * @description Prepare arguments and context for read
+     * @summary Resolves repository context for a read operation and forwards the key and processed arguments
+     * @param {string} key - The model primary key to read
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the key and processed arguments
+     */
+    async readPrefix(key, ...args) {
+        const contextArgs = await Context.args(OperationKeys.READ, this.class, args, this.adapter, this._overrides || {});
+        return [key, ...contextArgs.args];
+    }
+    /**
+     * @description Prepare arguments and context for bulk read
+     * @summary Resolves repository context for a readAll operation and forwards the keys and processed arguments
+     * @param {(string[]|number[])} keys - Array of model primary keys to read
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the keys and processed arguments
+     */
+    async readAllPrefix(keys, ...args) {
+        const contextArgs = await Context.args(OperationKeys.READ, this.class, args, this.adapter, this._overrides || {});
+        return [keys, ...contextArgs.args];
+    }
+    /**
+     * @description Prepare arguments and context for update
+     * @summary Resolves repository context for an update operation and forwards the model and processed arguments
+     * @param {M} model - The model instance to update
+     * @param {...any[]} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the model and processed arguments
+     */
+    async updatePrefix(model, ...args) {
+        const contextArgs = await Context.args(OperationKeys.UPDATE, this.class, args, this.adapter, this._overrides || {});
+        return [model, ...contextArgs.args];
+    }
+    /**
+     * @description Prepare arguments and context for bulk update
+     * @summary Resolves repository context for an updateAll operation and forwards the models and processed arguments
+     * @param {M[]} models - The model instances to update
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the models and processed arguments
+     */
+    async updateAllPrefix(models, ...args) {
+        const contextArgs = await Context.args(OperationKeys.UPDATE, this.class, args, this.adapter, this._overrides || {});
+        return [models, ...contextArgs.args];
+    }
+    /**
+     * @description Prepare arguments and context for delete
+     * @summary Resolves repository context for a delete operation, ensures the target exists via read, then forwards key and processed arguments
+     * @param {string|number} key - The model primary key to delete
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the key and processed arguments
+     */
+    async deletePrefix(key, ...args) {
+        const contextArgs = await Context.args(OperationKeys.DELETE, this.class, args, this.adapter, this._overrides || {});
+        await this.read(key, ...contextArgs.args);
+        return [key, ...contextArgs.args];
+    }
+    /**
+     * @description Prepare arguments and context for bulk delete
+     * @summary Resolves repository context for a deleteAll operation, validates existence via readAll, then forwards keys and processed arguments
+     * @param {(string[]|number[])} keys - The model primary keys to delete
+     * @param {...any} args - Additional operation arguments and flags
+     * @return {...any[]} Tuple containing the keys and processed arguments
+     */
+    async deleteAllPrefix(keys, ...args) {
+        const contextArgs = await Context.args(OperationKeys.DELETE, this.class, args, this.adapter, this._overrides || {});
+        await this.readAll(keys, ...contextArgs.args);
+        return [keys, ...contextArgs.args];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FabricClientRepository.js","sourceRoot":"","sources":["../../../src/client/FabricClientRepository.ts"],"names":[],"mappings":"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","sourcesContent":["import { Adapter, Repository } from \"@decaf-ts/core\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport { MangoQuery } from \"@decaf-ts/for-couchdb\";\nimport {\n  Context,\n  OperationKeys,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport { FabricFlags } from \"../shared\";\n\n/**\n * @description Repository implementation for Fabric client operations\n * @summary Extends the generic Repository to prepare context and arguments for CRUD operations executed via a Fabric client Adapter, wiring RepositoryFlags and Fabric-specific overrides.\n * @template M extends Model - The model type handled by this repository\n * @param {Adapter<any, MangoQuery, FabricFlags, Context<FabricFlags>>} [adapter] - Optional adapter instance used to execute operations\n * @param {Constructor<M>} [clazz] - Optional model constructor used by the repository\n * @return {void}\n * @class FabricClientRepository\n * @example\n * import { Repository } from \"@decaf-ts/core\";\n * import { FabricClientRepository } from \"@decaf-ts/for-fabric\";\n *\n * class User extends Model { id!: string; name!: string; }\n * const repo = new FabricClientRepository<User>();\n * const created = await repo.create(new User({ id: \"1\", name: \"Alice\" }));\n * const loaded = await repo.read(\"1\");\n *\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Repo as FabricClientRepository\n *   participant Adapter\n *   App->>Repo: create(model)\n *   Repo->>Repo: createPrefix(model, ...args)\n *   Repo->>Adapter: create(table, id, model, flags)\n *   Adapter-->>Repo: result\n *   Repo-->>App: model\n */\nexport class FabricClientRepository<M extends Model> extends Repository<\n  M,\n  MangoQuery,\n  Adapter<any, any, MangoQuery, FabricFlags, Context<FabricFlags>>\n> {\n  constructor(\n    adapter?: Adapter<any, any, MangoQuery, FabricFlags, Context<FabricFlags>>,\n    clazz?: Constructor<M>\n  ) {\n    super(adapter, clazz);\n  }\n\n  /**\n   * @description Prepare arguments and context for create\n   * @summary Builds repository context and ensures the model is instantiated with the repository's class before delegating to the adapter\n   * @param {M} model - The model instance to create\n   * @param {...any[]} args - Additional operation arguments and flags\n   * @return {...any[]} Tuple containing the prepared model and the processed arguments\n   */\n  protected override async createPrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...any[]]> {\n    const contextArgs = await Context.args<\n      M,\n      Context<RepositoryFlags>,\n      RepositoryFlags\n    >(\n      OperationKeys.CREATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    model = new this.class(model);\n    return [model, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepare arguments and context for bulk create\n   * @summary Resolves repository context for a createAll operation passing through models and processed arguments\n   * @param {M[]} models - Array of model instances to create\n   * @param {...any} args - Additional operation arguments and flags\n   * @return {...any[]} Tuple containing the models array and processed arguments\n   */\n  protected override async createAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.CREATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    return [models, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepare arguments and context for read\n   * @summary Resolves repository context for a read operation and forwards the key and processed arguments\n   * @param {string} key - The model primary key to read\n   * @param {...any} args - Additional operation arguments and flags\n   * @return {...any[]} Tuple containing the key and processed arguments\n   */\n  protected override async readPrefix(key: string, ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.READ,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    return [key, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepare arguments and context for bulk read\n   * @summary Resolves repository context for a readAll operation and forwards the keys and processed arguments\n   * @param {(string[]|number[])} keys - Array of model primary keys to read\n   * @param {...any} args - Additional operation arguments and flags\n   * @return {...any[]} Tuple containing the keys and processed arguments\n   */\n  protected override async readAllPrefix(\n    keys: string[] | number[],\n    ...args: any[]\n  ) {\n    const contextArgs = await Context.args(\n      OperationKeys.READ,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    return [keys, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepare arguments and context for update\n   * @summary Resolves repository context for an update operation and forwards the model and processed arguments\n   * @param {M} model - The model instance to update\n   * @param {...any[]} args - Additional operation arguments and flags\n   * @return {...any[]} Tuple containing the model and processed arguments\n   */\n  protected override async updatePrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...args: any[]]> {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    return [model, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepare arguments and context for bulk update\n   * @summary Resolves repository context for an updateAll operation and forwards the models and processed arguments\n   * @param {M[]} models - The model instances to update\n   * @param {...any} args - Additional operation arguments and flags\n   * @return {...any[]} Tuple containing the models and processed arguments\n   */\n  protected override async updateAllPrefix(\n    models: M[],\n    ...args: any[]\n  ): Promise<any[]> {\n    const contextArgs = await Context.args(\n      OperationKeys.UPDATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    return [models, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepare arguments and context for delete\n   * @summary Resolves repository context for a delete operation, ensures the target exists via read, then forwards key and processed arguments\n   * @param {string|number} key - The model primary key to delete\n   * @param {...any} args - Additional operation arguments and flags\n   * @return {...any[]} Tuple containing the key and processed arguments\n   */\n  protected override async deletePrefix(key: any, ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.DELETE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    await this.read(key, ...contextArgs.args);\n    return [key, ...contextArgs.args];\n  }\n\n  /**\n   * @description Prepare arguments and context for bulk delete\n   * @summary Resolves repository context for a deleteAll operation, validates existence via readAll, then forwards keys and processed arguments\n   * @param {(string[]|number[])} keys - The model primary keys to delete\n   * @param {...any} args - Additional operation arguments and flags\n   * @return {...any[]} Tuple containing the keys and processed arguments\n   */\n  protected override async deleteAllPrefix(\n    keys: string[] | number[],\n    ...args: any[]\n  ) {\n    const contextArgs = await Context.args(\n      OperationKeys.DELETE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    await this.readAll(keys, ...contextArgs.args);\n    return [keys, ...contextArgs.args];\n  }\n}\n"]}