@decaf-ts/for-fabric 0.9.0 → 0.10.0

package/lib/types/contracts/crud/crud-contract.d.cts

@@ -0,0 +1,199 @@
+import "../../shared/overrides";
+import { FabricContextualizedArgs, FabricContractAdapter } from "../ContractAdapter.cjs";
+import { Context as Ctx, Contract } from "fabric-contract-api";
+import { Model } from "@decaf-ts/decorator-validation";
+import { AllOperationKeys, Condition, ContextualArgs, DirectionLimitOffset, EventIds, MaybeContextualArg, MethodOrOperation, Observer, OrderDirection, PersistenceObserver, SerializedPage } from "@decaf-ts/core";
+import { FabricContractRepository } from "../FabricContractRepository.cjs";
+import { DeterministicSerializer } from "../../shared/DeterministicSerializer.cjs";
+import { MangoQuery } from "@decaf-ts/for-couchdb";
+import { Checkable, healthcheck } from "../../shared/interfaces/Checkable.cjs";
+import { Constructor } from "@decaf-ts/decoration";
+import { FabricContractContext } from "../ContractContext.cjs";
+import { PrimaryKeyType } from "@decaf-ts/db-decorators";
+/**
+ * @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, PersistenceObserver<FabricContractContext>, Observer<[
+    table: Constructor<M> | string,
+    event: AllOperationKeys,
+    id: EventIds,
+    ...args: ContextualArgs<FabricContractContext>
+]> {
+    protected readonly clazz: Constructor<M>;
+    /**
+     * @description Shared adapter instance for all contract instances
+     */
+    protected static adapter: FabricContractAdapter;
+    protected static readonly serializer: DeterministicSerializer<Model<false>>;
+    protected initialized: boolean;
+    private _repo?;
+    protected get repo(): FabricContractRepository<M>;
+    /**
+     * @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>);
+    refresh(table: Constructor<M> | string, event: AllOperationKeys, id: EventIds, ...args: ContextualArgs<FabricContractContext>): Promise<void>;
+    listBy(ctx: Ctx | FabricContractContext, key: string | keyof M, order: string, ...args: any[]): Promise<M[] | string>;
+    paginateBy(ctx: Ctx | FabricContractContext, key: string | keyof M, order: string, ref?: Omit<DirectionLimitOffset, "direction"> | string, ...args: any[]): Promise<SerializedPage<M> | string>;
+    page(ctx: Ctx | FabricContractContext, value: string, direction?: string | OrderDirection, ref?: Omit<DirectionLimitOffset, "direction"> | string, ...args: any[]): Promise<SerializedPage<M> | string>;
+    findOneBy(ctx: Ctx | FabricContractContext, key: string | keyof M, value: any, ...args: any[]): Promise<M | string>;
+    statement(ctx: Ctx | FabricContractContext, method: string, ...args: any[]): Promise<any>;
+    countOf(ctx: Ctx | FabricContractContext, key?: string | keyof M, ...args: any[]): Promise<number | string>;
+    maxOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<M[keyof M] | string>;
+    minOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<M[keyof M] | string>;
+    avgOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<number | string>;
+    sumOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<number | string>;
+    distinctOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<M[keyof M][] | string>;
+    groupOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<Record<string, M[]> | string>;
+    /**
+     * @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(context: Ctx | FabricContractContext, 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 | FabricContractContext, key: PrimaryKeyType | string, ...args: any[]): Promise<M | string>;
+    protected getTransientData(ctx: FabricContractContext): 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(context: Ctx | FabricContractContext, 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 | FabricContractContext, key: PrimaryKeyType | string, ...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 | FabricContractContext, keys: PrimaryKeyType[] | string, ...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 | FabricContractContext, keys: PrimaryKeyType[] | string, ...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(context: Ctx | FabricContractContext, models: string | M[], ...args: any[]): Promise<string | M[]>;
+    /**
+     * @description Executes a query with the specified conditions and options.
+     * @summary Provides a simplified way to query the database with common query parameters.
+     * @param {Condition<M>} condition - The condition to filter records.
+     * @param orderBy - The field to order results by.
+     * @param {OrderDirection} [order=OrderDirection.ASC] - The sort direction.
+     * @param {OrderDirection} [order=OrderDirection.ASC] - The sort direction.
+     * @param {number} [limit] - Optional maximum number of results to return.
+     * @param {number} [skip] - Optional number of results to skip.
+     * @return {Promise<M[]>} The query results as model instances.
+     */
+    query(context: Ctx | FabricContractContext, condition: Condition<M> | string, orderBy: string | keyof M, order?: OrderDirection | string, limit?: number, skip?: number, ...args: any[]): Promise<M[] | string>;
+    /**
+     * @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 | FabricContractContext, rawInput: MangoQuery, docsOnly: boolean, ...args: any[]): Promise<any>;
+    protected serialize(model: M): string;
+    protected deserialize<M extends Model>(str: string): M;
+    protected init(ctx: Ctx | FabricContractContext): Promise<void>;
+    healthcheck(ctx: Ctx | FabricContractContext): 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(context: Ctx | FabricContractContext, models: string | M[], ...args: any[]): Promise<string | M[]>;
+    protected ensureMirrorWritePermissions(ctx: FabricContractContext): void;
+    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD): FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>;
+    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: false): FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>;
+    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: true): Promise<FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>>;
+}

package/lib/types/contracts/crud/crud-contract.d.mts

@@ -0,0 +1,199 @@
+import "../../shared/overrides";
+import { FabricContextualizedArgs, FabricContractAdapter } from "../ContractAdapter.js";
+import { Context as Ctx, Contract } from "fabric-contract-api";
+import { Model } from "@decaf-ts/decorator-validation";
+import { AllOperationKeys, Condition, ContextualArgs, DirectionLimitOffset, EventIds, MaybeContextualArg, MethodOrOperation, Observer, OrderDirection, PersistenceObserver, SerializedPage } from "@decaf-ts/core";
+import { FabricContractRepository } from "../FabricContractRepository.js";
+import { DeterministicSerializer } from "../../shared/DeterministicSerializer.js";
+import { MangoQuery } from "@decaf-ts/for-couchdb";
+import { Checkable, healthcheck } from "../../shared/interfaces/Checkable.js";
+import { Constructor } from "@decaf-ts/decoration";
+import { FabricContractContext } from "../ContractContext.js";
+import { PrimaryKeyType } from "@decaf-ts/db-decorators";
+/**
+ * @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, PersistenceObserver<FabricContractContext>, Observer<[
+    table: Constructor<M> | string,
+    event: AllOperationKeys,
+    id: EventIds,
+    ...args: ContextualArgs<FabricContractContext>
+]> {
+    protected readonly clazz: Constructor<M>;
+    /**
+     * @description Shared adapter instance for all contract instances
+     */
+    protected static adapter: FabricContractAdapter;
+    protected static readonly serializer: DeterministicSerializer<Model<false>>;
+    protected initialized: boolean;
+    private _repo?;
+    protected get repo(): FabricContractRepository<M>;
+    /**
+     * @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>);
+    refresh(table: Constructor<M> | string, event: AllOperationKeys, id: EventIds, ...args: ContextualArgs<FabricContractContext>): Promise<void>;
+    listBy(ctx: Ctx | FabricContractContext, key: string | keyof M, order: string, ...args: any[]): Promise<M[] | string>;
+    paginateBy(ctx: Ctx | FabricContractContext, key: string | keyof M, order: string, ref?: Omit<DirectionLimitOffset, "direction"> | string, ...args: any[]): Promise<SerializedPage<M> | string>;
+    page(ctx: Ctx | FabricContractContext, value: string, direction?: string | OrderDirection, ref?: Omit<DirectionLimitOffset, "direction"> | string, ...args: any[]): Promise<SerializedPage<M> | string>;
+    findOneBy(ctx: Ctx | FabricContractContext, key: string | keyof M, value: any, ...args: any[]): Promise<M | string>;
+    statement(ctx: Ctx | FabricContractContext, method: string, ...args: any[]): Promise<any>;
+    countOf(ctx: Ctx | FabricContractContext, key?: string | keyof M, ...args: any[]): Promise<number | string>;
+    maxOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<M[keyof M] | string>;
+    minOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<M[keyof M] | string>;
+    avgOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<number | string>;
+    sumOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<number | string>;
+    distinctOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<M[keyof M][] | string>;
+    groupOf(ctx: Ctx | FabricContractContext, key: string | keyof M, ...args: any[]): Promise<Record<string, M[]> | string>;
+    /**
+     * @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(context: Ctx | FabricContractContext, 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 | FabricContractContext, key: PrimaryKeyType | string, ...args: any[]): Promise<M | string>;
+    protected getTransientData(ctx: FabricContractContext): 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(context: Ctx | FabricContractContext, 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 | FabricContractContext, key: PrimaryKeyType | string, ...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 | FabricContractContext, keys: PrimaryKeyType[] | string, ...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 | FabricContractContext, keys: PrimaryKeyType[] | string, ...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(context: Ctx | FabricContractContext, models: string | M[], ...args: any[]): Promise<string | M[]>;
+    /**
+     * @description Executes a query with the specified conditions and options.
+     * @summary Provides a simplified way to query the database with common query parameters.
+     * @param {Condition<M>} condition - The condition to filter records.
+     * @param orderBy - The field to order results by.
+     * @param {OrderDirection} [order=OrderDirection.ASC] - The sort direction.
+     * @param {OrderDirection} [order=OrderDirection.ASC] - The sort direction.
+     * @param {number} [limit] - Optional maximum number of results to return.
+     * @param {number} [skip] - Optional number of results to skip.
+     * @return {Promise<M[]>} The query results as model instances.
+     */
+    query(context: Ctx | FabricContractContext, condition: Condition<M> | string, orderBy: string | keyof M, order?: OrderDirection | string, limit?: number, skip?: number, ...args: any[]): Promise<M[] | string>;
+    /**
+     * @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 | FabricContractContext, rawInput: MangoQuery, docsOnly: boolean, ...args: any[]): Promise<any>;
+    protected serialize(model: M): string;
+    protected deserialize<M extends Model>(str: string): M;
+    protected init(ctx: Ctx | FabricContractContext): Promise<void>;
+    healthcheck(ctx: Ctx | FabricContractContext): 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(context: Ctx | FabricContractContext, models: string | M[], ...args: any[]): Promise<string | M[]>;
+    protected ensureMirrorWritePermissions(ctx: FabricContractContext): void;
+    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD): FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>;
+    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: false): FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>;
+    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: true): Promise<FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>>;
+}

package/lib/types/contracts/crud/index.d.cts

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

package/lib/types/contracts/crud/index.d.mts

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

package/lib/types/contracts/crud/serialized-crud-contract.d.cts

@@ -0,0 +1,42 @@
+import { FabricCrudContract } from "./crud-contract.cjs";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Context as Ctx } from "fabric-contract-api";
+import { Constructor } from "@decaf-ts/decoration";
+/**
+ * @description CRUD contract variant that serializes/deserializes payloads
+ * @summary Exposes the same CRUD operations as FabricCrudContract but takes and returns JSON strings to facilitate simple client interactions.
+ * @template M - Model type handled by this contract
+ * @param {string} name - The contract name
+ * @param {Constructor<M>} clazz - The model constructor used to instantiate models from JSON
+ * @return {void}
+ * @class SerializedCrudContract
+ * @example
+ * const contract = new SerializedCrudContract<MyModel>('MyModelContract', MyModel);
+ * // Client submits JSON string payloads and receives JSON string responses
+ */
+export declare class SerializedCrudContract<M extends Model> extends FabricCrudContract<M> {
+    constructor(name: string, clazz: Constructor<M>);
+    create(ctx: Ctx, model: string): Promise<string>;
+    read(ctx: Ctx, key: string): Promise<string>;
+    update(ctx: Ctx, model: string): Promise<string>;
+    delete(ctx: Ctx, key: string): Promise<string>;
+    deleteAll(ctx: Ctx, keys: string): Promise<string>;
+    readAll(ctx: Ctx, keys: string): Promise<string>;
+    updateAll(ctx: Ctx, models: string): Promise<string>;
+    statement(ctx: Ctx, method: string, args: string): Promise<string>;
+    listBy(ctx: Ctx, key: string, order: string): Promise<string>;
+    paginateBy(ctx: Ctx, key: string, order: string, ref: string): Promise<string>;
+    page(ctx: Ctx, value: string, direction: string, ref: string): Promise<string>;
+    findOneBy(ctx: Ctx, key: string, value: string): Promise<string>;
+    query(ctx: Ctx, condition: string, orderBy: string, order: string, limit?: number, skip?: number): Promise<string>;
+    init(ctx: Ctx): Promise<void>;
+    healthcheck(ctx: Ctx): Promise<string>;
+    createAll(context: Ctx, models: string): Promise<string>;
+    countOf(ctx: Ctx, key?: string): Promise<string>;
+    maxOf(ctx: Ctx, key: string): Promise<string>;
+    minOf(ctx: Ctx, key: string): Promise<string>;
+    avgOf(ctx: Ctx, key: string): Promise<string>;
+    sumOf(ctx: Ctx, key: string): Promise<string>;
+    distinctOf(ctx: Ctx, key: string): Promise<string>;
+    groupOf(ctx: Ctx, key: string): Promise<string>;
+}

