@decaf-ts/for-fabric 0.0.2

package/lib/contracts/FabricContractRepository.cjs

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FabricContractRepository = void 0;
+const core_1 = require("@decaf-ts/core");
+const ContractContext_1 = require("./ContractContext.cjs");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const FabricContractRepositoryObservableHandler_1 = require("./FabricContractRepositoryObservableHandler.cjs");
+const FabricContractSequence_1 = require("./FabricContractSequence.cjs");
+const logging_1 = require("@decaf-ts/logging");
+/**
+ * @description Repository for Hyperledger Fabric chaincode models
+ * @summary Provides CRUD operations for models within Fabric chaincode contracts
+ * @template M - Type extending Model
+ * @template MangoQuery - Query type for CouchDB-like queries
+ * @template FabricContractAdapter - Adapter type for Fabric contract operations
+ * @template FabricContractFlags - Flags specific to Fabric contract operations
+ * @template FabricContractContext - Context type for Fabric contract operations
+ *
+ * @param {FabricContractAdapter} [adapter] - The adapter for interacting with the state database
+ * @param {Constructor<M>} [clazz] - The model constructor
+ * @param {Array<OperationKeys | BulkCrudOperationKeys | string>} [trackedEvents] - Events to track for observer notifications
+ *
+ * @class FabricContractRepository
+ * @example
+ * ```typescript
+ * // In a Fabric chaincode contract class
+ * import { FabricContractRepository, FabricContractAdapter } from '@decaf-ts/for-fabric';
+ *
+ * @table('assets')
+ * class Asset extends Model {
+ *   @id()
+ *   id: string;
+ *
+ *   @property()
+ *   data: string;
+ * }
+ *
+ * export class MyContract extends Contract {
+ *   private adapter = new FabricContractAdapter();
+ *   private repository: FabricContractRepository<Asset>;
+ *
+ *   constructor() {
+ *     super('MyContract');
+ *     this.repository = new FabricContractRepository<Asset>(this.adapter, Asset);
+ *   }
+ *
+ *   @Transaction()
+ *   async createAsset(ctx: Context, id: string, data: string): Promise<void> {
+ *     const asset = new Asset();
+ *     asset.id = id;
+ *     asset.data = data;
+ *
+ *     await this.repository.create(asset, { stub: ctx.stub });
+ *   }
+ * }
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Contract
+ *   participant Repository
+ *   participant Adapter
+ *   participant StateDB
+ *
+ *   Contract->>Repository: create(model, ctx)
+ *   Repository->>Adapter: prepare(model, pk)
+ *   Repository->>Adapter: create(tableName, id, record, transient, ctx)
+ *   Adapter->>StateDB: putState(id, serializedData)
+ *   StateDB-->>Adapter: Success
+ *   Adapter-->>Repository: record
+ *   Repository->>Adapter: revert(record, class, pk, id, transient)
+ *   Adapter-->>Repository: model
+ *   Repository-->>Contract: model
+ */
+class FabricContractRepository extends core_1.Repository {
+    constructor(adapter, clazz, trackedEvents) {
+        super(adapter, clazz);
+        this.trackedEvents = trackedEvents;
+    }
+    /**
+     * @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(FabricContractRepository, {}, ctx);
+    }
+    /**
+     * @description Creates a single model in the state database
+     * @summary Prepares, creates, and reverts a model using the adapter
+     * @param {M} model - The model to create
+     * @param {...any[]} args - Additional arguments, including the chaincode context
+     * @return {Promise<M>} Promise resolving to the created model
+     */
+    async create(model, ...args) {
+        const ctx = args[args.length - 1];
+        const log = this.logFor(ctx).for(this.create);
+        log.info(`Preparing model: ${JSON.stringify(model)}`);
+        // eslint-disable-next-line prefer-const
+        let { record, id, transient } = this.adapter.prepare(model, this.pk, this.tableName, ...args);
+        log.info(`Creating model: ${JSON.stringify(model)}`);
+        record = await this.adapter.create(this.tableName, id, record, ...args);
+        let c = undefined;
+        if (args.length)
+            c = args[args.length - 1];
+        log.info(`Reverting model: ${JSON.stringify(model)}`);
+        return this.adapter.revert(record, this.class, this.pk, id, c && c.get("rebuildWithTransient") ? transient : undefined);
+    }
+    async read(id, ...args) {
+        const m = await this.adapter.read(this.tableName, id, new this.class(), ...args);
+        return this.adapter.revert(m, this.class, this.pk, id);
+    }
+    /**
+     * @description Deletes a model from the database by ID.
+     * @summary Removes a model instance from the database using its primary key.
+     * @param {string|number|bigint} id - The primary key of the model to delete.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M>} The deleted model instance.
+     */
+    async delete(id, ...args) {
+        const m = await this.adapter.delete(this.tableName, id, new this.class(), ...args);
+        return this.adapter.revert(m, this.class, this.pk, id);
+    }
+    /**
+     * @description Updates a single model in the state database
+     * @summary Prepares, updates, and reverts a model using the adapter
+     * @param {M} model - The model to update
+     * @param {...any[]} args - Additional arguments, including the chaincode context
+     * @return {Promise<M>} Promise resolving to the updated model
+     */
+    async update(model, ...args) {
+        const ctx = args[args.length - 1];
+        const log = this.logFor(ctx).for(this.update);
+        log.info(`Preparing model: ${JSON.stringify(model)}`);
+        // eslint-disable-next-line prefer-const
+        let { record, id, transient } = this.adapter.prepare(model, this.pk, this.tableName, ...args);
+        log.info(`Updating model: ${JSON.stringify(model)}`);
+        record = await this.adapter.update(this.tableName, id, record, ...args);
+        let c = undefined;
+        if (args.length)
+            c = args[args.length - 1];
+        log.info(`Reverting model: ${JSON.stringify(model)}`);
+        return this.adapter.revert(record, this.class, this.pk, id, c && c.get("rebuildWithTransient") ? transient : undefined);
+    }
+    /**
+     * @description Gets the observer handler for this repository
+     * @summary Returns a FabricContractRepositoryObservableHandler instance
+     * @return {ObserverHandler} The observer handler
+     */
+    ObserverHandler() {
+        return new FabricContractRepositoryObservableHandler_1.FabricContractRepositoryObservableHandler();
+    }
+    /**
+     * @description Creates multiple models in the state database
+     * @summary Prepares, creates, and reverts multiple models using the adapter
+     * @param {M[]} models - The models to create
+     * @param {...any[]} args - Additional arguments, including the chaincode context
+     * @return {Promise<M[]>} Promise resolving to the created models
+     */
+    async createAll(models, ...args) {
+        if (!models.length)
+            return models;
+        const prepared = models.map((m) => this.adapter.prepare(m, this.pk, this.tableName, ...args));
+        const ids = prepared.map((p) => p.id);
+        let records = prepared.map((p) => p.record);
+        const transients = prepared.map((p) => p.transient).filter((e) => !!e);
+        let c = undefined;
+        if (args.length)
+            c = args[args.length - 1];
+        records = await this.adapter.createAll(this.tableName, ids, records, ...args);
+        return records.map((r, i) => this.adapter.revert(r, this.class, this.pk, ids[i], c && c.get("rebuildWithTransient") ? transients : undefined));
+    }
+    /**
+     * @description Updates multiple models in the state database
+     * @summary Prepares, updates, and reverts multiple models using the adapter
+     * @param {M[]} models - The models to update
+     * @param {...any[]} args - Additional arguments, including the chaincode context
+     * @return {Promise<M[]>} Promise resolving to the updated models
+     */
+    async updateAll(models, ...args) {
+        if (!models.length)
+            return models;
+        const records = models.map((m) => this.adapter.prepare(m, this.pk, this.tableName, ...args));
+        const transients = records.map((p) => p.transient).filter((e) => !!e);
+        let c = undefined;
+        if (args.length)
+            c = args[args.length - 1];
+        const updated = await this.adapter.updateAll(this.tableName, records.map((r) => r.id), records.map((r) => r.record), ...args);
+        return updated.map((u, i) => this.adapter.revert(u, this.class, this.pk, records[i].id, c && c.get("rebuildWithTransient") ? transients : undefined));
+    }
+    /**
+     * @description Executes a raw query against the state database
+     * @summary Delegates to the adapter's raw method
+     * @param {MangoQuery} rawInput - The Mango Query to execute
+     * @param {boolean} docsOnly - Whether to return only documents
+     * @param {...any[]} args - Additional arguments, including the chaincode context
+     * @return {Promise<any>} Promise resolving to the query results
+     */
+    async raw(rawInput, docsOnly, ...args) {
+        const ctx = args.pop();
+        const transformedArgs = await db_decorators_1.Context.args("QUERY", this.class, [ctx], this["adapter"], {});
+        return this.adapter.raw(rawInput, docsOnly, new this.class(), ...transformedArgs.args);
+    }
+    /**
+     * @description Updates observers based on tracked events
+     * @summary Filters events based on trackedEvents and delegates to the parent method
+     * @param {string} table - The table/collection name
+     * @param {OperationKeys | BulkCrudOperationKeys | string} event - The event type
+     * @param {EventIds} id - The event identifier
+     * @param {FabricContractContext} ctx - The Fabric contract context
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<void>} Promise that resolves when observers are updated
+     */
+    async updateObservers(table, event, id, ctx, ...args) {
+        if (!this.trackedEvents || this.trackedEvents.indexOf(event) !== -1)
+            return await super.updateObservers(table, event, id, ctx, ...args);
+    }
+    async selectWithContext(selector, ctx) {
+        let contextArgs;
+        if (ctx instanceof ContractContext_1.FabricContractContext) {
+            contextArgs.context = ctx;
+        }
+        else {
+            contextArgs = await db_decorators_1.Context.args(db_decorators_1.OperationKeys.CREATE, this.class, [ctx], this.adapter, this._overrides || {});
+        }
+        if (!selector) {
+            return this.adapter
+                .Statement(contextArgs.context)
+                .select()
+                .from(this.class);
+        }
+        return this.adapter
+            .Statement(contextArgs.context)
+            .select(selector)
+            .from(this.class);
+    }
+    /**
+     * @description Prepares multiple models for creation.
+     * @summary Validates multiple models and prepares them for creation in the database.
+     * @param {M[]} models - The models to create.
+     * @param {...any[]} args - Additional arguments.
+     * @return The prepared models and context arguments.
+     * @throws {ValidationError} If any model fails validation.
+     */
+    async createAllPrefix(models, ...args) {
+        const ctx = args[args.length - 1];
+        const contextArgs = await db_decorators_1.Context.args(db_decorators_1.OperationKeys.CREATE, this.class, args, this.adapter, this._overrides || {});
+        if (!models.length)
+            return [models, ...contextArgs.args];
+        const opts = core_1.Repository.getSequenceOptions(models[0]);
+        let ids = [];
+        if (opts.type) {
+            if (!opts.name)
+                opts.name = FabricContractSequence_1.FabricContractSequence.pk(models[0]);
+            ids = await (await this.adapter.Sequence(opts)).range(models.length, ctx);
+        }
+        else {
+            ids = models.map((m, i) => {
+                if (typeof m[this.pk] === "undefined")
+                    throw new db_decorators_1.InternalError(`Primary key is not defined for model in position ${i}`);
+                return m[this.pk];
+            });
+        }
+        models = await Promise.all(models.map(async (m, i) => {
+            m = new this.class(m);
+            if (opts.type)
+                m[this.pk] = ids[i];
+            await (0, db_decorators_1.enforceDBDecorators)(this, contextArgs.context, m, db_decorators_1.OperationKeys.CREATE, db_decorators_1.OperationKeys.ON);
+            return m;
+        }));
+        const ignoredProps = contextArgs.context.get("ignoredValidationProperties") || [];
+        const errors = await Promise.all(models.map((m) => Promise.resolve(m.hasErrors(...ignoredProps))));
+        const errorMessages = errors.reduce((accum, e, i) => {
+            if (e)
+                accum =
+                    typeof accum === "string"
+                        ? accum + `\n - ${i}: ${e.toString()}`
+                        : ` - ${i}: ${e.toString()}`;
+            return accum;
+        }, undefined);
+        if (errorMessages)
+            throw new db_decorators_1.ValidationError(errorMessages);
+        return [models, ...contextArgs.args];
+    }
+    async createPrefix(model, ...args) {
+        const result = await super.createPrefix(model, ...args);
+        const id = result[0][this.pk];
+        try {
+            const res = await this.read(String(id), ...args);
+            if (res) {
+                throw new db_decorators_1.ConflictError(`Conflict detected while creating model with id: ${id} already exists`);
+            }
+        }
+        catch (e) {
+            if (e.code === 404) {
+                this.logFor(args[args.length - 1]).info(`Record entry with pk ${id} does not exist, creating it now...`);
+            }
+            else {
+                throw e;
+            }
+        }
+        return result;
+    }
+}
+exports.FabricContractRepository = FabricContractRepository;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FabricContractRepository.js","sourceRoot":"","sources":["../../src/contracts/FabricContractRepository.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  EventIds,\n  ObserverHandler,\n  Repository,\n  WhereOption,\n} from \"@decaf-ts/core\";\nimport { FabricContractAdapter } from \"./ContractAdapter\";\nimport { FabricContractFlags } from \"./types\";\nimport { FabricContractContext } from \"./ContractContext\";\nimport { Constructor, Model } from \"@decaf-ts/decorator-validation\";\nimport {\n  BulkCrudOperationKeys,\n  ConflictError,\n  Context as Ctx,\n  Context as CTX,\n  enforceDBDecorators,\n  InternalError,\n  OperationKeys,\n  ValidationError,\n} from \"@decaf-ts/db-decorators\";\nimport { MangoQuery } from \"@decaf-ts/for-couchdb\";\nimport { FabricContractRepositoryObservableHandler } from \"./FabricContractRepositoryObservableHandler\";\nimport { Context } from \"fabric-contract-api\";\nimport { FabricContractSequence } from \"./FabricContractSequence\";\nimport { ContractLogger } from \"./logging\";\nimport { Logging } from \"@decaf-ts/logging\";\n\n/**\n * @description Repository for Hyperledger Fabric chaincode models\n * @summary Provides CRUD operations for models within Fabric chaincode contracts\n * @template M - Type extending Model\n * @template MangoQuery - Query type for CouchDB-like queries\n * @template FabricContractAdapter - Adapter type for Fabric contract operations\n * @template FabricContractFlags - Flags specific to Fabric contract operations\n * @template FabricContractContext - Context type for Fabric contract operations\n *\n * @param {FabricContractAdapter} [adapter] - The adapter for interacting with the state database\n * @param {Constructor<M>} [clazz] - The model constructor\n * @param {Array<OperationKeys | BulkCrudOperationKeys | string>} [trackedEvents] - Events to track for observer notifications\n *\n * @class FabricContractRepository\n * @example\n * ```typescript\n * // In a Fabric chaincode contract class\n * import { FabricContractRepository, FabricContractAdapter } from '@decaf-ts/for-fabric';\n *\n * @table('assets')\n * class Asset extends Model {\n *   @id()\n *   id: string;\n *\n *   @property()\n *   data: string;\n * }\n *\n * export class MyContract extends Contract {\n *   private adapter = new FabricContractAdapter();\n *   private repository: FabricContractRepository<Asset>;\n *\n *   constructor() {\n *     super('MyContract');\n *     this.repository = new FabricContractRepository<Asset>(this.adapter, Asset);\n *   }\n *\n *   @Transaction()\n *   async createAsset(ctx: Context, id: string, data: string): Promise<void> {\n *     const asset = new Asset();\n *     asset.id = id;\n *     asset.data = data;\n *\n *     await this.repository.create(asset, { stub: ctx.stub });\n *   }\n * }\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Contract\n *   participant Repository\n *   participant Adapter\n *   participant StateDB\n *\n *   Contract->>Repository: create(model, ctx)\n *   Repository->>Adapter: prepare(model, pk)\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->>Adapter: revert(record, class, pk, id, transient)\n *   Adapter-->>Repository: model\n *   Repository-->>Contract: model\n */\nexport class FabricContractRepository<M extends Model> extends Repository<\n  M,\n  MangoQuery,\n  FabricContractAdapter,\n  FabricContractFlags,\n  FabricContractContext\n> {\n  constructor(\n    adapter?: FabricContractAdapter,\n    clazz?: Constructor<M>,\n    protected trackedEvents?: (OperationKeys | BulkCrudOperationKeys | string)[]\n  ) {\n    super(adapter, clazz);\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(FabricContractRepository, {}, ctx) as ContractLogger;\n  }\n\n  /**\n   * @description Creates a single model in the state database\n   * @summary Prepares, creates, and reverts a model using the adapter\n   * @param {M} model - The model to create\n   * @param {...any[]} args - Additional arguments, including the chaincode context\n   * @return {Promise<M>} Promise resolving to the created model\n   */\n  override async create(model: M, ...args: any[]): Promise<M> {\n    const ctx = args[args.length - 1] as Context;\n    const log = this.logFor(ctx).for(this.create);\n    log.info(`Preparing model: ${JSON.stringify(model)}`);\n    // eslint-disable-next-line prefer-const\n    let { record, id, transient } = this.adapter.prepare(\n      model,\n      this.pk,\n      this.tableName,\n      ...args\n    );\n    log.info(`Creating model: ${JSON.stringify(model)}`);\n    record = await this.adapter.create(this.tableName, id, record, ...args);\n    let c: FabricContractContext | undefined = undefined;\n    if (args.length) c = args[args.length - 1] as FabricContractContext;\n    log.info(`Reverting model: ${JSON.stringify(model)}`);\n    return this.adapter.revert<M>(\n      record,\n      this.class,\n      this.pk,\n      id,\n      c && c.get(\"rebuildWithTransient\") ? transient : undefined\n    );\n  }\n\n  override async read(\n    id: string | number | bigint,\n    ...args: any[]\n  ): Promise<M> {\n    const m = await this.adapter.read(\n      this.tableName,\n      id as string,\n      new this.class(),\n      ...args\n    );\n    return this.adapter.revert<M>(m, this.class, this.pk, id as string);\n  }\n\n  /**\n   * @description Deletes a model from the database by ID.\n   * @summary Removes a model instance from the database using its primary key.\n   * @param {string|number|bigint} id - The primary key of the model to delete.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M>} The deleted model instance.\n   */\n  override async delete(id: string, ...args: any[]) {\n    const m = await this.adapter.delete(\n      this.tableName,\n      id,\n      new this.class(),\n      ...args\n    );\n    return this.adapter.revert(m, this.class, this.pk, id);\n  }\n\n  /**\n   * @description Updates a single model in the state database\n   * @summary Prepares, updates, and reverts a model using the adapter\n   * @param {M} model - The model to update\n   * @param {...any[]} args - Additional arguments, including the chaincode context\n   * @return {Promise<M>} Promise resolving to the updated model\n   */\n  override async update(model: M, ...args: any[]): Promise<M> {\n    const ctx = args[args.length - 1] as Context;\n    const log = this.logFor(ctx).for(this.update);\n    log.info(`Preparing model: ${JSON.stringify(model)}`);\n    // eslint-disable-next-line prefer-const\n    let { record, id, transient } = this.adapter.prepare(\n      model,\n      this.pk,\n      this.tableName,\n      ...args\n    );\n    log.info(`Updating model: ${JSON.stringify(model)}`);\n    record = await this.adapter.update(this.tableName, id, record, ...args);\n    let c: FabricContractContext | undefined = undefined;\n    if (args.length) c = args[args.length - 1] as FabricContractContext;\n    log.info(`Reverting model: ${JSON.stringify(model)}`);\n    return this.adapter.revert<M>(\n      record,\n      this.class,\n      this.pk,\n      id,\n      c && c.get(\"rebuildWithTransient\") ? transient : undefined\n    );\n  }\n\n  /**\n   * @description Gets the observer handler for this repository\n   * @summary Returns a FabricContractRepositoryObservableHandler instance\n   * @return {ObserverHandler} The observer handler\n   */\n  override ObserverHandler(): ObserverHandler {\n    return new FabricContractRepositoryObservableHandler();\n  }\n\n  /**\n   * @description Creates multiple models in the state database\n   * @summary Prepares, creates, and reverts multiple models using the adapter\n   * @param {M[]} models - The models to create\n   * @param {...any[]} args - Additional arguments, including the chaincode context\n   * @return {Promise<M[]>} Promise resolving to the created models\n   */\n  override async createAll(models: M[], ...args: any[]): Promise<M[]> {\n    if (!models.length) return models;\n    const prepared = models.map((m) =>\n      this.adapter.prepare(m, this.pk, this.tableName, ...args)\n    );\n    const ids = prepared.map((p) => p.id);\n    let records = prepared.map((p) => p.record);\n    const transients = prepared.map((p) => p.transient).filter((e) => !!e);\n    let c: FabricContractContext | undefined = undefined;\n    if (args.length) c = args[args.length - 1] as FabricContractContext;\n    records = await this.adapter.createAll(\n      this.tableName,\n      ids,\n      records,\n      ...args\n    );\n    return records.map((r, i) =>\n      this.adapter.revert(\n        r,\n        this.class,\n        this.pk,\n        ids[i] as string | number,\n        c && c.get(\"rebuildWithTransient\") ? transients : undefined\n      )\n    );\n  }\n\n  /**\n   * @description Updates multiple models in the state database\n   * @summary Prepares, updates, and reverts multiple models using the adapter\n   * @param {M[]} models - The models to update\n   * @param {...any[]} args - Additional arguments, including the chaincode context\n   * @return {Promise<M[]>} Promise resolving to the updated models\n   */\n  override async updateAll(models: M[], ...args: any[]): Promise<M[]> {\n    if (!models.length) return models;\n    const records = models.map((m) =>\n      this.adapter.prepare(m, this.pk, this.tableName, ...args)\n    );\n    const transients = records.map((p) => p.transient).filter((e) => !!e);\n    let c: FabricContractContext | undefined = undefined;\n    if (args.length) c = args[args.length - 1] as FabricContractContext;\n\n    const updated = await this.adapter.updateAll(\n      this.tableName,\n      records.map((r) => r.id),\n      records.map((r) => r.record),\n      ...args\n    );\n    return updated.map((u, i) =>\n      this.adapter.revert(\n        u,\n        this.class,\n        this.pk,\n        records[i].id,\n        c && c.get(\"rebuildWithTransient\") ? transients : undefined\n      )\n    );\n  }\n\n  /**\n   * @description Executes a raw query against the state database\n   * @summary Delegates to the adapter's raw method\n   * @param {MangoQuery} rawInput - The Mango Query to execute\n   * @param {boolean} docsOnly - Whether to return only documents\n   * @param {...any[]} args - Additional arguments, including the chaincode context\n   * @return {Promise<any>} Promise resolving to the query results\n   */\n  async raw(rawInput: MangoQuery, docsOnly: boolean, ...args: any[]) {\n    const ctx = args.pop();\n    const transformedArgs = await CTX.args(\n      \"QUERY\" as OperationKeys.CREATE,\n      this.class,\n      [ctx],\n      this[\"adapter\"] as any,\n      {}\n    );\n\n    return this.adapter.raw(\n      rawInput,\n      docsOnly,\n      new this.class(),\n      ...transformedArgs.args\n    );\n  }\n\n  /**\n   * @description Updates observers based on tracked events\n   * @summary Filters events based on trackedEvents and delegates to the parent method\n   * @param {string} table - The table/collection name\n   * @param {OperationKeys | BulkCrudOperationKeys | string} event - The event type\n   * @param {EventIds} id - The event identifier\n   * @param {FabricContractContext} ctx - The Fabric contract context\n   * @param {...any[]} args - Additional arguments\n   * @return {Promise<void>} Promise that resolves when observers are updated\n   */\n  override async updateObservers(\n    table: string,\n    event: OperationKeys | BulkCrudOperationKeys | string,\n    id: EventIds,\n    ctx: FabricContractContext,\n    ...args: any[]\n  ): Promise<void> {\n    if (!this.trackedEvents || this.trackedEvents.indexOf(event) !== -1)\n      return await super.updateObservers(table, event, id, ctx, ...args);\n  }\n\n  async selectWithContext<S extends readonly (keyof M)[]>(\n    selector?: readonly [...S],\n    ctx?: FabricContractContext | Context\n  ): Promise<WhereOption<M, M[]> | WhereOption<M, Pick<M, S[number]>[]>> {\n    let contextArgs: any;\n    if (ctx instanceof FabricContractContext) {\n      contextArgs.context = ctx;\n    } else {\n      contextArgs = await Ctx.args(\n        OperationKeys.CREATE,\n        this.class,\n        [ctx],\n        this.adapter,\n        this._overrides || {}\n      );\n    }\n    if (!selector) {\n      return this.adapter\n        .Statement<M>(contextArgs.context as FabricContractContext)\n        .select()\n        .from(this.class);\n    }\n    return this.adapter\n      .Statement<M>(contextArgs.context as FabricContractContext)\n      .select(selector)\n      .from(this.class);\n  }\n\n  /**\n   * @description Prepares multiple models for creation.\n   * @summary Validates multiple models and prepares them for creation in the database.\n   * @param {M[]} models - The models to create.\n   * @param {...any[]} args - Additional arguments.\n   * @return The prepared models and context arguments.\n   * @throws {ValidationError} If any model fails validation.\n   */\n  protected override async createAllPrefix(models: M[], ...args: any[]) {\n    const ctx = args[args.length - 1] as Context;\n\n    const contextArgs = await Ctx.args(\n      OperationKeys.CREATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    if (!models.length) return [models, ...contextArgs.args];\n    const opts = Repository.getSequenceOptions(models[0]);\n    let ids: (string | number | bigint | undefined)[] = [];\n    if (opts.type) {\n      if (!opts.name) opts.name = FabricContractSequence.pk(models[0]);\n      ids = await (\n        (await this.adapter.Sequence(opts)) as FabricContractSequence\n      ).range(models.length, ctx as unknown as FabricContractContext);\n    } else {\n      ids = models.map((m, i) => {\n        if (typeof m[this.pk] === \"undefined\")\n          throw new InternalError(\n            `Primary key is not defined for model in position ${i}`\n          );\n        return m[this.pk] as string;\n      });\n    }\n\n    models = await Promise.all(\n      models.map(async (m, i) => {\n        m = new this.class(m);\n        if (opts.type) m[this.pk] = ids[i] as M[keyof M];\n        await enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n\n    const ignoredProps =\n      contextArgs.context.get(\"ignoredValidationProperties\") || [];\n\n    const errors = await Promise.all(\n      models.map((m) => Promise.resolve(m.hasErrors(...ignoredProps)))\n    );\n\n    const errorMessages = errors.reduce((accum: string | undefined, e, i) => {\n      if (e)\n        accum =\n          typeof accum === \"string\"\n            ? accum + `\\n - ${i}: ${e.toString()}`\n            : ` - ${i}: ${e.toString()}`;\n      return accum;\n    }, undefined);\n\n    if (errorMessages) throw new ValidationError(errorMessages);\n    return [models, ...contextArgs.args];\n  }\n\n  protected override async createPrefix(\n    model: M,\n    ...args: any[]\n  ): Promise<[M, ...any[]]> {\n    const result = await super.createPrefix(model, ...args);\n    const id = result[0][this.pk];\n    try {\n      const res = await this.read(String(id), ...args);\n      if (res) {\n        throw new ConflictError(\n          `Conflict detected while creating model with id: ${id} already exists`\n        );\n      }\n    } catch (e) {\n      if ((e as any).code === 404) {\n        this.logFor(args[args.length - 1]).info(\n          `Record entry with pk ${id} does not exist, creating it now...`\n        );\n      } else {\n        throw e;\n      }\n    }\n    return result;\n  }\n}\n"]}

