@decaf-ts/for-fabric 0.0.2

package/lib/contracts/ContractPrivateDataAdapter.cjs

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FabricContractPrivateDataAdapter = void 0;
+const ContractAdapter_1 = require("./ContractAdapter.cjs");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const private_data_1 = require("./private-data.cjs");
+const errors_1 = require("./../shared/errors.cjs");
+const FabricContractSequence_1 = require("./FabricContractSequence.cjs");
+const for_couchdb_1 = require("@decaf-ts/for-couchdb");
+class FabricContractPrivateDataAdapter extends ContractAdapter_1.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_1.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 db_decorators_1.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 = (0, private_data_1.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][for_couchdb_1.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(ContractAdapter_1.FabricContractAdapter.serializer.serialize(model[collection]));
+            }
+            catch (e) {
+                throw new db_decorators_1.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 = (0, private_data_1.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 db_decorators_1.NotFoundError(`Entry with id ${id} doesn't exist...`);
+                }
+                try {
+                    res = ContractAdapter_1.FabricContractAdapter.serializer.deserialize(res.toString()
+                    // model.constructor.name
+                    );
+                }
+                catch (e) {
+                    throw new db_decorators_1.SerializationError(`Failed to parse private data: ${e}`);
+                }
+                results.push(res);
+            }
+            catch (e) {
+                if (private_data_1.MISSING_PRIVATE_DATA_REGEX.test(e.message))
+                    throw new errors_1.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 = (0, private_data_1.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 = (0, private_data_1.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 = (0, private_data_1.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;
+    }
+}
+exports.FabricContractPrivateDataAdapter = FabricContractPrivateDataAdapter;
+//# 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"]}

package/lib/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>;
+}