@decaf-ts/for-fabric 0.0.2

package/lib/esm/contracts/FabricContractRepositoryObservableHandler.js

@@ -0,0 +1,81 @@
+import { BulkCrudOperationKeys, OperationKeys } from "@decaf-ts/db-decorators";
+import { ObserverHandler } from "@decaf-ts/core";
+import { generateFabricEventName } from "./../shared/events.js";
+/**
+ * @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
+ */
+export class FabricContractRepositoryObservableHandler extends 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 = [
+        OperationKeys.CREATE,
+        OperationKeys.UPDATE,
+        OperationKeys.DELETE,
+        BulkCrudOperationKeys.CREATE_ALL,
+        BulkCrudOperationKeys.UPDATE_ALL,
+        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 = generateFabricEventName(table, event, owner);
+            stub.setEvent(eventName, Buffer.from(JSON.stringify({ id: id })));
+        }
+        else {
+            stub.setEvent(event, Buffer.from(JSON.stringify(payload)));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,61 @@
+import { Context, RepositoryFlags } from "@decaf-ts/db-decorators";
+import { Adapter, Sequence, SequenceOptions } from "@decaf-ts/core";
+import { MangoQuery } from "@decaf-ts/for-couchdb";
+import { FabricContractContext } from "./ContractContext";
+import { FabricContractRepository } from "./FabricContractRepository";
+import { CustomizableSequence } from "./PrivateSequence";
+/**
+ * @description Abstract implementation of a Sequence for Fabric contracts
+ * @summary Provides the basic functionality for sequences backed by the FabricContractRepository storing values in CouchDB-like state, including current, next and range operations.
+ * @param {SequenceOptions} options - Sequence configuration such as name, type, startWith and incrementBy
+ * @return {void}
+ * @class FabricContractSequence
+ * @example
+ * const seq = new FabricContractDBSequence({ name: 'orderSeq', type: 'Number', incrementBy: 1, startWith: 1 }, adapter);
+ * const next = await seq.next(ctx); // 1
+ * const [a,b,c] = await seq.range(3, ctx); // [2,3,4]
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Sequence
+ *   participant Repo
+ *   App->>Sequence: next(ctx)
+ *   Sequence->>Repo: read(name, ctx)
+ *   Repo-->>Sequence: current
+ *   Sequence->>Repo: update(current+inc)
+ *   Repo-->>Sequence: saved
+ *   Sequence-->>App: next value
+ */
+export declare class FabricContractSequence extends Sequence {
+    protected repo: FabricContractRepository<CustomizableSequence>;
+    constructor(options: SequenceOptions, adapter: Adapter<any, any, MangoQuery, any, any>, collections?: string[]);
+    /**
+     * @summary Retrieves the current value for the sequence
+     * @protected
+     */
+    current(ctx?: Context<RepositoryFlags>): Promise<string | number | bigint>;
+    /**
+     * @summary Parses the {@link Sequence} value
+     *
+     * @protected
+     * @param value
+     */
+    private parse;
+    /**
+     * @summary increments the sequence
+     * @description Sequence specific implementation
+     *
+     * @param {string | number | bigint} current
+     * @param count
+     * @protected
+     */
+    private increment;
+    /**
+     * @summary Generates the next value in th sequence
+     * @description calls {@link Sequence#parse} on the current value
+     * followed by {@link Sequence#increment}
+     *
+     */
+    next(ctx?: FabricContractContext): Promise<number | string | bigint>;
+    range(count: number, ctx?: FabricContractContext): Promise<(number | string | bigint)[]>;
+}

package/lib/esm/contracts/FabricContractSequence.js

@@ -0,0 +1,135 @@
+import { InternalError, NotFoundError, } from "@decaf-ts/db-decorators";
+import { Repository, Sequence } from "@decaf-ts/core";
+import { MissingContextError } from "./../shared/errors.js";
+import { CustomizableSequence } from "./PrivateSequence.js";
+import { privateData } from "./../shared/decorators.js";
+/**
+ * @description Abstract implementation of a Sequence for Fabric contracts
+ * @summary Provides the basic functionality for sequences backed by the FabricContractRepository storing values in CouchDB-like state, including current, next and range operations.
+ * @param {SequenceOptions} options - Sequence configuration such as name, type, startWith and incrementBy
+ * @return {void}
+ * @class FabricContractSequence
+ * @example
+ * const seq = new FabricContractDBSequence({ name: 'orderSeq', type: 'Number', incrementBy: 1, startWith: 1 }, adapter);
+ * const next = await seq.next(ctx); // 1
+ * const [a,b,c] = await seq.range(3, ctx); // [2,3,4]
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Sequence
+ *   participant Repo
+ *   App->>Sequence: next(ctx)
+ *   Sequence->>Repo: read(name, ctx)
+ *   Repo-->>Sequence: current
+ *   Sequence->>Repo: update(current+inc)
+ *   Repo-->>Sequence: saved
+ *   Sequence-->>App: next value
+ */
+export class FabricContractSequence extends Sequence {
+    constructor(options, adapter, collections) {
+        super(options);
+        for (const collection of collections || []) {
+            privateData(collection)(CustomizableSequence);
+        }
+        this.repo = Repository.forModel(CustomizableSequence, adapter.alias);
+    }
+    /**
+     * @summary Retrieves the current value for the sequence
+     * @protected
+     */
+    async current(ctx) {
+        if (!ctx)
+            throw new MissingContextError("Context is required");
+        const { name, startWith } = this.options;
+        try {
+            const sequence = await this.repo.read(name, ctx);
+            return this.parse(sequence.current);
+        }
+        catch (e) {
+            if (e instanceof NotFoundError) {
+                if (typeof startWith === "undefined")
+                    throw new InternalError("Starting value is not defined for a non existing sequence");
+                try {
+                    return this.parse(startWith);
+                }
+                catch (e) {
+                    throw new InternalError(`Failed to parse initial value for sequence ${startWith}: ${e}`);
+                }
+            }
+            throw new InternalError(`Failed to retrieve current value for sequence ${name}: ${e}`);
+        }
+    }
+    /**
+     * @summary Parses the {@link Sequence} value
+     *
+     * @protected
+     * @param value
+     */
+    parse(value) {
+        return Sequence.parseValue(this.options.type, value);
+    }
+    /**
+     * @summary increments the sequence
+     * @description Sequence specific implementation
+     *
+     * @param {string | number | bigint} current
+     * @param count
+     * @protected
+     */
+    async increment(current, count, ctx) {
+        if (!ctx)
+            throw new MissingContextError("Context is required");
+        const { type, incrementBy, name } = this.options;
+        let next;
+        const toIncrementBy = count || incrementBy;
+        if (toIncrementBy % incrementBy !== 0)
+            throw new InternalError(`Value to increment does not consider the incrementBy setting: ${incrementBy}`);
+        switch (type) {
+            case "Number":
+                next = this.parse(current) + toIncrementBy;
+                break;
+            case "BigInt":
+                next = this.parse(current) + BigInt(toIncrementBy);
+                break;
+            default:
+                throw new InternalError("Should never happen");
+        }
+        let seq;
+        try {
+            seq = await this.repo.update(new CustomizableSequence({ id: name, current: next }), ctx);
+        }
+        catch (e) {
+            if (!(e instanceof NotFoundError))
+                throw e;
+            seq = await this.repo.create(new CustomizableSequence({ id: name, current: next }), ctx);
+        }
+        return seq.current;
+    }
+    /**
+     * @summary Generates the next value in th sequence
+     * @description calls {@link Sequence#parse} on the current value
+     * followed by {@link Sequence#increment}
+     *
+     */
+    async next(ctx) {
+        if (!ctx)
+            throw new MissingContextError("Context is required");
+        const current = await this.current(ctx);
+        return this.increment(current, undefined, ctx);
+    }
+    async range(count, ctx) {
+        if (!ctx)
+            throw new MissingContextError("Context is required");
+        const current = (await this.current(ctx));
+        const incrementBy = this.parse(this.options.incrementBy);
+        const next = await this.increment(current, this.parse(count) * incrementBy, ctx);
+        const range = [];
+        for (let i = 1; i <= count; i++) {
+            range.push(current + incrementBy * this.parse(i));
+        }
+        if (range[range.length - 1] !== next)
+            throw new InternalError("Miscalculation of range");
+        return range;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FabricContractSequence.js","sourceRoot":"","sources":["../../../src/contracts/FabricContractSequence.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Context,\n  InternalError,\n  NotFoundError,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport { Adapter, Repository, Sequence, SequenceOptions } from \"@decaf-ts/core\";\nimport { MangoQuery } from \"@decaf-ts/for-couchdb\";\nimport { FabricContractContext } from \"./ContractContext\";\nimport { FabricContractRepository } from \"./FabricContractRepository\";\nimport { MissingContextError } from \"../shared/errors\";\nimport { CustomizableSequence } from \"./PrivateSequence\";\nimport { privateData } from \"../shared/decorators\";\n\n/**\n * @description Abstract implementation of a Sequence for Fabric contracts\n * @summary Provides the basic functionality for sequences backed by the FabricContractRepository storing values in CouchDB-like state, including current, next and range operations.\n * @param {SequenceOptions} options - Sequence configuration such as name, type, startWith and incrementBy\n * @return {void}\n * @class FabricContractSequence\n * @example\n * const seq = new FabricContractDBSequence({ name: 'orderSeq', type: 'Number', incrementBy: 1, startWith: 1 }, adapter);\n * const next = await seq.next(ctx); // 1\n * const [a,b,c] = await seq.range(3, ctx); // [2,3,4]\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Sequence\n *   participant Repo\n *   App->>Sequence: next(ctx)\n *   Sequence->>Repo: read(name, ctx)\n *   Repo-->>Sequence: current\n *   Sequence->>Repo: update(current+inc)\n *   Repo-->>Sequence: saved\n *   Sequence-->>App: next value\n */\nexport class FabricContractSequence extends Sequence {\n  protected repo: FabricContractRepository<CustomizableSequence>;\n\n  constructor(\n    options: SequenceOptions,\n    adapter: Adapter<any, any, MangoQuery, any, any>,\n    collections?: string[]\n  ) {\n    super(options);\n\n    for (const collection of collections || []) {\n      privateData(collection)(CustomizableSequence);\n    }\n\n    this.repo = Repository.forModel(CustomizableSequence, adapter.alias);\n  }\n\n  /**\n   * @summary Retrieves the current value for the sequence\n   * @protected\n   */\n  async current(\n    ctx?: Context<RepositoryFlags>\n  ): Promise<string | number | bigint> {\n    if (!ctx) throw new MissingContextError(\"Context is required\");\n    const { name, startWith } = this.options;\n    try {\n      const sequence: CustomizableSequence = await this.repo.read(\n        name as string,\n        ctx\n      );\n      return this.parse(sequence.current as string | number);\n    } catch (e: any) {\n      if (e instanceof NotFoundError) {\n        if (typeof startWith === \"undefined\")\n          throw new InternalError(\n            \"Starting value is not defined for a non existing sequence\"\n          );\n        try {\n          return this.parse(startWith);\n        } catch (e: unknown) {\n          throw new InternalError(\n            `Failed to parse initial value for sequence ${startWith}: ${e}`\n          );\n        }\n      }\n      throw new InternalError(\n        `Failed to retrieve current value for sequence ${name}: ${e}`\n      );\n    }\n  }\n\n  /**\n   * @summary Parses the {@link Sequence} value\n   *\n   * @protected\n   * @param value\n   */\n  private parse(value: string | number | bigint): string | number | bigint {\n    return Sequence.parseValue(this.options.type, value);\n  }\n\n  /**\n   * @summary increments the sequence\n   * @description Sequence specific implementation\n   *\n   * @param {string | number | bigint} current\n   * @param count\n   * @protected\n   */\n  private async increment(\n    current: string | number | bigint,\n    count?: number,\n    ctx?: FabricContractContext\n  ): Promise<string | number | bigint> {\n    if (!ctx) throw new MissingContextError(\"Context is required\");\n    const { type, incrementBy, name } = this.options;\n    let next: string | number | bigint;\n    const toIncrementBy = count || incrementBy;\n    if (toIncrementBy % incrementBy !== 0)\n      throw new InternalError(\n        `Value to increment does not consider the incrementBy setting: ${incrementBy}`\n      );\n    switch (type) {\n      case \"Number\":\n        next = (this.parse(current) as number) + toIncrementBy;\n        break;\n      case \"BigInt\":\n        next = (this.parse(current) as bigint) + BigInt(toIncrementBy);\n        break;\n      default:\n        throw new InternalError(\"Should never happen\");\n    }\n    let seq: CustomizableSequence;\n    try {\n      seq = await this.repo.update(\n        new CustomizableSequence({ id: name, current: next }),\n        ctx\n      );\n    } catch (e: any) {\n      if (!(e instanceof NotFoundError)) throw e;\n      seq = await this.repo.create(\n        new CustomizableSequence({ id: name, current: next }),\n        ctx\n      );\n    }\n\n    return seq.current as string | number | bigint;\n  }\n\n  /**\n   * @summary Generates the next value in th sequence\n   * @description calls {@link Sequence#parse} on the current value\n   * followed by {@link Sequence#increment}\n   *\n   */\n  async next(ctx?: FabricContractContext): Promise<number | string | bigint> {\n    if (!ctx) throw new MissingContextError(\"Context is required\");\n    const current = await this.current(ctx);\n    return this.increment(current, undefined, ctx);\n  }\n\n  async range(\n    count: number,\n    ctx?: FabricContractContext\n  ): Promise<(number | string | bigint)[]> {\n    if (!ctx) throw new MissingContextError(\"Context is required\");\n    const current = (await this.current(ctx)) as number;\n    const incrementBy = this.parse(this.options.incrementBy) as number;\n    const next: string | number | bigint = await this.increment(\n      current,\n      (this.parse(count) as number) * incrementBy,\n      ctx\n    );\n    const range: (number | string | bigint)[] = [];\n    for (let i: number = 1; i <= count; i++) {\n      range.push(current + incrementBy * (this.parse(i) as number));\n    }\n    if (range[range.length - 1] !== next)\n      throw new InternalError(\"Miscalculation of range\");\n    return range;\n  }\n}\n"]}

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

@@ -0,0 +1,34 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { CouchDBStatement, MangoQuery } from "@decaf-ts/for-couchdb";
+import { FabricContractAdapter } from "./ContractAdapter";
+import { FabricContractContext } from "./ContractContext";
+/**
+ * @description Statement wrapper for executing Mango queries within Fabric contracts
+ * @summary Bridges CouchDB-style queries to Fabric via the FabricContractAdapter, handling identity and primary key projection when needed.
+ * @template M - Model type this statement operates on
+ * @template R - Result type returned by the statement
+ * @param {FabricContractAdapter} adapter - The Fabric contract adapter used for raw execution
+ * @param {FabricContractContext} ctx - The Fabric contract context carrying stub and identity
+ * @return {void}
+ * @class FabricStatement
+ * @example
+ * const stmt = new FabricStatement<MyModel, MyModel[]>(adapter, ctx);
+ * const result = await stmt.raw<MyModel[]>({ selector: { type: 'MyModel' } });
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Statement
+ *   participant Adapter
+ *   participant Ledger
+ *   App->>Statement: raw({ selector })
+ *   Statement->>Adapter: adapter.raw(mango, true, ctx)
+ *   Adapter->>Ledger: Evaluate query
+ *   Adapter-->>Statement: rows
+ *   Statement-->>App: models
+ */
+export declare class FabricStatement<M extends Model, R> extends CouchDBStatement<M, R> {
+    private readonly ctx;
+    constructor(adapter: FabricContractAdapter, ctx: FabricContractContext);
+    raw<R>(rawInput: MangoQuery): Promise<R>;
+    build(): MangoQuery;
+}

package/lib/esm/contracts/FabricContractStatement.js

@@ -0,0 +1,115 @@
+import { CouchDBGroupOperator, CouchDBKeys, CouchDBOperator, CouchDBStatement, } from "@decaf-ts/for-couchdb";
+import { findPrimaryKey } from "@decaf-ts/db-decorators";
+import { Condition, Repository } from "@decaf-ts/core";
+/**
+ * @description Statement wrapper for executing Mango queries within Fabric contracts
+ * @summary Bridges CouchDB-style queries to Fabric via the FabricContractAdapter, handling identity and primary key projection when needed.
+ * @template M - Model type this statement operates on
+ * @template R - Result type returned by the statement
+ * @param {FabricContractAdapter} adapter - The Fabric contract adapter used for raw execution
+ * @param {FabricContractContext} ctx - The Fabric contract context carrying stub and identity
+ * @return {void}
+ * @class FabricStatement
+ * @example
+ * const stmt = new FabricStatement<MyModel, MyModel[]>(adapter, ctx);
+ * const result = await stmt.raw<MyModel[]>({ selector: { type: 'MyModel' } });
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Statement
+ *   participant Adapter
+ *   participant Ledger
+ *   App->>Statement: raw({ selector })
+ *   Statement->>Adapter: adapter.raw(mango, true, ctx)
+ *   Adapter->>Ledger: Evaluate query
+ *   Adapter-->>Statement: rows
+ *   Statement-->>App: models
+ */
+export class FabricStatement extends CouchDBStatement {
+    constructor(adapter, ctx) {
+        super(adapter);
+        this.ctx = ctx;
+    }
+    async raw(rawInput) {
+        const results = await this.adapter.raw(rawInput, true, this.ctx);
+        const pkDef = findPrimaryKey(new this.fromSelector());
+        const pkAttr = pkDef.id;
+        const type = pkDef.props.type;
+        if (!this.selectSelector)
+            return results.map((r) => this.processRecord(r, pkAttr, type));
+        return results;
+    }
+    build() {
+        const selectors = {};
+        selectors[CouchDBKeys.TABLE] = {};
+        selectors[CouchDBKeys.TABLE] = Repository.table(this.fromSelector);
+        const query = { selector: selectors };
+        if (this.selectSelector)
+            query.fields = this.selectSelector;
+        if (this.whereCondition) {
+            const condition = this.parseCondition(Condition.and(this.whereCondition, Condition.attribute(CouchDBKeys.TABLE).eq(query.selector[CouchDBKeys.TABLE]))).selector;
+            const selectorKeys = Object.keys(condition);
+            if (selectorKeys.length === 1 &&
+                Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1)
+                switch (selectorKeys[0]) {
+                    case CouchDBGroupOperator.AND:
+                        condition[CouchDBGroupOperator.AND] = [
+                            ...Object.values(condition[CouchDBGroupOperator.AND]).reduce((accum, val) => {
+                                const keys = Object.keys(val);
+                                if (keys.length !== 1)
+                                    throw new Error("Too many keys in query selector. should be one");
+                                const k = keys[0];
+                                if (k === CouchDBGroupOperator.AND)
+                                    accum.push(...val[k]);
+                                else
+                                    accum.push(val);
+                                return accum;
+                            }, []),
+                        ];
+                        query.selector = condition;
+                        break;
+                    case CouchDBGroupOperator.OR: {
+                        const s = {};
+                        s[CouchDBGroupOperator.AND] = [
+                            condition,
+                            ...Object.entries(query.selector).map(([key, val]) => {
+                                const result = {};
+                                result[key] = val;
+                                return result;
+                            }),
+                        ];
+                        query.selector = s;
+                        break;
+                    }
+                    default:
+                        throw new Error("This should be impossible");
+                }
+            else {
+                Object.entries(condition).forEach(([key, val]) => {
+                    if (query.selector[key])
+                        console.warn(`A ${key} query param is about to be overridden: ${query.selector[key]} by ${val}`);
+                    query.selector[key] = val;
+                });
+            }
+        }
+        if (this.orderBySelector) {
+            query.sort = query.sort || [];
+            query.selector = query.selector || {};
+            const [selector, value] = this.orderBySelector;
+            const rec = {};
+            rec[selector] = value;
+            query.sort.push(rec);
+            if (!query.selector[selector]) {
+                query.selector[selector] = {};
+                query.selector[selector][CouchDBOperator.BIGGER] =
+                    null;
+            }
+        }
+        if (this.limitSelector)
+            query.limit = this.limitSelector;
+        if (this.offsetSelector)
+            query.skip = this.offsetSelector;
+        return query;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FabricContractStatement.js","sourceRoot":"","sources":["../../../src/contracts/FabricContractStatement.ts"],"names":[],"mappings":"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","sourcesContent":["import { Model } from \"@decaf-ts/decorator-validation\";\nimport {\n  CouchDBAdapter,\n  CouchDBGroupOperator,\n  CouchDBKeys,\n  CouchDBOperator,\n  CouchDBStatement,\n  MangoOperator,\n  MangoQuery,\n  MangoSelector,\n} from \"@decaf-ts/for-couchdb\";\nimport { FabricContractAdapter } from \"./ContractAdapter\";\nimport { findPrimaryKey } from \"@decaf-ts/db-decorators\";\nimport { FabricContractContext } from \"./ContractContext\";\nimport { Condition, OrderDirection, Repository } from \"@decaf-ts/core\";\n\n/**\n * @description Statement wrapper for executing Mango queries within Fabric contracts\n * @summary Bridges CouchDB-style queries to Fabric via the FabricContractAdapter, handling identity and primary key projection when needed.\n * @template M - Model type this statement operates on\n * @template R - Result type returned by the statement\n * @param {FabricContractAdapter} adapter - The Fabric contract adapter used for raw execution\n * @param {FabricContractContext} ctx - The Fabric contract context carrying stub and identity\n * @return {void}\n * @class FabricStatement\n * @example\n * const stmt = new FabricStatement<MyModel, MyModel[]>(adapter, ctx);\n * const result = await stmt.raw<MyModel[]>({ selector: { type: 'MyModel' } });\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Statement\n *   participant Adapter\n *   participant Ledger\n *   App->>Statement: raw({ selector })\n *   Statement->>Adapter: adapter.raw(mango, true, ctx)\n *   Adapter->>Ledger: Evaluate query\n *   Adapter-->>Statement: rows\n *   Statement-->>App: models\n */\nexport class FabricStatement<M extends Model, R> extends CouchDBStatement<\n  M,\n  R\n> {\n  constructor(\n    adapter: FabricContractAdapter,\n    private readonly ctx: FabricContractContext\n  ) {\n    super(adapter as unknown as CouchDBAdapter<any, any, any, any>);\n  }\n\n  override async raw<R>(rawInput: MangoQuery): Promise<R> {\n    const results: any[] = await this.adapter.raw(rawInput, true, this.ctx);\n\n    const pkDef = findPrimaryKey(new this.fromSelector());\n    const pkAttr = pkDef.id;\n    const type = pkDef.props.type;\n\n    if (!this.selectSelector)\n      return results.map((r) => this.processRecord(r, pkAttr, type)) as R;\n    return results as R;\n  }\n\n  override build(): MangoQuery {\n    const selectors: MangoSelector = {};\n    selectors[CouchDBKeys.TABLE] = {};\n    selectors[CouchDBKeys.TABLE] = Repository.table(this.fromSelector);\n    const query: MangoQuery = { selector: selectors };\n    if (this.selectSelector) query.fields = this.selectSelector as string[];\n\n    if (this.whereCondition) {\n      const condition: MangoSelector = this.parseCondition(\n        Condition.and(\n          this.whereCondition,\n          Condition.attribute<M>(CouchDBKeys.TABLE as keyof M).eq(\n            query.selector[CouchDBKeys.TABLE]\n          )\n        )\n      ).selector;\n      const selectorKeys = Object.keys(condition) as MangoOperator[];\n      if (\n        selectorKeys.length === 1 &&\n        Object.values(CouchDBGroupOperator).indexOf(selectorKeys[0]) !== -1\n      )\n        switch (selectorKeys[0]) {\n          case CouchDBGroupOperator.AND:\n            condition[CouchDBGroupOperator.AND] = [\n              ...Object.values(\n                condition[CouchDBGroupOperator.AND] as MangoSelector\n              ).reduce((accum: MangoSelector[], val: any) => {\n                const keys = Object.keys(val);\n                if (keys.length !== 1)\n                  throw new Error(\n                    \"Too many keys in query selector. should be one\"\n                  );\n                const k = keys[0];\n                if (k === CouchDBGroupOperator.AND)\n                  accum.push(...(val[k] as any[]));\n                else accum.push(val);\n                return accum;\n              }, []),\n            ];\n            query.selector = condition;\n            break;\n          case CouchDBGroupOperator.OR: {\n            const s: Record<any, any> = {};\n            s[CouchDBGroupOperator.AND] = [\n              condition,\n              ...Object.entries(query.selector).map(([key, val]) => {\n                const result: Record<any, any> = {};\n                result[key] = val;\n                return result;\n              }),\n            ];\n            query.selector = s;\n            break;\n          }\n          default:\n            throw new Error(\"This should be impossible\");\n        }\n      else {\n        Object.entries(condition).forEach(([key, val]) => {\n          if (query.selector[key])\n            console.warn(\n              `A ${key} query param is about to be overridden: ${query.selector[key]} by ${val}`\n            );\n          query.selector[key] = val;\n        });\n      }\n    }\n\n    if (this.orderBySelector) {\n      query.sort = query.sort || [];\n      query.selector = query.selector || ({} as MangoSelector);\n      const [selector, value] = this.orderBySelector as [\n        string,\n        OrderDirection,\n      ];\n      const rec: any = {};\n      rec[selector] = value;\n      (query.sort as any[]).push(rec as any);\n      if (!query.selector[selector]) {\n        query.selector[selector] = {} as MangoSelector;\n        (query.selector[selector] as MangoSelector)[CouchDBOperator.BIGGER] =\n          null;\n      }\n    }\n\n    if (this.limitSelector) query.limit = this.limitSelector;\n\n    if (this.offsetSelector) query.skip = this.offsetSelector;\n\n    return query;\n  }\n}\n"]}

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

@@ -0,0 +1,15 @@
+import { BaseModel } from "@decaf-ts/core";
+import { type ModelArg } from "@decaf-ts/decorator-validation";
+export declare class CustomizableSequence extends BaseModel {
+    /**
+     * @description The unique identifier for the sequence
+     * @summary Primary key for the sequence record
+     */
+    id: string;
+    /**
+     * @description The current value of the sequence
+     * @summary Current sequence value that can be incremented
+     */
+    current: string | number;
+    constructor(seq?: ModelArg<CustomizableSequence>);
+}

package/lib/esm/contracts/PrivateSequence.js

@@ -0,0 +1,33 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { BaseModel, index, pk, table } from "@decaf-ts/core";
+import { model, required } from "@decaf-ts/decorator-validation";
+import { CouchDBKeys } from "@decaf-ts/for-couchdb";
+let CustomizableSequence = class CustomizableSequence extends BaseModel {
+    constructor(seq) {
+        super(seq);
+    }
+};
+__decorate([
+    pk(),
+    __metadata("design:type", String)
+], CustomizableSequence.prototype, "id", void 0);
+__decorate([
+    required(),
+    index(),
+    __metadata("design:type", Object)
+], CustomizableSequence.prototype, "current", void 0);
+CustomizableSequence = __decorate([
+    table(CouchDBKeys.SEQUENCE),
+    model(),
+    __metadata("design:paramtypes", [Object])
+], CustomizableSequence);
+export { CustomizableSequence };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUHJpdmF0ZVNlcXVlbmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbnRyYWN0cy9Qcml2YXRlU2VxdWVuY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdELE9BQU8sRUFBRSxLQUFLLEVBQWlCLFFBQVEsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ2hGLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUk3QyxJQUFNLG9CQUFvQixHQUExQixNQUFNLG9CQUFxQixTQUFRLFNBQVM7SUFnQmpELFlBQVksR0FBb0M7UUFDOUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2IsQ0FBQztDQUNGLENBQUE7QUFiQztJQURDLEVBQUUsRUFBRTs7Z0RBQ087QUFRWjtJQUZDLFFBQVEsRUFBRTtJQUNWLEtBQUssRUFBRTs7cURBQ2tCO0FBZGYsb0JBQW9CO0lBRmhDLEtBQUssQ0FBQyxXQUFXLENBQUMsUUFBUSxDQUFDO0lBQzNCLEtBQUssRUFBRTs7R0FDSyxvQkFBb0IsQ0FtQmhDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZU1vZGVsLCBpbmRleCwgcGssIHRhYmxlIH0gZnJvbSBcIkBkZWNhZi10cy9jb3JlXCI7XG5pbXBvcnQgeyBtb2RlbCwgdHlwZSBNb2RlbEFyZywgcmVxdWlyZWQgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBDb3VjaERCS2V5cyB9IGZyb20gXCJAZGVjYWYtdHMvZm9yLWNvdWNoZGJcIjtcblxuQHRhYmxlKENvdWNoREJLZXlzLlNFUVVFTkNFKVxuQG1vZGVsKClcbmV4cG9ydCBjbGFzcyBDdXN0b21pemFibGVTZXF1ZW5jZSBleHRlbmRzIEJhc2VNb2RlbCB7XG4gIC8qKlxuICAgKiBAZGVzY3JpcHRpb24gVGhlIHVuaXF1ZSBpZGVudGlmaWVyIGZvciB0aGUgc2VxdWVuY2VcbiAgICogQHN1bW1hcnkgUHJpbWFyeSBrZXkgZm9yIHRoZSBzZXF1ZW5jZSByZWNvcmRcbiAgICovXG4gIEBwaygpXG4gIGlkITogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBAZGVzY3JpcHRpb24gVGhlIGN1cnJlbnQgdmFsdWUgb2YgdGhlIHNlcXVlbmNlXG4gICAqIEBzdW1tYXJ5IEN1cnJlbnQgc2VxdWVuY2UgdmFsdWUgdGhhdCBjYW4gYmUgaW5jcmVtZW50ZWRcbiAgICovXG4gIEByZXF1aXJlZCgpXG4gIEBpbmRleCgpXG4gIGN1cnJlbnQhOiBzdHJpbmcgfCBudW1iZXI7XG5cbiAgY29uc3RydWN0b3Ioc2VxPzogTW9kZWxBcmc8Q3VzdG9taXphYmxlU2VxdWVuY2U+KSB7XG4gICAgc3VwZXIoc2VxKTtcbiAgfVxufVxuIl19