package/lib/types/contracts/crud/serialized-crud-contract.d.mts

@@ -0,0 +1,42 @@
+import { FabricCrudContract } from "./crud-contract.js";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Context as Ctx } from "fabric-contract-api";
+import { Constructor } from "@decaf-ts/decoration";
+/**
+ * @description CRUD contract variant that serializes/deserializes payloads
+ * @summary Exposes the same CRUD operations as FabricCrudContract but takes and returns JSON strings to facilitate simple client interactions.
+ * @template M - Model type handled by this contract
+ * @param {string} name - The contract name
+ * @param {Constructor<M>} clazz - The model constructor used to instantiate models from JSON
+ * @return {void}
+ * @class SerializedCrudContract
+ * @example
+ * const contract = new SerializedCrudContract<MyModel>('MyModelContract', MyModel);
+ * // Client submits JSON string payloads and receives JSON string responses
+ */
+export declare class SerializedCrudContract<M extends Model> extends FabricCrudContract<M> {
+    constructor(name: string, clazz: Constructor<M>);
+    create(ctx: Ctx, model: string): Promise<string>;
+    read(ctx: Ctx, key: string): Promise<string>;
+    update(ctx: Ctx, model: string): Promise<string>;
+    delete(ctx: Ctx, key: string): Promise<string>;
+    deleteAll(ctx: Ctx, keys: string): Promise<string>;
+    readAll(ctx: Ctx, keys: string): Promise<string>;
+    updateAll(ctx: Ctx, models: string): Promise<string>;
+    statement(ctx: Ctx, method: string, args: string): Promise<string>;
+    listBy(ctx: Ctx, key: string, order: string): Promise<string>;
+    paginateBy(ctx: Ctx, key: string, order: string, ref: string): Promise<string>;
+    page(ctx: Ctx, value: string, direction: string, ref: string): Promise<string>;
+    findOneBy(ctx: Ctx, key: string, value: string): Promise<string>;
+    query(ctx: Ctx, condition: string, orderBy: string, order: string, limit?: number, skip?: number): Promise<string>;
+    init(ctx: Ctx): Promise<void>;
+    healthcheck(ctx: Ctx): Promise<string>;
+    createAll(context: Ctx, models: string): Promise<string>;
+    countOf(ctx: Ctx, key?: string): Promise<string>;
+    maxOf(ctx: Ctx, key: string): Promise<string>;
+    minOf(ctx: Ctx, key: string): Promise<string>;
+    avgOf(ctx: Ctx, key: string): Promise<string>;
+    sumOf(ctx: Ctx, key: string): Promise<string>;
+    distinctOf(ctx: Ctx, key: string): Promise<string>;
+    groupOf(ctx: Ctx, key: string): Promise<string>;
+}

