@decaf-ts/for-fabric 0.0.2

package/lib/esm/contracts/ContractContext.d.ts

@@ -0,0 +1,64 @@
+import { Context } from "@decaf-ts/db-decorators";
+import { FabricContractFlags } from "./types";
+import { ChaincodeStub, ClientIdentity } from "fabric-shim-api";
+/**
+ * @description Context class for Fabric chaincode operations
+ * @summary Provides access to Fabric-specific context elements like stub, identity, and logger to be used by repositories and adapters during contract execution.
+ * @template F - Flags specific to Fabric contract operations
+ * @param {object} [args] - Optional initialization arguments passed to the base Context
+ * @return {void}
+ * @class FabricContractContext
+ * @example
+ * ```typescript
+ * // In a Fabric chaincode contract method
+ * const context = new FabricContractContext();
+ * // Optionally set values via the base Context API
+ * context.set('stub', ctx.stub);
+ * context.set('clientIdentity', ctx.clientIdentity);
+ * context.set('logger', contractLogger);
+ *
+ * // Access context properties
+ * const timestamp = context.timestamp;
+ * const creator = context.identity.getID();
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Contract
+ *   participant Context
+ *   participant Ledger
+ *   Contract->>Context: new FabricContractContext()
+ *   Contract->>Context: set('stub'|'clientIdentity'|'logger', ...)
+ *   Context-->>Contract: timestamp, identity, logger
+ *   Contract->>Ledger: Interact via stub
+ */
+export declare class FabricContractContext extends Context<FabricContractFlags> {
+    /**
+     * @description Creates a new FabricContractContext instance
+     * @summary Initializes the context with Fabric-specific flags
+     */
+    constructor();
+    /**
+     * @description Gets the chaincode stub
+     * @summary Returns the ChaincodeStub instance for interacting with the ledger
+     * @return {ChaincodeStub} The chaincode stub
+     */
+    get stub(): ChaincodeStub;
+    /**
+     * @description Gets the transaction timestamp
+     * @summary Overrides the base timestamp getter to use the stub's timestamp
+     * @return {Date} The transaction timestamp
+     */
+    get timestamp(): Date;
+    /**
+     * @description Gets the client identity
+     * @summary Returns the ClientIdentity instance for the transaction submitter
+     * @return {ClientIdentity} The client identity
+     */
+    get identity(): ClientIdentity;
+    /**
+     * @description Gets the logger
+     * @summary Returns the logger instance for the current context
+     * @return {any} The logger instance
+     */
+    get logger(): import("@decaf-ts/logging").Logger;
+}

package/lib/esm/contracts/ContractContext.js

