@decaf-ts/for-fabric 0.0.2

package/lib/client/FabricClientAdapter.d.ts

@@ -0,0 +1,381 @@
+import { CouchDBAdapter, type MangoQuery } from "@decaf-ts/for-couchdb";
+import { Client } from "@grpc/grpc-js";
+import { type Constructor, Model, type Serializer } from "@decaf-ts/decorator-validation";
+import { Logger } from "@decaf-ts/logging";
+import { FabricFlags, PeerConfig } from "../shared/types";
+import { Gateway, Network, Contract as Contrakt } from "@hyperledger/fabric-gateway";
+import { BaseError, Context } from "@decaf-ts/db-decorators";
+import { Adapter, Dispatch, Repository } from "@decaf-ts/core";
+/**
+ * @description Adapter for interacting with Hyperledger Fabric networks
+ * @summary The FabricAdapter extends CouchDBAdapter to provide a seamless interface for interacting with Hyperledger Fabric networks.
+ * It handles connection management, transaction submission, and CRUD operations against Fabric chaincode.
+ * @template PeerConfig - Configuration type for connecting to a Fabric peer
+ * @template FabricFlags - Flags specific to Fabric operations
+ * @template Context<FabricFlags> - Context type containing Fabric-specific flags
+ * @param config - Configuration for connecting to a Fabric peer
+ * @param alias - Optional alias for the adapter instance
+ * @class FabricClientAdapter
+ * @example
+ * ```typescript
+ * // Create a new FabricAdapter instance
+ * const config: PeerConfig = {
+ *   mspId: 'Org1MSP',
+ *   peerEndpoint: 'localhost:7051',
+ *   channelName: 'mychannel',
+ *   chaincodeName: 'mycc',
+ *   contractName: 'mycontract',
+ *   tlsCertPath: '/path/to/tls/cert',
+ *   certDirectoryPath: '/path/to/cert/dir',
+ *   keyDirectoryPath: '/path/to/key/dir'
+ * };
+ *
+ * const adapter = new FabricAdapter(config, 'org1-adapter');
+ *
+ * // Use the adapter to interact with the Fabric network
+ * const result = await adapter.read('users', 'user1', mySerializer);
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant FabricAdapter
+ *   participant Gateway
+ *   participant Network
+ *   participant Contract
+ *   participant Chaincode
+ *
+ *   Client->>FabricAdapter: create(tableName, id, model, transient, serializer)
+ *   FabricAdapter->>FabricAdapter: submitTransaction(OperationKeys.CREATE, [serializedModel], transient)
+ *   FabricAdapter->>Gateway: connect()
+ *   Gateway->>Network: getNetwork(channelName)
+ *   Network->>Contract: getContract(chaincodeName, contractName)
+ *   FabricAdapter->>Contract: submit(api, proposalOptions)
+ *   Contract->>Chaincode: invoke
+ *   Chaincode-->>Contract: response
+ *   Contract-->>FabricAdapter: result
+ *   FabricAdapter->>FabricAdapter: decode(result)
+ *   FabricAdapter->>FabricAdapter: serializer.deserialize(decodedResult)
+ *   FabricAdapter-->>Client: deserializedResult
+ */
+export declare class FabricClientAdapter extends CouchDBAdapter<PeerConfig, Client, FabricFlags, Context<FabricFlags>> {
+    /**
+     * @description Static text decoder for converting Uint8Array to string
+     */
+    private static decoder;
+    private static serializer;
+    /**
+     * @description Static logger instance for the FabricAdapter class
+     */
+    private static log;
+    /**
+     * @description Gets the logger instance for this adapter
+     * @summary Returns the static logger instance for the FabricAdapter class
+     * @return {Logger} The logger instance
+     */
+    protected get log(): Logger;
+    protected readonly serializer: Serializer<any>;
+    /**
+     * @description Creates a new FabricAdapter instance
+     * @summary Initializes a new adapter for interacting with a Hyperledger Fabric network
+     * @param {PeerConfig} config - Configuration for connecting to a Fabric peer
+     * @param {string} [alias] - Optional alias for the adapter instance
+     */
+    constructor(config: PeerConfig, alias?: string);
+    /**
+     * @description Decodes a Uint8Array to a string
+     * @summary Converts binary data received from Fabric to a string using UTF-8 encoding
+     * @param {Uint8Array} data - The binary data to decode
+     * @return {string} The decoded string
+     */
+    decode(data: Uint8Array): string;
+    repository<M extends Model<true | false>>(): Constructor<Repository<M, MangoQuery, Adapter<PeerConfig, Client, MangoQuery, FabricFlags, Context<FabricFlags>>, FabricFlags, Context<FabricFlags>>>;
+    /**
+     * @description Creates multiple records in a single transaction
+     * @summary Submits a transaction to create multiple records in the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string[] | number[]} ids - Array of record identifiers
+     * @param {Array<Record<string, any>>} models - Array of record data
+     * @param {Record<string, any>} transient - Transient data for the transaction
+     * @return {Promise<Array<Record<string, any>>>} Promise resolving to the created records
+     */
+    createAll(tableName: string, ids: string[] | number[], models: Record<string, any>[], transient: Record<string, any>): Promise<Record<string, any>[]>;
+    /**
+     * @description Reads multiple records in a single transaction
+     * @summary Submits a transaction to read multiple records from the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string[] | number[]} ids - Array of record identifiers to read
+     * @return {Promise<Array<Record<string, any>>>} Promise resolving to the retrieved records
+     */
+    readAll(tableName: string, ids: string[] | number[]): Promise<Record<string, any>[]>;
+    /**
+     * @description Updates multiple records in a single transaction
+     * @summary Submits a transaction to update multiple records in the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string[] | number[]} ids - Array of record identifiers
+     * @param {Array<Record<string, any>>} models - Array of updated record data
+     * @param {Record<string, any>} transient - Transient data for the transaction
+     * @return {Promise<Array<Record<string, any>>>} Promise resolving to the updated records
+     */
+    updateAll(tableName: string, ids: string[] | number[], models: Record<string, any>[], transient: Record<string, any>): Promise<Record<string, any>[]>;
+    /**
+     * @description Deletes multiple records in a single transaction
+     * @summary Submits a transaction to delete multiple records from the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {Array<string | number | bigint>} ids - Array of record identifiers to delete
+     * @param {Serializer<any>} serializer - Serializer for the model data
+     * @return {Promise<Array<Record<string, any>>>} Promise resolving to the deleted records
+     */
+    deleteAll(tableName: string, ids: (string | number | bigint)[]): Promise<Record<string, any>[]>;
+    /**
+     * @description Prepares a model for persistence
+     * @summary Converts a model instance into a format suitable for database storage,
+     * handling column mapping and separating transient properties
+     * @template M - The model type
+     * @param {M} model - The model instance to prepare
+     * @param pk - The primary key property name
+     * @return The prepared data
+     */
+    prepare<M extends Model>(model: M, pk: keyof M): {
+        record: Record<string, any>;
+        id: string;
+        transient?: Record<string, any>;
+    };
+    /**
+     * @description Converts database data back into a model instance
+     * @summary Reconstructs a model instance from database data, handling column mapping
+     * and reattaching transient properties
+     * @template M - The model type
+     * @param obj - The database record
+     * @param {string|Constructor<M>} clazz - The model class or name
+     * @param pk - The primary key property name
+     * @param {string|number|bigint} id - The primary key value
+     * @param [transient] - Transient properties to reattach
+     * @return {M} The reconstructed model instance
+     */
+    revert<M extends Model>(obj: Record<string, any>, clazz: string | Constructor<M>, pk: keyof M, id: string | number | bigint, transient?: Record<string, any>): M;
+    /**
+     * @description Creates an index for a model
+     * @summary This method is not implemented for Fabric and will throw an error
+     * @template M - Type extending Model
+     * @param {Constructor<M>} models - The model constructor
+     * @return {Promise<void>} Promise that will throw an error
+     */
+    protected index<M>(models: Constructor<M>): Promise<void>;
+    /**
+     * @description Creates a single record
+     * @summary Submits a transaction to create a record in the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier
+     * @param {Record<string, any>} model - The record data
+     * @param {Record<string, any>} transient - Transient data for the transaction
+     * @return {Promise<Record<string, any>>} Promise resolving to the created record
+     */
+    create(tableName: string, id: string | number, model: Record<string, any>, transient: Record<string, any>): Promise<Record<string, any>>;
+    /**
+     * @description Reads a single record
+     * @summary Evaluates a transaction to read a record from the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier
+     * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record
+     */
+    read(tableName: string, id: string | number): Promise<Record<string, any>>;
+    /**
+     * @description Updates a single record
+     * @summary Submits a transaction to update a record in the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier
+     * @param {Record<string, any>} model - The updated record data
+     * @param {Record<string, any>} transient - Transient data for the transaction
+     * @return {Promise<Record<string, any>>} Promise resolving to the updated record
+     */
+    update(tableName: string, id: string | number, model: Record<string, any>, transient: Record<string, any>): Promise<Record<string, any>>;
+    /**
+     * @description Deletes a single record
+     * @summary Submits a transaction to delete a record from the Fabric ledger
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier to delete
+     * @return {Promise<Record<string, any>>} Promise resolving to the deleted record
+     */
+    delete(tableName: string, id: string | number): Promise<Record<string, any>>;
+    /**
+     * @description Executes a raw query against the Fabric ledger
+     * @summary Evaluates a transaction to perform a query using Mango Query syntax
+     * @template V - The return type
+     * @param {MangoQuery} rawInput - The Mango Query to execute
+     * @param {boolean} process - Whether to process the result
+     * @return {Promise<V>} Promise resolving to the query result
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant FabricAdapter
+     *   participant Contract
+     *   participant Chaincode
+     *
+     *   Client->>FabricAdapter: raw(rawInput, process)
+     *   FabricAdapter->>FabricAdapter: JSON.stringify(rawInput)
+     *   FabricAdapter->>FabricAdapter: evaluateTransaction("query", [input])
+     *   FabricAdapter->>Contract: evaluate("query", proposalOptions)
+     *   Contract->>Chaincode: invoke
+     *   Chaincode-->>Contract: response
+     *   Contract-->>FabricAdapter: result
+     *   FabricAdapter->>FabricAdapter: JSON.parse(decode(result))
+     *   FabricAdapter->>FabricAdapter: Process result based on type
+     *   FabricAdapter-->>Client: processed result
+     */
+    raw<V>(rawInput: MangoQuery, process: boolean): Promise<V>;
+    /**
+     * @description Gets or creates a gRPC client for the Fabric peer
+     * @summary Returns a cached client or creates a new one if none exists
+     * @return {Promise<Client>} Promise resolving to the gRPC client
+     */
+    getClient(): Client;
+    /**
+     * @description Gets a Gateway instance for the Fabric network
+     * @summary Creates a new Gateway instance using the current client
+     * @return {Promise<Gateway>} Promise resolving to the Gateway instance
+     */
+    protected Gateway(): Promise<Gateway>;
+    /**
+     * @description Gets a Contract instance for the Fabric chaincode
+     * @summary Creates a new Contract instance using the current Gateway
+     * @return {Promise<Contrakt>} Promise resolving to the Contract instance
+     */
+    protected Contract(): Promise<Contrakt>;
+    /**
+     * @description Executes a transaction on the Fabric network
+     * @summary Submits or evaluates a transaction on the Fabric chaincode
+     * @param {string} api - The chaincode function to call
+     * @param {boolean} submit - Whether to submit (true) or evaluate (false) the transaction
+     * @param {any[]} [args] - Arguments to pass to the chaincode function
+     * @param {Record<string, string>} [transientData] - Transient data for the transaction
+     * @param {Array<string>} [endorsingOrganizations] - Organizations that must endorse the transaction
+     * @return {Promise<Uint8Array>} Promise resolving to the transaction result
+     * @mermaid
+     * sequenceDiagram
+     *   participant FabricAdapter
+     *   participant Gateway
+     *   participant Contract
+     *   participant Chaincode
+     *
+     *   FabricAdapter->>Gateway: connect()
+     *   FabricAdapter->>Contract: getContract()
+     *   alt submit transaction
+     *     FabricAdapter->>Contract: submit(api, proposalOptions)
+     *   else evaluate transaction
+     *     FabricAdapter->>Contract: evaluate(api, proposalOptions)
+     *   end
+     *   Contract->>Chaincode: invoke
+     *   Chaincode-->>Contract: response
+     *   Contract-->>FabricAdapter: result
+     *   FabricAdapter->>Gateway: close()
+     */
+    protected transaction(api: string, submit?: boolean, args?: any[], transientData?: Record<string, string>, endorsingOrganizations?: Array<string>): Promise<Uint8Array>;
+    /**
+     * @description Parses an error into a BaseError
+     * @summary Converts any error into a standardized BaseError
+     * @param {Error | string} err - The error to parse
+     * @param {string} [reason] - Optional reason for the error
+     * @return {BaseError} The parsed error
+     */
+    parseError(err: Error | string, reason?: string): BaseError;
+    /**
+     * @description Submits a transaction to the Fabric network
+     * @summary Executes a transaction that modifies the ledger state
+     * @param {string} api - The chaincode function to call
+     * @param {any[]} [args] - Arguments to pass to the chaincode function
+     * @param {Record<string, string>} [transientData] - Transient data for the transaction
+     * @param {Array<string>} [endorsingOrganizations] - Organizations that must endorse the transaction
+     * @return {Promise<Uint8Array>} Promise resolving to the transaction result
+     */
+    submitTransaction(api: string, args?: any[], transientData?: Record<string, string>, endorsingOrganizations?: Array<string>): Promise<Uint8Array>;
+    /**
+     * @description Evaluates a transaction on the Fabric network
+     * @summary Executes a transaction that does not modify the ledger state
+     * @param {string} api - The chaincode function to call
+     * @param {any[]} [args] - Arguments to pass to the chaincode function
+     * @param {Record<string, string>} [transientData] - Transient data for the transaction
+     * @param {Array<string>} [endorsingOrganizations] - Organizations that must endorse the transaction
+     * @return {Promise<Uint8Array>} Promise resolving to the transaction result
+     */
+    evaluateTransaction(api: string, args?: any[], transientData?: Record<string, string>, endorsingOrganizations?: Array<string>): Promise<Uint8Array>;
+    /**
+     * @description Closes the connection to the Fabric network
+     * @summary Closes the gRPC client if it exists
+     * @return {Promise<void>} Promise that resolves when the client is closed
+     */
+    close(): Promise<void>;
+    /**
+     * @description Gets a Contract instance from a Gateway
+     * @summary Retrieves a chaincode contract from the specified network
+     * @param {Gateway} gateway - The Gateway instance
+     * @param {PeerConfig} config - The peer configuration
+     * @return {Contrakt} The Contract instance
+     */
+    static getContract(gateway: Gateway, config: PeerConfig): Contrakt;
+    /**
+     * @description Gets a Network instance from a Gateway
+     * @summary Connects to a specific channel on the Fabric network
+     * @param {Gateway} gateway - The Gateway instance
+     * @param {string} channelName - The name of the channel to connect to
+     * @return {Network} The Network instance
+     */
+    static getNetwork(gateway: Gateway, channelName: string): Network;
+    /**
+     * @description Gets a Gateway instance for connecting to the Fabric network
+     * @summary Creates a Gateway using the provided configuration and client
+     * @param {PeerConfig} config - The peer configuration
+     * @param {Client} [client] - Optional gRPC client, will be created if not provided
+     * @return {Promise<Gateway>} Promise resolving to the Gateway instance
+     */
+    static getGateway(config: PeerConfig, client?: Client): Promise<Gateway>;
+    /**
+     * @description Creates a gRPC client for connecting to a Fabric peer
+     * @summary Initializes a client with TLS credentials for secure communication
+     * @param {PeerConfig} config - The peer configuration
+     * @return {Client} Promise resolving to the gRPC client
+     */
+    static getClient(config: PeerConfig): Client;
+    /**
+     * @description Establishes a connection to the Fabric network
+     * @summary Creates a Gateway connection with identity and signer
+     * @param {Client} client - The gRPC client
+     * @param {PeerConfig} config - The peer configuration
+     * @return {Promise<Gateway>} Promise resolving to the connected Gateway
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant FabricAdapter
+     *   participant Identity
+     *   participant Signer
+     *   participant Gateway
+     *
+     *   Caller->>FabricAdapter: getConnection(client, config)
+     *   FabricAdapter->>Identity: getIdentity(mspId, certDirectoryPath)
+     *   Identity-->>FabricAdapter: identity
+     *   FabricAdapter->>Signer: getSigner(keyDirectoryPath)
+     *   Signer-->>FabricAdapter: signer
+     *   FabricAdapter->>FabricAdapter: Create ConnectOptions
+     *   FabricAdapter->>Gateway: connect(options)
+     *   Gateway-->>FabricAdapter: gateway
+     *   FabricAdapter-->>Caller: gateway
+     */
+    static getConnection(client: Client, config: PeerConfig): Promise<Gateway>;
+    /**
+     * @description Creates a new Dispatch instance for the Fabric client.
+     * @summary This function is responsible for creating a new FabricClientDispatch instance that can be used to interact with the Fabric network.
+     * @returns {Dispatch} A new Dispatch instance configured for the Fabric client.
+     * @remarks The Dispatch instance is used to encapsulate the logic for interacting with the Fabric network, such as submitting transactions or querying data.
+     * @example
+     * const fabricDispatch = fabricClientAdapter.Dispatch();
+     * fabricDispatch.submitTransaction('createProduct', { name: 'Product A', price: 100 });
+     */
+    Dispatch(): Dispatch;
+    /**
+     * @description Parses an error into a BaseError
+     * @summary Converts any error into a standardized BaseError using the parent class implementation
+     * @param {Error | string} err - The error to parse
+     * @param {string} [reason] - Optional reason for the error
+     * @return {BaseError} The parsed error
+     */
+    protected static parseError(err: Error | string, reason?: string): BaseError;
+}

