@decaf-ts/for-fabric 0.0.2

package/lib/contracts/crud/crud-contract.cjs

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FabricCrudContract = void 0;
+const ContractAdapter_1 = require("./../ContractAdapter.cjs");
+const fabric_contract_api_1 = require("fabric-contract-api");
+const core_1 = require("@decaf-ts/core");
+const DeterministicSerializer_1 = require("./../../shared/DeterministicSerializer.cjs");
+const logging_1 = require("@decaf-ts/logging");
+const private_data_1 = require("./../private-data.cjs");
+const ContractPrivateDataAdapter_1 = require("./../ContractPrivateDataAdapter.cjs");
+/**
+ * @description Base contract class for CRUD operations in Fabric chaincode
+ * @summary Provides standard create, read, update, and delete operations for models in Fabric chaincode
+ * @template M - Type extending Model
+ * @class FabricCrudContract
+ * @extends {Contract}
+ * @example
+ * ```typescript
+ * // Define a model
+ * @table('assets')
+ * class Asset extends Model {
+ *   @id()
+ *   id: string;
+ *
+ *   @property()
+ *   data: string;
+ * }
+ *
+ * // Create a contract that extends FabricCrudContract
+ * export class AssetContract extends FabricCrudContract<Asset> {
+ *   constructor() {
+ *     super('AssetContract', Asset);
+ *   }
+ *
+ *   // Add custom methods as needed
+ *   async getAssetHistory(ctx: Context, id: string): Promise<any[]> {
+ *     // Custom implementation
+ *   }
+ * }
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Contract
+ *   participant Repository
+ *   participant Adapter
+ *   participant StateDB
+ *
+ *   Client->>Contract: create(ctx, model)
+ *   Contract->>Repository: repository(ctx)
+ *   Contract->>Repository: create(model, ctx)
+ *   Repository->>Adapter: create(tableName, id, record, transient, ctx)
+ *   Adapter->>StateDB: putState(id, serializedData)
+ *   StateDB-->>Adapter: Success
+ *   Adapter-->>Repository: record
+ *   Repository-->>Contract: model
+ *   Contract-->>Client: model
+ */
+class FabricCrudContract extends fabric_contract_api_1.Contract {
+    static { this.serializer = new DeterministicSerializer_1.DeterministicSerializer(); }
+    /**
+     * @description Creates a new FabricCrudContract instance
+     * @summary Initializes a contract with a name and model class
+     * @param {string} name - The name of the contract
+     * @param {Constructor<M>} clazz - The model constructor
+     */
+    constructor(name, clazz) {
+        super(name);
+        this.clazz = clazz;
+        this.initialized = false;
+        FabricCrudContract.adapter = this.getAdapter(clazz);
+        this.repo = core_1.Repository.forModel(clazz, FabricCrudContract.adapter.alias);
+    }
+    getAdapter(clazz) {
+        const instance = new clazz();
+        if ((0, private_data_1.isModelPrivate)(instance)) {
+            const pvt = (0, private_data_1.modelToPrivate)(instance);
+            const collections = Object.keys(pvt.private);
+            return new ContractPrivateDataAdapter_1.FabricContractPrivateDataAdapter(undefined, "fabric-private-data-adapter", collections);
+        }
+        else {
+            return new ContractAdapter_1.FabricContractAdapter(undefined, "fabric-public-data-adapter");
+        }
+    }
+    /**
+     * @description Creates a logger for a specific chaincode context
+     * @summary Returns a ContractLogger instance configured for the current context
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @return {ContractLogger} The logger instance
+     */
+    logFor(ctx) {
+        return logging_1.Logging.for(FabricCrudContract.name, {}, ctx);
+    }
+    /**
+     * @description Creates a single model in the state database
+     * @summary Delegates to the repository's create method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {M} model - The model to create
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M>} Promise resolving to the created model
+     */
+    async create(ctx, model, ...args) {
+        const log = this.logFor(ctx).for(this.create);
+        if (typeof model === "string")
+            model = this.deserialize(model);
+        log.info(`Creating model: ${JSON.stringify(model)}`);
+        const transient = this.getTransientData(ctx);
+        log.info(`Merging transient data...`);
+        model = this.repo.merge(model, transient);
+        return this.repo.create(model, ctx, ...args);
+    }
+    /**
+     * @description Reads a single model from the state database
+     * @summary Delegates to the repository's read method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {string | number} key - The key of the model to read
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M>} Promise resolving to the retrieved model
+     */
+    async read(ctx, key, ...args) {
+        const log = this.logFor(ctx).for(this.read);
+        log.info(`reading entry with pk ${key} `);
+        return this.repo.read(key, ctx, ...args);
+    }
+    getTransientData(ctx) {
+        const transientMap = ctx.stub.getTransient();
+        let transient = {};
+        if (transientMap.has(this.repo.tableName)) {
+            transient = JSON.parse(transientMap.get(this.repo.tableName)?.toString("utf8"));
+        }
+        return transient;
+    }
+    /**
+     * @description Updates a single model in the state database
+     * @summary Delegates to the repository's update method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {M} model - The model to update
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M>} Promise resolving to the updated model
+     */
+    async update(ctx, model, ...args) {
+        const log = this.logFor(ctx).for(this.update);
+        if (typeof model === "string")
+            model = this.deserialize(model);
+        log.info(`Updating model: ${JSON.stringify(model)}`);
+        const transient = this.getTransientData(ctx);
+        log.info(`Merging transient data...`);
+        model = this.repo.merge(model, transient);
+        return this.repo.update(model, ctx, ...args);
+    }
+    /**
+     * @description Deletes a single model from the state database
+     * @summary Delegates to the repository's delete method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {string | number} key - The key of the model to delete
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M>} Promise resolving to the deleted model
+     */
+    async delete(ctx, key, ...args) {
+        const log = this.logFor(ctx).for(this.delete);
+        log.info(`deleting entry with pk ${key} `);
+        return this.repo.delete(String(key), ctx, ...args);
+    }
+    /**
+     * @description Deletes multiple models from the state database
+     * @summary Delegates to the repository's deleteAll method
+     * @param {string[] | number[]} keys - The keys of the models to delete
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M[]>} Promise resolving to the deleted models
+     */
+    async deleteAll(ctx, keys, ...args) {
+        if (typeof keys === "string")
+            keys = JSON.parse(keys);
+        return this.repo.deleteAll(keys, ctx, ...args);
+    }
+    /**
+     * @description Reads multiple models from the state database
+     * @summary Delegates to the repository's readAll method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {string[] | number[]} keys - The keys of the models to read
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M[]>} Promise resolving to the retrieved models
+     */
+    async readAll(ctx, keys, ...args) {
+        if (typeof keys === "string")
+            keys = JSON.parse(keys);
+        return this.repo.readAll(keys, ctx, ...args);
+    }
+    /**
+     * @description Updates multiple models in the state database
+     * @summary Delegates to the repository's updateAll method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {M[]} models - The models to update
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M[]>} Promise resolving to the updated models
+     */
+    async updateAll(ctx, models, ...args) {
+        const log = this.logFor(ctx).for(this.updateAll);
+        if (typeof models === "string")
+            models = JSON.parse(models)
+                .map((m) => this.deserialize(m))
+                .map((m) => new this.clazz(m));
+        log.info(`updating ${models.length} entries to the table`);
+        return this.repo.updateAll(models, ctx, ...args);
+    }
+    /**
+     * @description Executes a raw query against the state database
+     * @summary Delegates to the repository's raw method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {any} rawInput - The query to execute
+     * @param {boolean} docsOnly - Whether to return only documents
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<any>} Promise resolving to the query results
+     */
+    async raw(ctx, rawInput, docsOnly, ...args) {
+        if (typeof rawInput === "string")
+            rawInput = JSON.parse(rawInput);
+        return this.repo.raw(rawInput, docsOnly, ctx, ...args);
+    }
+    serialize(model) {
+        return FabricCrudContract.serializer.serialize(model);
+    }
+    deserialize(str) {
+        return FabricCrudContract.serializer.deserialize(str);
+    }
+    async init(ctx) {
+        const log = this.logFor(ctx).for(this.init);
+        log.info(`Running contract initialization...`);
+        this.initialized = true;
+        log.info(`Contract initialization completed.`);
+    }
+    async healthcheck(ctx) {
+        const log = this.logFor(ctx).for(this.healthcheck);
+        log.info(`Running Healthcheck: ${this.initialized}...`);
+        return { healthcheck: this.initialized };
+    }
+    /**
+     * @description Creates multiple models in the state database
+     * @summary Delegates to the repository's createAll method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {M[]} models - The models to create
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M[]>} Promise resolving to the created models
+     */
+    async createAll(ctx, models, ...args) {
+        const log = this.logFor(ctx).for(this.createAll);
+        if (typeof models === "string")
+            models = JSON.parse(models)
+                .map((m) => this.deserialize(m))
+                .map((m) => new this.clazz(m));
+        log.info(`adding ${models.length} entries to the table`);
+        return this.repo.createAll(models, ctx, ...args);
+    }
+}
+exports.FabricCrudContract = FabricCrudContract;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crud-contract.js","sourceRoot":"","sources":["../../../src/contracts/crud/crud-contract.ts"],"names":[],"mappings":"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","sourcesContent":["import { FabricContractAdapter } from \"../ContractAdapter\";\nimport { Context, Contract, Context as Ctx } from \"fabric-contract-api\";\nimport { Constructor, Model, Serializer } from \"@decaf-ts/decorator-validation\";\nimport { Repository } from \"@decaf-ts/core\";\nimport { FabricContractRepository } from \"../FabricContractRepository\";\nimport { DeterministicSerializer } from \"../../shared/DeterministicSerializer\";\nimport { MangoQuery } from \"@decaf-ts/for-couchdb\";\nimport { Checkable, healthcheck } from \"../../shared/interfaces/Checkable\";\nimport { ContractLogger } from \"../logging\";\nimport { Logging } from \"@decaf-ts/logging\";\nimport { isModelPrivate, modelToPrivate } from \"../private-data\";\nimport { FabricContractPrivateDataAdapter } from \"../ContractPrivateDataAdapter\";\n\n/**\n * @description Base contract class for CRUD operations in Fabric chaincode\n * @summary Provides standard create, read, update, and delete operations for models in Fabric chaincode\n * @template M - Type extending Model\n * @class FabricCrudContract\n * @extends {Contract}\n * @example\n * ```typescript\n * // Define a model\n * @table('assets')\n * class Asset extends Model {\n *   @id()\n *   id: string;\n *\n *   @property()\n *   data: string;\n * }\n *\n * // Create a contract that extends FabricCrudContract\n * export class AssetContract extends FabricCrudContract<Asset> {\n *   constructor() {\n *     super('AssetContract', Asset);\n *   }\n *\n *   // Add custom methods as needed\n *   async getAssetHistory(ctx: Context, id: string): Promise<any[]> {\n *     // Custom implementation\n *   }\n * }\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Contract\n *   participant Repository\n *   participant Adapter\n *   participant StateDB\n *\n *   Client->>Contract: create(ctx, model)\n *   Contract->>Repository: repository(ctx)\n *   Contract->>Repository: create(model, ctx)\n *   Repository->>Adapter: create(tableName, id, record, transient, ctx)\n *   Adapter->>StateDB: putState(id, serializedData)\n *   StateDB-->>Adapter: Success\n *   Adapter-->>Repository: record\n *   Repository-->>Contract: model\n *   Contract-->>Client: model\n */\nexport abstract class FabricCrudContract<M extends Model>\n  extends Contract\n  implements Checkable\n{\n  /**\n   * @description Shared adapter instance for all contract instances\n   */\n  protected static adapter: FabricContractAdapter;\n\n  protected readonly repo: FabricContractRepository<M>;\n\n  protected static readonly serializer = new DeterministicSerializer();\n\n  protected initialized: boolean = false;\n\n  /**\n   * @description Creates a new FabricCrudContract instance\n   * @summary Initializes a contract with a name and model class\n   * @param {string} name - The name of the contract\n   * @param {Constructor<M>} clazz - The model constructor\n   */\n  protected constructor(\n    name: string,\n    protected readonly clazz: Constructor<M>\n  ) {\n    super(name);\n    FabricCrudContract.adapter = this.getAdapter(clazz);\n    this.repo = Repository.forModel(clazz, FabricCrudContract.adapter.alias);\n  }\n\n  protected getAdapter(clazz: Constructor<M>): FabricContractAdapter {\n    const instance = new clazz();\n\n    if (isModelPrivate(instance)) {\n      const pvt = modelToPrivate(instance);\n      const collections = Object.keys(pvt.private!);\n\n      return new FabricContractPrivateDataAdapter(\n        undefined,\n        \"fabric-private-data-adapter\",\n        collections\n      );\n    } else {\n      return new FabricContractAdapter(undefined, \"fabric-public-data-adapter\");\n    }\n  }\n\n  /**\n   * @description Creates a logger for a specific chaincode context\n   * @summary Returns a ContractLogger instance configured for the current context\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @return {ContractLogger} The logger instance\n   */\n  public logFor(ctx: Context): ContractLogger {\n    return Logging.for(FabricCrudContract.name, {}, ctx) as ContractLogger;\n  }\n\n  /**\n   * @description Creates a single model in the state database\n   * @summary Delegates to the repository's create method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {M} model - The model to create\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M>} Promise resolving to the created model\n   */\n  async create(\n    ctx: Ctx,\n    model: string | M,\n    ...args: any[]\n  ): Promise<string | M> {\n    const log = this.logFor(ctx).for(this.create);\n\n    if (typeof model === \"string\") model = this.deserialize<M>(model) as any;\n\n    log.info(`Creating model: ${JSON.stringify(model)}`);\n\n    const transient = this.getTransientData(ctx);\n\n    log.info(`Merging transient data...`);\n    model = (this.repo as any).merge(model as M, transient);\n\n    return this.repo.create(model as unknown as M, ctx, ...args);\n  }\n\n  /**\n   * @description Reads a single model from the state database\n   * @summary Delegates to the repository's read method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {string | number} key - The key of the model to read\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M>} Promise resolving to the retrieved model\n   */\n  async read(\n    ctx: Ctx,\n    key: string | number,\n    ...args: any[]\n  ): Promise<M | string> {\n    const log = this.logFor(ctx).for(this.read);\n\n    log.info(`reading entry with pk ${key} `);\n\n    return this.repo.read(key, ctx, ...args);\n  }\n\n  protected getTransientData(ctx: Ctx): any {\n    const transientMap = ctx.stub.getTransient();\n    let transient: any = {};\n\n    if (transientMap.has((this.repo as any).tableName)) {\n      transient = JSON.parse(\n        (transientMap.get((this.repo as any).tableName) as Buffer)?.toString(\n          \"utf8\"\n        ) as string\n      );\n    }\n\n    return transient;\n  }\n\n  /**\n   * @description Updates a single model in the state database\n   * @summary Delegates to the repository's update method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {M} model - The model to update\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M>} Promise resolving to the updated model\n   */\n  async update(\n    ctx: Ctx,\n    model: string | M,\n    ...args: any[]\n  ): Promise<string | M> {\n    const log = this.logFor(ctx).for(this.update);\n\n    if (typeof model === \"string\") model = this.deserialize<M>(model) as any;\n\n    log.info(`Updating model: ${JSON.stringify(model)}`);\n\n    const transient = this.getTransientData(ctx);\n\n    log.info(`Merging transient data...`);\n    model = (this.repo as any).merge(model as M, transient);\n\n    return this.repo.update(model as unknown as M, ctx, ...args);\n  }\n\n  /**\n   * @description Deletes a single model from the state database\n   * @summary Delegates to the repository's delete method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {string | number} key - The key of the model to delete\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M>} Promise resolving to the deleted model\n   */\n  async delete(\n    ctx: Ctx,\n    key: string | number,\n    ...args: any[]\n  ): Promise<M | string> {\n    const log = this.logFor(ctx).for(this.delete);\n    log.info(`deleting entry with pk ${key} `);\n    return this.repo.delete(String(key), ctx, ...args);\n  }\n\n  /**\n   * @description Deletes multiple models from the state database\n   * @summary Delegates to the repository's deleteAll method\n   * @param {string[] | number[]} keys - The keys of the models to delete\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M[]>} Promise resolving to the deleted models\n   */\n  async deleteAll(\n    ctx: Ctx,\n    keys: string | string[] | number[],\n    ...args: any[]\n  ): Promise<M[] | string> {\n    if (typeof keys === \"string\") keys = JSON.parse(keys) as string[];\n    return this.repo.deleteAll(keys, ctx, ...args);\n  }\n\n  /**\n   * @description Reads multiple models from the state database\n   * @summary Delegates to the repository's readAll method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {string[] | number[]} keys - The keys of the models to read\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M[]>} Promise resolving to the retrieved models\n   */\n  async readAll(\n    ctx: Ctx,\n    keys: string | string[] | number[],\n    ...args: any[]\n  ): Promise<M[] | string> {\n    if (typeof keys === \"string\") keys = JSON.parse(keys) as string[];\n    return this.repo.readAll(keys, ctx, ...args);\n  }\n\n  /**\n   * @description Updates multiple models in the state database\n   * @summary Delegates to the repository's updateAll method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {M[]} models - The models to update\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M[]>} Promise resolving to the updated models\n   */\n  async updateAll(\n    ctx: Ctx,\n    models: string | M[],\n    ...args: any[]\n  ): Promise<string | M[]> {\n    const log = this.logFor(ctx).for(this.updateAll);\n    if (typeof models === \"string\")\n      models = (JSON.parse(models) as [])\n        .map((m) => this.deserialize(m))\n        .map((m) => new this.clazz(m)) as any;\n\n    log.info(`updating ${models.length} entries to the table`);\n    return this.repo.updateAll(models as unknown as M[], ctx, ...args);\n  }\n\n  /**\n   * @description Executes a raw query against the state database\n   * @summary Delegates to the repository's raw method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {any} rawInput - The query to execute\n   * @param {boolean} docsOnly - Whether to return only documents\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<any>} Promise resolving to the query results\n   */\n  async raw(\n    ctx: Ctx,\n    rawInput: MangoQuery | string,\n    docsOnly: boolean,\n    ...args: any[]\n  ): Promise<any | string> {\n    if (typeof rawInput === \"string\")\n      rawInput = JSON.parse(rawInput) as MangoQuery;\n    return this.repo.raw(rawInput, docsOnly, ctx, ...args);\n  }\n\n  protected serialize(model: M): string {\n    return FabricCrudContract.serializer.serialize(model);\n  }\n\n  protected deserialize<M extends Model>(str: string): M {\n    return (\n      FabricCrudContract.serializer as unknown as Serializer<M>\n    ).deserialize(str);\n  }\n\n  protected async init(ctx: Ctx): Promise<void> {\n    const log = this.logFor(ctx).for(this.init);\n    log.info(`Running contract initialization...`);\n    this.initialized = true;\n    log.info(`Contract initialization completed.`);\n  }\n\n  async healthcheck(ctx: Ctx): Promise<string | healthcheck> {\n    const log = this.logFor(ctx).for(this.healthcheck);\n    log.info(`Running Healthcheck: ${this.initialized}...`);\n    return { healthcheck: this.initialized };\n  }\n\n  /**\n   * @description Creates multiple models in the state database\n   * @summary Delegates to the repository's createAll method\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @param {M[]} models - The models to create\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<M[]>} Promise resolving to the created models\n   */\n  async createAll(\n    ctx: Ctx,\n    models: string | M[],\n    ...args: any[]\n  ): Promise<string | M[]> {\n    const log = this.logFor(ctx).for(this.createAll);\n\n    if (typeof models === \"string\")\n      models = (JSON.parse(models) as [])\n        .map((m) => this.deserialize(m))\n        .map((m) => new this.clazz(m)) as any;\n\n    log.info(`adding ${models.length} entries to the table`);\n    return this.repo.createAll(models as unknown as M[], ctx, ...args);\n  }\n}\n"]}