package/lib/contracts/FabricContractRepository.d.ts

@@ -0,0 +1,162 @@
+import { EventIds, ObserverHandler, Repository, WhereOption } from "@decaf-ts/core";
+import { FabricContractAdapter } from "./ContractAdapter";
+import { FabricContractFlags } from "./types";
+import { FabricContractContext } from "./ContractContext";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { BulkCrudOperationKeys, OperationKeys } from "@decaf-ts/db-decorators";
+import { MangoQuery } from "@decaf-ts/for-couchdb";
+import { Context } from "fabric-contract-api";
+import { ContractLogger } from "./logging";
+/**
+ * @description Repository for Hyperledger Fabric chaincode models
+ * @summary Provides CRUD operations for models within Fabric chaincode contracts
+ * @template M - Type extending Model
+ * @template MangoQuery - Query type for CouchDB-like queries
+ * @template FabricContractAdapter - Adapter type for Fabric contract operations
+ * @template FabricContractFlags - Flags specific to Fabric contract operations
+ * @template FabricContractContext - Context type for Fabric contract operations
+ *
+ * @param {FabricContractAdapter} [adapter] - The adapter for interacting with the state database
+ * @param {Constructor<M>} [clazz] - The model constructor
+ * @param {Array<OperationKeys | BulkCrudOperationKeys | string>} [trackedEvents] - Events to track for observer notifications
+ *
+ * @class FabricContractRepository
+ * @example
+ * ```typescript
+ * // In a Fabric chaincode contract class
+ * import { FabricContractRepository, FabricContractAdapter } from '@decaf-ts/for-fabric';
+ *
+ * @table('assets')
+ * class Asset extends Model {
+ *   @id()
+ *   id: string;
+ *
+ *   @property()
+ *   data: string;
+ * }
+ *
+ * export class MyContract extends Contract {
+ *   private adapter = new FabricContractAdapter();
+ *   private repository: FabricContractRepository<Asset>;
+ *
+ *   constructor() {
+ *     super('MyContract');
+ *     this.repository = new FabricContractRepository<Asset>(this.adapter, Asset);
+ *   }
+ *
+ *   @Transaction()
+ *   async createAsset(ctx: Context, id: string, data: string): Promise<void> {
+ *     const asset = new Asset();
+ *     asset.id = id;
+ *     asset.data = data;
+ *
+ *     await this.repository.create(asset, { stub: ctx.stub });
+ *   }
+ * }
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Contract
+ *   participant Repository
+ *   participant Adapter
+ *   participant StateDB
+ *
+ *   Contract->>Repository: create(model, ctx)
+ *   Repository->>Adapter: prepare(model, pk)
+ *   Repository->>Adapter: create(tableName, id, record, transient, ctx)
+ *   Adapter->>StateDB: putState(id, serializedData)
+ *   StateDB-->>Adapter: Success
+ *   Adapter-->>Repository: record
+ *   Repository->>Adapter: revert(record, class, pk, id, transient)
+ *   Adapter-->>Repository: model
+ *   Repository-->>Contract: model
+ */
+export declare class FabricContractRepository<M extends Model> extends Repository<M, MangoQuery, FabricContractAdapter, FabricContractFlags, FabricContractContext> {
+    protected trackedEvents?: (OperationKeys | BulkCrudOperationKeys | string)[] | undefined;
+    constructor(adapter?: FabricContractAdapter, clazz?: Constructor<M>, trackedEvents?: (OperationKeys | BulkCrudOperationKeys | string)[] | undefined);
+    /**
+     * @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 Prepares, creates, and reverts a model using the adapter
+     * @param {M} model - The model to create
+     * @param {...any[]} args - Additional arguments, including the chaincode context
+     * @return {Promise<M>} Promise resolving to the created model
+     */
+    create(model: M, ...args: any[]): Promise<M>;
+    read(id: string | number | bigint, ...args: any[]): Promise<M>;
+    /**
+     * @description Deletes a model from the database by ID.
+     * @summary Removes a model instance from the database using its primary key.
+     * @param {string|number|bigint} id - The primary key of the model to delete.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M>} The deleted model instance.
+     */
+    delete(id: string, ...args: any[]): Promise<M>;
+    /**
+     * @description Updates a single model in the state database
+     * @summary Prepares, updates, and reverts a model using the adapter
+     * @param {M} model - The model to update
+     * @param {...any[]} args - Additional arguments, including the chaincode context
+     * @return {Promise<M>} Promise resolving to the updated model
+     */
+    update(model: M, ...args: any[]): Promise<M>;
+    /**
+     * @description Gets the observer handler for this repository
+     * @summary Returns a FabricContractRepositoryObservableHandler instance
+     * @return {ObserverHandler} The observer handler
+     */
+    ObserverHandler(): ObserverHandler;
+    /**
+     * @description Creates multiple models in the state database
+     * @summary Prepares, creates, and reverts multiple models using the adapter
+     * @param {M[]} models - The models to create
+     * @param {...any[]} args - Additional arguments, including the chaincode context
+     * @return {Promise<M[]>} Promise resolving to the created models
+     */
+    createAll(models: M[], ...args: any[]): Promise<M[]>;
+    /**
+     * @description Updates multiple models in the state database
+     * @summary Prepares, updates, and reverts multiple models using the adapter
+     * @param {M[]} models - The models to update
+     * @param {...any[]} args - Additional arguments, including the chaincode context
+     * @return {Promise<M[]>} Promise resolving to the updated models
+     */
+    updateAll(models: M[], ...args: any[]): Promise<M[]>;
+    /**
+     * @description Executes a raw query against the state database
+     * @summary Delegates to the adapter's raw method
+     * @param {MangoQuery} rawInput - The Mango Query to execute
+     * @param {boolean} docsOnly - Whether to return only documents
+     * @param {...any[]} args - Additional arguments, including the chaincode context
+     * @return {Promise<any>} Promise resolving to the query results
+     */
+    raw(rawInput: MangoQuery, docsOnly: boolean, ...args: any[]): Promise<unknown>;
+    /**
+     * @description Updates observers based on tracked events
+     * @summary Filters events based on trackedEvents and delegates to the parent method
+     * @param {string} table - The table/collection name
+     * @param {OperationKeys | BulkCrudOperationKeys | string} event - The event type
+     * @param {EventIds} id - The event identifier
+     * @param {FabricContractContext} ctx - The Fabric contract context
+     * @param {...any[]} args - Additional arguments
+     * @return {Promise<void>} Promise that resolves when observers are updated
+     */
+    updateObservers(table: string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ctx: FabricContractContext, ...args: any[]): Promise<void>;
+    selectWithContext<S extends readonly (keyof M)[]>(selector?: readonly [...S], ctx?: FabricContractContext | Context): Promise<WhereOption<M, M[]> | WhereOption<M, Pick<M, S[number]>[]>>;
+    /**
+     * @description Prepares multiple models for creation.
+     * @summary Validates multiple models and prepares them for creation in the database.
+     * @param {M[]} models - The models to create.
+     * @param {...any[]} args - Additional arguments.
+     * @return The prepared models and context arguments.
+     * @throws {ValidationError} If any model fails validation.
+     */
+    protected createAllPrefix(models: M[], ...args: any[]): Promise<any[]>;
+    protected createPrefix(model: M, ...args: any[]): Promise<[M, ...any[]]>;
+}