package/lib/client/FabricClientDispatch.cjs

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FabricClientDispatch = void 0;
+const core_1 = require("@decaf-ts/core");
+const FabricClientAdapter_1 = require("./FabricClientAdapter.cjs");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const events_1 = require("./../shared/events.cjs");
+/**
+ * @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
+ */
+class FabricClientDispatch extends core_1.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_1.FabricClientAdapter))
+            throw new core_1.UnsupportedError("Only FabricClientAdapter can be observed by dispatch");
+        this.adapter = observer;
+        this.models = core_1.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 db_decorators_1.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 db_decorators_1.InternalError(`Event stack not initialized. Ensure that "startListening" is called before attempting this operation.`);
+        if (!this.adapter || !this.adapter.config)
+            throw new db_decorators_1.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 } = (0, events_1.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 db_decorators_1.InternalError(`No adapter or config observed for dispatch`);
+        const gateway = await FabricClientAdapter_1.FabricClientAdapter.getGateway(this.adapter.config, this.client);
+        const network = gateway.getNetwork(this.adapter.config.channel);
+        if (!this.adapter)
+            throw new db_decorators_1.InternalError(`No adapter observed for dispatch`);
+        this.listeningStack = await network.getChaincodeEvents(this.adapter.config.chaincodeName);
+        this.handleEvents();
+    }
+}
+exports.FabricClientDispatch = FabricClientDispatch;
+//# 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"]}