package/lib/contracts/crud/crud-contract.d.ts

@@ -0,0 +1,168 @@
+import { FabricContractAdapter } from "../ContractAdapter";
+import { Context, Contract, Context as Ctx } from "fabric-contract-api";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { FabricContractRepository } from "../FabricContractRepository";
+import { DeterministicSerializer } from "../../shared/DeterministicSerializer";
+import { MangoQuery } from "@decaf-ts/for-couchdb";
+import { Checkable, healthcheck } from "../../shared/interfaces/Checkable";
+import { ContractLogger } from "../logging";
+/**
+ * @description Base contract class for CRUD operations in Fabric chaincode
+ * @summary Provides standard create, read, update, and delete operations for models in Fabric chaincode
+ * @template M - Type extending Model
+ * @class FabricCrudContract
+ * @extends {Contract}
+ * @example
+ * ```typescript
+ * // Define a model
+ * @table('assets')
+ * class Asset extends Model {
+ *   @id()
+ *   id: string;
+ *
+ *   @property()
+ *   data: string;
+ * }
+ *
+ * // Create a contract that extends FabricCrudContract
+ * export class AssetContract extends FabricCrudContract<Asset> {
+ *   constructor() {
+ *     super('AssetContract', Asset);
+ *   }
+ *
+ *   // Add custom methods as needed
+ *   async getAssetHistory(ctx: Context, id: string): Promise<any[]> {
+ *     // Custom implementation
+ *   }
+ * }
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Contract
+ *   participant Repository
+ *   participant Adapter
+ *   participant StateDB
+ *
+ *   Client->>Contract: create(ctx, model)
+ *   Contract->>Repository: repository(ctx)
+ *   Contract->>Repository: create(model, ctx)
+ *   Repository->>Adapter: create(tableName, id, record, transient, ctx)
+ *   Adapter->>StateDB: putState(id, serializedData)
+ *   StateDB-->>Adapter: Success
+ *   Adapter-->>Repository: record
+ *   Repository-->>Contract: model
+ *   Contract-->>Client: model
+ */
+export declare abstract class FabricCrudContract<M extends Model> extends Contract implements Checkable {
+    protected readonly clazz: Constructor<M>;
+    /**
+     * @description Shared adapter instance for all contract instances
+     */
+    protected static adapter: FabricContractAdapter;
+    protected readonly repo: FabricContractRepository<M>;
+    protected static readonly serializer: DeterministicSerializer<Model<false>>;
+    protected initialized: boolean;
+    /**
+     * @description Creates a new FabricCrudContract instance
+     * @summary Initializes a contract with a name and model class
+     * @param {string} name - The name of the contract
+     * @param {Constructor<M>} clazz - The model constructor
+     */
+    protected constructor(name: string, clazz: Constructor<M>);
+    protected getAdapter(clazz: Constructor<M>): FabricContractAdapter;
+    /**
+     * @description Creates a logger for a specific chaincode context
+     * @summary Returns a ContractLogger instance configured for the current context
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @return {ContractLogger} The logger instance
+     */
+    logFor(ctx: Context): ContractLogger;
+    /**
+     * @description Creates a single model in the state database
+     * @summary Delegates to the repository's create method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {M} model - The model to create
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M>} Promise resolving to the created model
+     */
+    create(ctx: Ctx, model: string | M, ...args: any[]): Promise<string | M>;
+    /**
+     * @description Reads a single model from the state database
+     * @summary Delegates to the repository's read method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {string | number} key - The key of the model to read
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M>} Promise resolving to the retrieved model
+     */
+    read(ctx: Ctx, key: string | number, ...args: any[]): Promise<M | string>;
+    protected getTransientData(ctx: Ctx): any;
+    /**
+     * @description Updates a single model in the state database
+     * @summary Delegates to the repository's update method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {M} model - The model to update
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M>} Promise resolving to the updated model
+     */
+    update(ctx: Ctx, model: string | M, ...args: any[]): Promise<string | M>;
+    /**
+     * @description Deletes a single model from the state database
+     * @summary Delegates to the repository's delete method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {string | number} key - The key of the model to delete
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M>} Promise resolving to the deleted model
+     */
+    delete(ctx: Ctx, key: string | number, ...args: any[]): Promise<M | string>;
+    /**
+     * @description Deletes multiple models from the state database
+     * @summary Delegates to the repository's deleteAll method
+     * @param {string[] | number[]} keys - The keys of the models to delete
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M[]>} Promise resolving to the deleted models
+     */
+    deleteAll(ctx: Ctx, keys: string | string[] | number[], ...args: any[]): Promise<M[] | string>;
+    /**
+     * @description Reads multiple models from the state database
+     * @summary Delegates to the repository's readAll method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {string[] | number[]} keys - The keys of the models to read
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M[]>} Promise resolving to the retrieved models
+     */
+    readAll(ctx: Ctx, keys: string | string[] | number[], ...args: any[]): Promise<M[] | string>;
+    /**
+     * @description Updates multiple models in the state database
+     * @summary Delegates to the repository's updateAll method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {M[]} models - The models to update
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M[]>} Promise resolving to the updated models
+     */
+    updateAll(ctx: Ctx, models: string | M[], ...args: any[]): Promise<string | M[]>;
+    /**
+     * @description Executes a raw query against the state database
+     * @summary Delegates to the repository's raw method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {any} rawInput - The query to execute
+     * @param {boolean} docsOnly - Whether to return only documents
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<any>} Promise resolving to the query results
+     */
+    raw(ctx: Ctx, rawInput: MangoQuery | string, docsOnly: boolean, ...args: any[]): Promise<any | string>;
+    protected serialize(model: M): string;
+    protected deserialize<M extends Model>(str: string): M;
+    protected init(ctx: Ctx): Promise<void>;
+    healthcheck(ctx: Ctx): Promise<string | healthcheck>;
+    /**
+     * @description Creates multiple models in the state database
+     * @summary Delegates to the repository's createAll method
+     * @param {Ctx} ctx - The Fabric chaincode context
+     * @param {M[]} models - The models to create
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<M[]>} Promise resolving to the created models
+     */
+    createAll(ctx: Ctx, models: string | M[], ...args: any[]): Promise<string | M[]>;
+}

package/lib/contracts/crud/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./crud-contract.cjs"), exports);
+__exportStar(require("./serialized-crud-contract.cjs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29udHJhY3RzL2NydWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHNEQUFnQztBQUNoQyxpRUFBMkMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9jcnVkLWNvbnRyYWN0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zZXJpYWxpemVkLWNydWQtY29udHJhY3RcIjtcbiJdfQ==

package/lib/contracts/crud/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./crud-contract";
+export * from "./serialized-crud-contract";