package/lib/contracts/FabricContractRepositoryObservableHandler.cjs

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FabricContractRepositoryObservableHandler = void 0;
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const core_1 = require("@decaf-ts/core");
+const events_1 = require("./../shared/events.cjs");
+/**
+ * @description Observer handler for Fabric chaincode events
+ * @summary Emits events on the Fabric ledger when repository operations occur
+ * @class FabricContractRepositoryObservableHandler
+ * @extends {ObserverHandler}
+ * @example
+ * ```typescript
+ * // In a Fabric chaincode contract
+ * import { FabricContractRepositoryObservableHandler } from '@decaf-ts/for-fabric';
+ *
+ * // Create a handler with default supported events
+ * const handler = new FabricContractRepositoryObservableHandler();
+ *
+ * // Emit an event
+ * await handler.updateObservers(
+ *   logger,
+ *   'assets',
+ *   OperationKeys.CREATE,
+ *   'asset1',
+ *   context
+ * );
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Repository
+ *   participant ObservableHandler
+ *   participant Stub
+ *   participant Ledger
+ *
+ *   Repository->>ObservableHandler: updateObservers(log, table, event, id, ctx)
+ *   ObservableHandler->>ObservableHandler: Check if event is supported
+ *   ObservableHandler->>ObservableHandler: generateFabricEventName(table, event, owner)
+ *   ObservableHandler->>Stub: setEvent(eventName, payload)
+ *   Stub->>Ledger: Record event
+ */
+class FabricContractRepositoryObservableHandler extends core_1.ObserverHandler {
+    /**
+     * @description Creates a new FabricContractRepositoryObservableHandler instance
+     * @summary Initializes the handler with a list of supported events
+     * @param {Array<OperationKeys | BulkCrudOperationKeys | string>} [supportedEvents] - Events that will trigger Fabric events
+     */
+    constructor(supportedEvents = [
+        db_decorators_1.OperationKeys.CREATE,
+        db_decorators_1.OperationKeys.UPDATE,
+        db_decorators_1.OperationKeys.DELETE,
+        db_decorators_1.BulkCrudOperationKeys.CREATE_ALL,
+        db_decorators_1.BulkCrudOperationKeys.UPDATE_ALL,
+        db_decorators_1.BulkCrudOperationKeys.DELETE_ALL,
+    ]) {
+        super();
+        this.supportedEvents = supportedEvents;
+    }
+    /**
+     * @description Updates observers by emitting Fabric events
+     * @summary Emits events on the Fabric ledger for supported event types
+     * @param {Logger} log - Logger instance for debugging
+     * @param {string} table - The table/collection name
+     * @param {OperationKeys | BulkCrudOperationKeys | string} event - The event type
+     * @param {EventIds} id - The event identifier
+     * @param {FabricContractContext} ctx - The Fabric contract context
+     * @param {string} [owner] - Optional owner identifier for the event
+     * @param {object | string | undefined} [owner] - Optional payload for the event
+     *
+     * @return {Promise<void>} Promise that resolves when the event is emitted
+     */
+    async updateObservers(log, table, event, id, ctx, owner, payload) {
+        const { stub } = ctx;
+        if (this.supportedEvents.indexOf(event) !== -1) {
+            log.debug(`Emitting ${event} event`);
+            const eventName = (0, events_1.generateFabricEventName)(table, event, owner);
+            stub.setEvent(eventName, Buffer.from(JSON.stringify({ id: id })));
+        }
+        else {
+            stub.setEvent(event, Buffer.from(JSON.stringify(payload)));
+        }
+    }
+}
+exports.FabricContractRepositoryObservableHandler = FabricContractRepositoryObservableHandler;
+//# sourceMappingURL=data:application/json;base64,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