package/lib/types/contracts/erc20/erc20contract.d.cts

@@ -0,0 +1,152 @@
+import { Context } from "fabric-contract-api";
+import { Allowance, ERC20Token, ERC20Wallet } from "./models.cjs";
+import type { FabricContractContext } from "../ContractContext.cjs";
+import { FabricCrudContract } from "../crud/crud-contract.cjs";
+/**
+ * @description ERC20 token contract base for Hyperledger Fabric
+ * @summary Implements ERC20-like token logic using repositories and adapters, providing standard token operations such as balance queries, transfers, approvals, minting and burning.
+ * @param {string} name - The contract name used to scope token identity
+ * @note https://eips.ethereum.org/EIPS/eip-20
+ * @return {void}
+ * @class FabricERC20Contract
+ * @example
+ * class MyTokenContract extends FabricERC20Contract {
+ *   constructor() { super('MyToken'); }
+ * }
+ * // The contract exposes methods like Transfer, Approve, Mint, Burn, etc.
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Contract
+ *   participant WalletRepo
+ *   participant TokenRepo
+ *   participant Ledger
+ *   Client->>Contract: Transfer(ctx, to, value)
+ *   Contract->>WalletRepo: read(from)
+ *   Contract->>WalletRepo: read(to)
+ *   Contract->>Ledger: putState(updated balances)
+ *   Contract-->>Client: success
+ */
+export declare abstract class FabricERC20Contract extends FabricCrudContract<ERC20Wallet> {
+    private walletRepository;
+    private tokenRepository;
+    private allowanceRepository;
+    protected constructor(name: string);
+    TokenName(context: Context): Promise<string>;
+    /**
+     * Return the symbol of the token. E.g. “HIX”.
+     *
+     * @param {Context} context the transaction context
+     * @returns {String} Returns the symbol of the token
+     */
+    Symbol(context: Context): Promise<string>;
+    /**
+     * Return the number of decimals the token uses
+     * e.g. 8, means to divide the token amount by 100000000 to get its user representation.
+     *
+     * @param {Context} context the transaction context
+     * @returns {Number} Returns the number of decimals
+     */
+    Decimals(context: Context): Promise<number>;
+    /**
+     * Return the total token supply.
+     *
+     * @param {Context} context the transaction context
+     * @returns {Number} Returns the total token supply
+     */
+    TotalSupply(context: Context): Promise<number>;
+    /**
+     * BalanceOf returns the balance of the given account.
+     *
+     * @param {Context} ctx the transaction context
+     * @param {String} owner The owner from which the balance will be retrieved
+     * @returns {Number} Returns the account balance
+     */
+    BalanceOf(context: Context, owner: string): Promise<number>;
+    /**
+     * @summary Transfer transfers tokens from client account to recipient account.
+     * @description recipient account must be a valid clientID as returned by the ClientAccountID() function.
+     *
+     * @param {Context} context the transaction context
+     * @param {String} to The recipient
+     * @param {number} value The amount of token to be transferred
+     *
+     * @returns {Boolean} Return whether the transfer was successful or not
+     */
+    Transfer(context: Context, to: string, value: number): Promise<boolean>;
+    /**
+     * Transfer `value` amount of tokens from `from` to `to`.
+     *
+     * @param {Context} context the transaction context
+     * @param {String} from The sender
+     * @param {String} to The recipient
+     * @param {number} value The amount of token to be transferred
+     * @returns {Boolean} Return whether the transfer was successful or not
+     */
+    TransferFrom(context: Context, from: string, to: string, value: number): Promise<boolean>;
+    _transfer(from: string, to: string, value: number, ctx: FabricContractContext): Promise<boolean>;
+    /**
+     * Allows `spender` to spend `value` amount of tokens from the owner. New Approve calls override the previous allowance.
+     * @note https://eips.ethereum.org/EIPS/eip-20
+     *
+     * @param {Context} ctx the transaction context
+     * @param {String} spender The spender
+     * @param {number} value The amount of tokens to be approved for transfer
+     * @returns {Boolean} Return whether the approval was successful or not
+     */
+    Approve(context: Context, spender: string, value: number): Promise<boolean>;
+    /**
+     * Returns the amount of tokens which ` ` is allowed to withdraw from `owner`.
+     *
+     * @param {Context} ctx the transaction context
+     * @param {String} owner The owner of tokens
+     * @param {String} spender The spender who are able to transfer the tokens
+     * @returns {number} Return the amount of remaining tokens allowed to spent
+     */
+    Allowance(context: Context, owner: string, spender: string): Promise<number>;
+    _getAllowance(owner: string, spender: string, ctx: FabricContractContext): Promise<Allowance>;
+    /**
+     * Set optional infomation for a token.
+     *
+     * @param {Context} ctx the transaction context
+     * @param {String} name The name of the token
+     * @param {String} symbol The symbol of the token
+     * @param {String} decimals The decimals of the token
+     * @param {String} totalSupply The totalSupply of the token
+     */
+    Initialize(context: Context, token: ERC20Token): Promise<boolean>;
+    CheckInitialized(context: Context): Promise<void>;
+    /**
+     * Mint creates new tokens and adds them to minter's account balance
+     *
+     * @param {Context} context the transaction context
+     * @param {number} amount amount of tokens to be minted
+     * @returns {Object} The balance
+     */
+    Mint(context: Context, amount: number): Promise<void>;
+    /**
+     * Burn redeem tokens from minter's account balance
+     *
+     * @param {Context} context the transaction context
+     * @param {number} amount amount of tokens to be burned
+     * @returns {Object} The balance
+     */
+    Burn(context: Context, amount: number): Promise<void>;
+    /**
+     * BurnFrom redeem tokens from account allowence and balance
+     *
+     * @param {Context} context the transaction context
+     * @param {number} account account from where tokens will be burned
+     * @param {number} amount amount of tokens to be burned
+     * @returns {Object} The balance
+     */
+    BurnFrom(context: Context, account: string, amount: number): Promise<void>;
+    /**
+     * ClientAccountBalance returns the balance of the requesting client's account.
+     *
+     * @param {Context} context the transaction context
+     * @returns {Number} Returns the account balance
+     */
+    ClientAccountBalance(context: Context): Promise<number>;
+    ClientAccountID(context: Context): Promise<string>;
+}