@@ -0,0 +1,81 @@
+import { Context } from "@decaf-ts/db-decorators";
+/**
+ * @description Context class for Fabric chaincode operations
+ * @summary Provides access to Fabric-specific context elements like stub, identity, and logger to be used by repositories and adapters during contract execution.
+ * @template F - Flags specific to Fabric contract operations
+ * @param {object} [args] - Optional initialization arguments passed to the base Context
+ * @return {void}
+ * @class FabricContractContext
+ * @example
+ * ```typescript
+ * // In a Fabric chaincode contract method
+ * const context = new FabricContractContext();
+ * // Optionally set values via the base Context API
+ * context.set('stub', ctx.stub);
+ * context.set('clientIdentity', ctx.clientIdentity);
+ * context.set('logger', contractLogger);
+ *
+ * // Access context properties
+ * const timestamp = context.timestamp;
+ * const creator = context.identity.getID();
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Contract
+ *   participant Context
+ *   participant Ledger
+ *   Contract->>Context: new FabricContractContext()
+ *   Contract->>Context: set('stub'|'clientIdentity'|'logger', ...)
+ *   Context-->>Contract: timestamp, identity, logger
+ *   Contract->>Ledger: Interact via stub
+ */
+export class FabricContractContext extends Context {
+    /**
+     * @description Creates a new FabricContractContext instance
+     * @summary Initializes the context with Fabric-specific flags
+     */
+    constructor() {
+        super();
+    }
+    /**
+     * @description Gets the chaincode stub
+     * @summary Returns the ChaincodeStub instance for interacting with the ledger
+     * @return {ChaincodeStub} The chaincode stub
+     */
+    get stub() {
+        return this.get("stub");
+    }
+    /**
+     * @description Gets the transaction timestamp
+     * @summary Overrides the base timestamp getter to use the stub's timestamp
+     * @return {Date} The transaction timestamp
+     */
+    get timestamp() {
+        return this.stub.getDateTimestamp();
+    }
+    /**
+     * @description Gets the client identity
+     * @summary Returns the ClientIdentity instance for the transaction submitter
+     * @return {ClientIdentity} The client identity
+     */
+    get identity() {
+        //TODO: Find what is happening it seems FabricContractContext is being created with FabricContractContext instead of the transaction context
+        // return this.get("clientIdentity");
+        try {
+            return this.get("clientIdentity");
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (_) {
+            return this.get("identity");
+        }
+    }
+    /**
+     * @description Gets the logger
+     * @summary Returns the logger instance for the current context
+     * @return {any} The logger instance
+     */
+    get logger() {
+        return this.get("logger");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/contracts/ContractPrivateDataAdapter.d.ts

@@ -0,0 +1,74 @@
+import { ChaincodeStub, Iterators, StateQueryResponse } from "fabric-shim";
+import { FabricContractAdapter } from "./ContractAdapter";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Sequence, SequenceOptions } from "@decaf-ts/core";
+import { MangoQuery } from "@decaf-ts/for-couchdb";
+export declare class FabricContractPrivateDataAdapter extends FabricContractAdapter {
+    private readonly collections?;
+    /**
+     * @description Creates a new FabricContractAdapter instance
+     * @summary Initializes an adapter for interacting with the Fabric state database
+     * @param {void} scope - Not used in this adapter
+     * @param {string} [alias] - Optional alias for the adapter instance
+     */
+    constructor(scope: void, alias?: string, collections?: string[] | undefined);
+    Sequence(options: SequenceOptions): Promise<Sequence>;
+    /**
+     * @description Reads a record from the state database
+     * @summary Retrieves and deserializes a record from the Fabric state database
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier
+     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
+     * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record
+     */
+    read(tableName: string, id: string | number, instance: any, ...args: any[]): Promise<Record<string, any>>;
+    /**
+     * @description Deletes a record from the state database
+     * @summary Retrieves a record and then removes it from the Fabric state database
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier to delete
+     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
+     * @return {Promise<Record<string, any>>} Promise resolving to the deleted record
+     */
+    delete(tableName: string, id: string | number, instance: any, ...args: any[]): Promise<Record<string, any>>;
+    prepare<M extends Model>(model: M, pk: keyof M, ...args: any[]): {
+        record: Record<string, any>;
+        id: string;
+        transient?: Record<string, any>;
+    };
+    updatePrefix(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): (string | number | Record<string, any>)[];
+    putState(stub: ChaincodeStub, id: string, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
+    readState(stub: ChaincodeStub, tableName: string, id: string, instance: any, ...args: any[]): Promise<any[]>;
+    deleteState(stub: ChaincodeStub, tableName: string, id: string, instance: any, ...args: any[]): Promise<void>;
+    queryResult(stub: ChaincodeStub, rawInput: any, instance: any): Promise<Iterators.StateQueryIterator>;
+    queryResultPaginated(stub: ChaincodeStub, rawInput: any, limit: number | undefined, skip: number | undefined, instance: any): Promise<StateQueryResponse<Iterators.StateQueryIterator>>;
+    /**
+     * @description Executes a raw query against the state database
+     * @summary Performs a rich query using CouchDB syntax against the Fabric state database
+     * @template R - The return type
+     * @param {MangoQuery} rawInput - The Mango Query to execute
+     * @param {boolean} docsOnly - Whether to return only documents (not used in this implementation)
+     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
+     * @return {Promise<R>} Promise resolving to the query results
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant FabricContractAdapter
+     *   participant Stub
+     *   participant StateDB
+     *
+     *   Caller->>FabricContractAdapter: raw(rawInput, docsOnly, ctx)
+     *   FabricContractAdapter->>FabricContractAdapter: Extract limit and skip
+     *   alt With pagination
+     *     FabricContractAdapter->>Stub: getQueryResultWithPagination(query, limit, skip)
+     *   else Without pagination
+     *     FabricContractAdapter->>Stub: getQueryResult(query)
+     *   end
+     *   Stub->>StateDB: Execute query
+     *   StateDB-->>Stub: Iterator
+     *   Stub-->>FabricContractAdapter: Iterator
+     *   FabricContractAdapter->>FabricContractAdapter: resultIterator(log, iterator)
+     *   FabricContractAdapter-->>Caller: results
+     */
+    raw<R>(rawInput: MangoQuery, docsOnly: boolean, ...args: any[]): Promise<R>;
+}

package/lib/esm/contracts/ContractPrivateDataAdapter.js

@@ -0,0 +1,277 @@
+import { FabricContractAdapter } from "./ContractAdapter.js";
+import { NotFoundError, SerializationError, } from "@decaf-ts/db-decorators";
+import { MISSING_PRIVATE_DATA_REGEX, modelToPrivate, processModel, } from "./private-data.js";
+import { UnauthorizedPrivateDataAccess } from "./../shared/errors.js";
+import { FabricContractSequence } from "./FabricContractSequence.js";
+import { CouchDBKeys } from "@decaf-ts/for-couchdb";
+export class FabricContractPrivateDataAdapter extends FabricContractAdapter {
+    /**
+     * @description Creates a new FabricContractAdapter instance
+     * @summary Initializes an adapter for interacting with the Fabric state database
+     * @param {void} scope - Not used in this adapter
+     * @param {string} [alias] - Optional alias for the adapter instance
+     */
+    constructor(scope, alias, collections) {
+        super(scope, alias);
+        this.collections = collections;
+        this.collections = collections || [];
+    }
+    async Sequence(options) {
+        return new FabricContractSequence(options, this, this.collections);
+    }
+    /**
+     * @description Reads a record from the state database
+     * @summary Retrieves and deserializes a record from the Fabric state database
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier
+     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
+     * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record
+     */
+    async read(tableName, id, instance, ...args) {
+        const { stub, logger } = args.pop();
+        const log = logger.for(this.read);
+        let model;
+        try {
+            const results = await this.readState(stub, tableName, id.toString(), instance);
+            if (results.length < 1) {
+                log.debug(`No record found for id ${id} in ${tableName} table`);
+                throw new NotFoundError(`No record found for id ${id} in ${tableName} table`);
+            }
+            else if (results.length < 2) {
+                log.debug(`No record found for id ${id} in ${tableName} table`);
+                model = results.pop();
+            }
+            else {
+                model = this.mergeModels(results);
+            }
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        return model;
+    }
+    /**
+     * @description Deletes a record from the state database
+     * @summary Retrieves a record and then removes it from the Fabric state database
+     * @param {string} tableName - The name of the table/collection
+     * @param {string | number} id - The record identifier to delete
+     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
+     * @return {Promise<Record<string, any>>} Promise resolving to the deleted record
+     */
+    async delete(tableName, id, instance, ...args) {
+        const ctx = args.pop();
+        const { stub, logger } = ctx;
+        const log = logger.for(this.delete);
+        args.push(ctx);
+        let model;
+        try {
+            model = await this.read(tableName, id, instance, ...args);
+            log.verbose(`deleting entry with pk ${id} from ${tableName} table`);
+            this.deleteState(stub, tableName, id.toString(), instance);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        return model;
+    }
+    prepare(model, pk, ...args) {
+        const { stub, logger } = args.pop();
+        const tableName = args.shift();
+        const log = logger.for(this.prepare);
+        const split = processModel(this, model);
+        // if ((model as any)[PersistenceKeys.METADATA]) {
+        //   log.silly(
+        //     `Passing along persistence metadata for ${(model as any)[PersistenceKeys.METADATA]}`
+        //   );
+        //   Object.defineProperty(split.result, PersistenceKeys.METADATA, {
+        //     enumerable: false,
+        //     writable: false,
+        //     configurable: true,
+        //     value: (model as any)[PersistenceKeys.METADATA],
+        //   });
+        // }
+        log.info(`Preparing record for ${tableName} table with pk ${model[pk]}`);
+        return {
+            record: split.privateData,
+            id: stub.createCompositeKey(tableName, [String(model[pk])]),
+            transient: split.transient,
+        };
+    }
+    updatePrefix(tableName, id, model, ...args) {
+        const ctx = args.pop();
+        const collections = Object.keys(model);
+        for (const collection of collections) {
+            model[collection][CouchDBKeys.TABLE] = tableName;
+        }
+        const record = model;
+        return [tableName, id, record, ctx];
+    }
+    async putState(stub, id, model, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        const collections = Object.keys(model);
+        let res = {};
+        let data;
+        for (const collection of collections) {
+            res = model[collection];
+            try {
+                data = Buffer.from(FabricContractAdapter.serializer.serialize(model[collection]));
+            }
+            catch (e) {
+                throw new SerializationError(`Failed to serialize record with id ${id}: ${e}`);
+            }
+            await stub.putPrivateData(collection, id.toString(), data);
+        }
+        return res;
+    }
+    async readState(stub, tableName, id, instance, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        const composedKey = stub.createCompositeKey(tableName, [String(id)]);
+        const model = modelToPrivate(instance);
+        const collections = Object.keys(model.private);
+        const results = [];
+        for (const collection of collections) {
+            try {
+                let res = await stub.getPrivateData(collection, composedKey);
+                if (res.toString() === "") {
+                    throw new NotFoundError(`Entry with id ${id} doesn't exist...`);
+                }
+                try {
+                    res = FabricContractAdapter.serializer.deserialize(res.toString()
+                    // model.constructor.name
+                    );
+                }
+                catch (e) {
+                    throw new SerializationError(`Failed to parse private data: ${e}`);
+                }
+                results.push(res);
+            }
+            catch (e) {
+                if (MISSING_PRIVATE_DATA_REGEX.test(e.message))
+                    throw new UnauthorizedPrivateDataAccess(e);
+                throw e;
+            }
+        }
+        return results;
+    }
+    async deleteState(stub, tableName, id, instance, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        const composedKey = stub.createCompositeKey(tableName, [String(id)]);
+        const model = modelToPrivate(instance);
+        const collections = Object.keys(model.private);
+        for (const collection of collections) {
+            await stub.deletePrivateData(collection, composedKey);
+        }
+    }
+    async queryResult(stub, rawInput, instance) {
+        const privateData = modelToPrivate(instance).private;
+        const collection = Object.keys(privateData)[0] || "";
+        const result = (await stub.getPrivateDataQueryResult(collection, JSON.stringify(rawInput)));
+        const iterator = result.iterator;
+        return iterator;
+    }
+    async queryResultPaginated(stub, rawInput, limit = 250, skip = undefined, instance) {
+        const privateData = modelToPrivate(instance).private;
+        const collection = Object.keys(privateData)[0] || "";
+        const iterator = await stub.getPrivateDataQueryResult(collection, JSON.stringify(rawInput));
+        const results = [];
+        let count = 0;
+        let reachedBookmark = skip ? false : true;
+        let lastKey = null;
+        while (true) {
+            const res = await iterator.next();
+            if (res.value && res.value.value.toString()) {
+                const recordKey = res.value.key;
+                const recordValue = res.value.value.toString("utf8");
+                // If we have a skip, skip until we reach it
+                if (!reachedBookmark) {
+                    if (recordKey === skip?.toString()) {
+                        reachedBookmark = true;
+                    }
+                    continue;
+                }
+                results.push({ Key: recordKey, Record: JSON.parse(recordValue) });
+                lastKey = recordKey;
+                count++;
+                if (count >= limit) {
+                    await iterator.close();
+                    return {
+                        iterator: results,
+                        metadata: {
+                            fetchedRecordsCount: results.length,
+                            bookmark: lastKey,
+                        },
+                    };
+                }
+            }
+            if (res.done) {
+                await iterator.close();
+                return {
+                    iterator: results,
+                    metadata: {
+                        fetchedRecordsCount: results.length,
+                        bookmark: "",
+                    },
+                };
+            }
+        }
+        // return (await stub.getQueryResultWithPagination(
+        //   JSON.stringify(rawInput),
+        //   limit,
+        //   skip?.toString()
+        // )) as StateQueryResponse<Iterators.StateQueryIterator>;
+    }
+    /**
+     * @description Executes a raw query against the state database
+     * @summary Performs a rich query using CouchDB syntax against the Fabric state database
+     * @template R - The return type
+     * @param {MangoQuery} rawInput - The Mango Query to execute
+     * @param {boolean} docsOnly - Whether to return only documents (not used in this implementation)
+     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
+     * @return {Promise<R>} Promise resolving to the query results
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant FabricContractAdapter
+     *   participant Stub
+     *   participant StateDB
+     *
+     *   Caller->>FabricContractAdapter: raw(rawInput, docsOnly, ctx)
+     *   FabricContractAdapter->>FabricContractAdapter: Extract limit and skip
+     *   alt With pagination
+     *     FabricContractAdapter->>Stub: getQueryResultWithPagination(query, limit, skip)
+     *   else Without pagination
+     *     FabricContractAdapter->>Stub: getQueryResult(query)
+     *   end
+     *   Stub->>StateDB: Execute query
+     *   StateDB-->>Stub: Iterator
+     *   Stub-->>FabricContractAdapter: Iterator
+     *   FabricContractAdapter->>FabricContractAdapter: resultIterator(log, iterator)
+     *   FabricContractAdapter-->>Caller: results
+     */
+    async raw(rawInput, docsOnly, ...args) {
+        const { stub, logger } = args.pop();
+        const log = logger.for(this.raw);
+        const { skip, limit } = rawInput;
+        const instance = args.shift();
+        let iterator;
+        if (limit || skip) {
+            delete rawInput["limit"];
+            delete rawInput["skip"];
+            log.debug(`Retrieving paginated iterator: limit: ${limit}/ skip: ${skip}`);
+            const response = (await this.queryResultPaginated(stub, rawInput, limit || 250, skip?.toString(), instance));
+            iterator = response.iterator;
+        }
+        else {
+            log.debug("Retrieving iterator");
+            iterator = (await this.queryResult(stub, rawInput, instance));
+        }
+        log.debug("Iterator acquired");
+        const results = (await this.resultIterator(log, iterator));
+        log.debug(`returning {0} results`, `${Array.isArray(results) ? results.length : 1}`);
+        return results;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ContractPrivateDataAdapter.js","sourceRoot":"","sources":["../../../src/contracts/ContractPrivateDataAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChaincodeStub, Iterators, StateQueryResponse } from \"fabric-shim\";\nimport { FabricContractAdapter } from \"./ContractAdapter\";\nimport {\n  BaseError,\n  NotFoundError,\n  SerializationError,\n} from \"@decaf-ts/db-decorators\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport {\n  MISSING_PRIVATE_DATA_REGEX,\n  modelToPrivate,\n  processModel,\n} from \"./private-data\";\nimport { UnauthorizedPrivateDataAccess } from \"../shared/errors\";\nimport { FabricContractSequence } from \"./FabricContractSequence\";\nimport { Sequence, SequenceOptions } from \"@decaf-ts/core\";\nimport { FabricContractContext } from \"./ContractContext\";\nimport { CouchDBKeys, MangoQuery } from \"@decaf-ts/for-couchdb\";\n\nexport class FabricContractPrivateDataAdapter extends FabricContractAdapter {\n  /**\n   * @description Creates a new FabricContractAdapter instance\n   * @summary Initializes an adapter for interacting with the Fabric state database\n   * @param {void} scope - Not used in this adapter\n   * @param {string} [alias] - Optional alias for the adapter instance\n   */\n  constructor(\n    scope: void,\n    alias?: string,\n    private readonly collections?: string[]\n  ) {\n    super(scope, alias);\n    this.collections = collections || [];\n  }\n\n  override async Sequence(options: SequenceOptions): Promise<Sequence> {\n    return new FabricContractSequence(options, this, this.collections);\n  }\n\n  /**\n   * @description Reads a record from the state database\n   * @summary Retrieves and deserializes a record from the Fabric state database\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record\n   */\n  override async read(\n    tableName: string,\n    id: string | number,\n    instance: any,\n    ...args: any[]\n  ): Promise<Record<string, any>> {\n    const { stub, logger } = args.pop();\n    const log = logger.for(this.read);\n\n    let model: Record<string, any>;\n    try {\n      const results = await this.readState(\n        stub,\n        tableName,\n        id.toString(),\n        instance\n      );\n\n      if (results.length < 1) {\n        log.debug(`No record found for id ${id} in ${tableName} table`);\n        throw new NotFoundError(\n          `No record found for id ${id} in ${tableName} table`\n        );\n      } else if (results.length < 2) {\n        log.debug(`No record found for id ${id} in ${tableName} table`);\n        model = results.pop() as Record<string, any>;\n      } else {\n        model = this.mergeModels(results);\n      }\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n\n    return model;\n  }\n\n  /**\n   * @description Deletes a record from the state database\n   * @summary Retrieves a record and then removes it from the Fabric state database\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier to delete\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<Record<string, any>>} Promise resolving to the deleted record\n   */\n  override async delete(\n    tableName: string,\n    id: string | number,\n    instance: any,\n    ...args: any[]\n  ): Promise<Record<string, any>> {\n    const ctx = args.pop();\n    const { stub, logger } = ctx;\n    const log = logger.for(this.delete);\n\n    args.push(ctx);\n\n    let model: Record<string, any>;\n    try {\n      model = await this.read(tableName, id, instance, ...args);\n      log.verbose(`deleting entry with pk ${id} from ${tableName} table`);\n      this.deleteState(stub, tableName, id.toString(), instance);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n\n    return model;\n  }\n  override prepare<M extends Model>(\n    model: M,\n    pk: keyof M,\n    ...args: any[]\n  ): {\n    record: Record<string, any>;\n    id: string;\n    transient?: Record<string, any>;\n  } {\n    const { stub, logger } = args.pop();\n    const tableName = args.shift();\n    const log = logger.for(this.prepare);\n\n    const split = processModel(this, model);\n    // if ((model as any)[PersistenceKeys.METADATA]) {\n    //   log.silly(\n    //     `Passing along persistence metadata for ${(model as any)[PersistenceKeys.METADATA]}`\n    //   );\n    //   Object.defineProperty(split.result, PersistenceKeys.METADATA, {\n    //     enumerable: false,\n    //     writable: false,\n    //     configurable: true,\n    //     value: (model as any)[PersistenceKeys.METADATA],\n    //   });\n    // }\n\n    log.info(`Preparing record for ${tableName} table with pk ${model[pk]}`);\n\n    return {\n      record: split.privateData as Record<string, any>,\n      id: stub.createCompositeKey(tableName, [String(model[pk])]),\n      transient: split.transient,\n    };\n  }\n\n  override updatePrefix(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): (string | number | Record<string, any>)[] {\n    const ctx: FabricContractContext = args.pop();\n    const collections = Object.keys(model);\n\n    for (const collection of collections) {\n      model[collection][CouchDBKeys.TABLE] = tableName;\n    }\n\n    const record: Record<string, any> = model;\n\n    return [tableName, id, record, ctx];\n  }\n  override async putState(\n    stub: ChaincodeStub,\n    id: string,\n    model: Record<string, any>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ) {\n    const collections = Object.keys(model);\n    let res: Record<string, any> = {};\n    let data: Buffer;\n\n    for (const collection of collections) {\n      res = model![collection];\n      try {\n        data = Buffer.from(\n          FabricContractAdapter.serializer.serialize(\n            model![collection] as Model\n          )\n        );\n      } catch (e: unknown) {\n        throw new SerializationError(\n          `Failed to serialize record with id ${id}: ${e}`\n        );\n      }\n      await stub.putPrivateData(collection, id.toString(), data);\n    }\n\n    return res;\n  }\n\n  override async readState(\n    stub: ChaincodeStub,\n    tableName: string,\n    id: string,\n    instance: any,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ) {\n    const composedKey = stub.createCompositeKey(tableName, [String(id)]);\n    const model = modelToPrivate(instance);\n    const collections = Object.keys(model.private!);\n    const results: any[] = [];\n\n    for (const collection of collections) {\n      try {\n        let res: Buffer | Record<string, any> = await stub.getPrivateData(\n          collection,\n          composedKey\n        );\n        if (res.toString() === \"\") {\n          throw new NotFoundError(`Entry with id ${id} doesn't exist...`);\n        }\n        try {\n          res = FabricContractAdapter.serializer.deserialize(\n            res.toString()\n            // model.constructor.name\n          );\n        } catch (e: unknown) {\n          throw new SerializationError(`Failed to parse private data: ${e}`);\n        }\n        results.push(res);\n      } catch (e: unknown) {\n        if (MISSING_PRIVATE_DATA_REGEX.test((e as BaseError).message))\n          throw new UnauthorizedPrivateDataAccess(e as BaseError);\n        throw e;\n      }\n    }\n\n    return results;\n  }\n\n  override async deleteState(\n    stub: ChaincodeStub,\n    tableName: string,\n    id: string,\n    instance: any,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ) {\n    const composedKey = stub.createCompositeKey(tableName, [String(id)]);\n    const model = modelToPrivate(instance);\n    const collections = Object.keys(model.private!);\n\n    for (const collection of collections) {\n      await stub.deletePrivateData(collection, composedKey);\n    }\n  }\n\n  override async queryResult(\n    stub: ChaincodeStub,\n    rawInput: any,\n    instance: any\n  ): Promise<Iterators.StateQueryIterator> {\n    const privateData = modelToPrivate(instance).private!;\n    const collection = Object.keys(privateData)[0] || \"\";\n\n    const result = (await stub.getPrivateDataQueryResult(\n      collection,\n      JSON.stringify(rawInput)\n    )) as any;\n\n    const iterator = result.iterator as Iterators.StateQueryIterator;\n\n    return iterator;\n  }\n\n  override async queryResultPaginated(\n    stub: ChaincodeStub,\n    rawInput: any,\n    limit: number = 250,\n    skip: number | undefined = undefined,\n    instance: any\n  ): Promise<StateQueryResponse<Iterators.StateQueryIterator>> {\n    const privateData = modelToPrivate(instance).private!;\n    const collection = Object.keys(privateData)[0] || \"\";\n\n    const iterator = await stub.getPrivateDataQueryResult(\n      collection,\n      JSON.stringify(rawInput)\n    );\n\n    const results: any[] = [];\n    let count = 0;\n    let reachedBookmark = skip ? false : true;\n    let lastKey: string | null = null;\n\n    while (true) {\n      const res = await iterator.next();\n\n      if (res.value && res.value.value.toString()) {\n        const recordKey = res.value.key;\n        const recordValue = (res.value.value as any).toString(\"utf8\");\n\n        // If we have a skip, skip until we reach it\n        if (!reachedBookmark) {\n          if (recordKey === skip?.toString()) {\n            reachedBookmark = true;\n          }\n          continue;\n        }\n\n        results.push({ Key: recordKey, Record: JSON.parse(recordValue) });\n        lastKey = recordKey;\n        count++;\n\n        if (count >= limit) {\n          await iterator.close();\n          return {\n            iterator: results as unknown as Iterators.StateQueryIterator,\n            metadata: {\n              fetchedRecordsCount: results.length,\n              bookmark: lastKey,\n            },\n          };\n        }\n      }\n\n      if (res.done) {\n        await iterator.close();\n        return {\n          iterator: results as unknown as Iterators.StateQueryIterator,\n          metadata: {\n            fetchedRecordsCount: results.length,\n            bookmark: \"\",\n          },\n        };\n      }\n    }\n    // return (await stub.getQueryResultWithPagination(\n    //   JSON.stringify(rawInput),\n    //   limit,\n    //   skip?.toString()\n    // )) as StateQueryResponse<Iterators.StateQueryIterator>;\n  }\n\n  /**\n   * @description Executes a raw query against the state database\n   * @summary Performs a rich query using CouchDB syntax against the Fabric state database\n   * @template R - The return type\n   * @param {MangoQuery} rawInput - The Mango Query to execute\n   * @param {boolean} docsOnly - Whether to return only documents (not used in this implementation)\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<R>} Promise resolving to the query results\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant FabricContractAdapter\n   *   participant Stub\n   *   participant StateDB\n   *\n   *   Caller->>FabricContractAdapter: raw(rawInput, docsOnly, ctx)\n   *   FabricContractAdapter->>FabricContractAdapter: Extract limit and skip\n   *   alt With pagination\n   *     FabricContractAdapter->>Stub: getQueryResultWithPagination(query, limit, skip)\n   *   else Without pagination\n   *     FabricContractAdapter->>Stub: getQueryResult(query)\n   *   end\n   *   Stub->>StateDB: Execute query\n   *   StateDB-->>Stub: Iterator\n   *   Stub-->>FabricContractAdapter: Iterator\n   *   FabricContractAdapter->>FabricContractAdapter: resultIterator(log, iterator)\n   *   FabricContractAdapter-->>Caller: results\n   */\n  override async raw<R>(\n    rawInput: MangoQuery,\n    docsOnly: boolean,\n    ...args: any[]\n  ): Promise<R> {\n    const { stub, logger } = args.pop();\n    const log = logger.for(this.raw);\n    const { skip, limit } = rawInput;\n    const instance = args.shift();\n    let iterator: Iterators.StateQueryIterator;\n    if (limit || skip) {\n      delete rawInput[\"limit\"];\n      delete rawInput[\"skip\"];\n      log.debug(\n        `Retrieving paginated iterator: limit: ${limit}/ skip: ${skip}`\n      );\n      const response: StateQueryResponse<Iterators.StateQueryIterator> =\n        (await this.queryResultPaginated(\n          stub,\n          rawInput,\n          limit || 250,\n          (skip as any)?.toString(),\n          instance\n        )) as StateQueryResponse<Iterators.StateQueryIterator>;\n      iterator = response.iterator;\n    } else {\n      log.debug(\"Retrieving iterator\");\n      iterator = (await this.queryResult(\n        stub,\n        rawInput,\n        instance\n      )) as Iterators.StateQueryIterator;\n    }\n    log.debug(\"Iterator acquired\");\n\n    const results = (await this.resultIterator(log, iterator)) as R;\n    log.debug(\n      `returning {0} results`,\n      `${Array.isArray(results) ? results.length : 1}`\n    );\n    return results;\n  }\n}\n"]}