@decaf-ts/for-fabric 0.11.0 → 0.12.0

package/lib/types/contracts/ContractAdapter.d.ts

@@ -1,287 +0,0 @@
-import { CouchDBAdapter, MangoQuery, ViewResponse } from "@decaf-ts/for-couchdb";
-import { Model } from "@decaf-ts/decorator-validation";
-import { FabricContractFlags } from "./types";
-import { FabricContractContext } from "./ContractContext";
-import { BaseError, BulkCrudOperationKeys, OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorators";
-import { Context as Ctx } from "fabric-contract-api";
-import { Logger } from "@decaf-ts/logging";
-import { RelationsMetadata, Sequence, SequenceOptions, Adapter, AdapterFlags, PreparedModel, Repository, ContextualizedArgs, Context, RawResult, Paginator, ContextualArgs, MaybeContextualArg, MethodOrOperation, AllOperationKeys, FlagsOf, ContextOf, EventIds, Dispatch } from "@decaf-ts/core";
-import { FabricContractRepository } from "./FabricContractRepository";
-import { ChaincodeStub, ClientIdentity, Iterators, StateQueryResponse } from "fabric-shim-api";
-import { FabricStatement } from "./FabricContractStatement";
-import { SimpleDeterministicSerializer } from "../shared/SimpleDeterministicSerializer";
-import { Constructor } from "@decaf-ts/decoration";
-export type FabricContextualizedArgs<ARGS extends any[] = any[], EXTEND extends boolean = false> = ContextualizedArgs<FabricContractContext, ARGS, EXTEND> & {
-    stub: ChaincodeStub;
-    identity: ClientIdentity;
-};
-/**
- * @description Sets the creator or updater field in a model based on the user in the context
- * @summary Callback function used in decorators to automatically set the created_by or updated_by fields
- * with the username from the context when a document is created or updated
- * @template M - Type extending Model
- * @template R - Type extending NanoRepository<M>
- * @template V - Type extending RelationsMetadata
- * @param {R} this - The repository instance
- * @param {FabricContractContext} context - The operation context containing user information
- * @param {V} data - The relation metadata
- * @param {string} key - The property key to set with the username
- * @param {M} model - The model instance being created or updated
- * @return {Promise<void>} A promise that resolves when the operation is complete
- * @function createdByOnFabricCreateUpdate
- * @memberOf module:fabric.contracts
- * @mermaid
- * sequenceDiagram
- *   participant F as createdByOnNanoCreateUpdate
- *   participant C as Context
- *   participant M as Model
- *   F->>C: get("user")
- *   C-->>F: user object
- *   F->>M: set key to user.name
- *   Note over F: If no user in context
- *   F-->>F: throw UnsupportedError
- */
-export declare function createdByOnFabricCreateUpdate<M extends Model, R extends FabricContractRepository<M>, V extends RelationsMetadata>(this: R, context: ContextOf<R>, data: V, key: keyof M, model: M): Promise<void>;
-/**
- * @description Adapter for Hyperledger Fabric chaincode state database operations
- * @summary Provides a CouchDB-like interface for interacting with the Fabric state database from within a chaincode contract
- * @template void - No configuration needed for contract adapter
- * @template FabricContractFlags - Flags specific to Fabric contract operations
- * @template FabricContractContext - Context type for Fabric contract operations
- * @class FabricContractAdapter
- * @example
- * ```typescript
- * // In a Fabric chaincode contract class
- * import { FabricContractAdapter } from '@decaf-ts/for-fabric';
- *
- * export class MyContract extends Contract {
- *   private adapter = new FabricContractAdapter();
- *
- *   @Transaction()
- *   async createAsset(ctx: Context, id: string, data: string): Promise<void> {
- *     const model = { id, data, timestamp: Date.now() };
- *     await this.adapter.create('assets', id, model, {}, { stub: ctx.stub });
- *   }
- * }
- * ```
- * @mermaid
- * sequenceDiagram
- *   participant Contract
- *   participant FabricContractAdapter
- *   participant Stub
- *   participant StateDB
- *
- *   Contract->>FabricContractAdapter: create(tableName, id, model, transient, ctx)
- *   FabricContractAdapter->>FabricContractAdapter: Serialize model to JSON
- *   FabricContractAdapter->>Stub: putState(id, serializedData)
- *   Stub->>StateDB: Write data
- *   StateDB-->>Stub: Success
- *   Stub-->>FabricContractAdapter: Success
- *   FabricContractAdapter-->>Contract: model
- */
-export declare class FabricContractAdapter extends CouchDBAdapter<any, void, FabricContractContext> {
-    private static readonly PRIVATE_BOOKMARK_PREFIX;
-    private static parseSyntheticPrivateBookmark;
-    private static buildSyntheticPrivateBookmark;
-    protected getClient(): void;
-    /**
-     * @description Text decoder for converting binary data to strings
-     */
-    private static textDecoder;
-    protected static readonly serializer: SimpleDeterministicSerializer<Model<false>>;
-    /**
-     * @description Context constructor for this adapter
-     * @summary Overrides the base Context constructor with FabricContractContext
-     */
-    protected get Context(): Constructor<FabricContractContext>;
-    /**
-     * @description Gets the repository constructor for this adapter
-     * @summary Returns the FabricContractRepository constructor for creating repositories
-     * @template M - Type extending Model
-     * @return {Constructor<Repository<M, MangoQuery, FabricContractAdapter, FabricContractFlags, FabricContractContext>>} The repository constructor
-     */
-    repository<R extends Repository<any, Adapter<any, void, MangoQuery, Context<FabricContractFlags>>>>(): Constructor<R>;
-    Paginator<M extends Model>(query: MangoQuery, size: number, clazz: Constructor<M>): Paginator<M, any, MangoQuery>;
-    Sequence(options: SequenceOptions): Promise<Sequence>;
-    protected Dispatch(): Dispatch<FabricContractAdapter>;
-    /**
-     * @description Creates a new FabricContractAdapter instance
-     * @summary Initializes an adapter for interacting with the Fabric state database
-     * @param {void} scope - Not used in this adapter
-     * @param {string} [alias] - Optional alias for the adapter instance
-     */
-    constructor(scope: void, alias?: string);
-    for(config: Partial<any>, ...args: any): typeof this;
-    protected getModelDefaults<M extends Model>(clazz: Constructor<M>): Record<keyof M, any>;
-    /**
-     * @description Creates a record in the state database
-     * @summary Serializes a model and stores it in the Fabric state database
-     * @param {string} tableName - The name of the table/collection
-     * @param {string | number} id - The record identifier
-     * @param {Record<string, any>} model - The record data
-     * @param {Record<string, any>} transient - Transient data (not used in this implementation)
-     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
-     * @return {Promise<Record<string, any>>} Promise resolving to the created record
-     */
-    create<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<Context<FabricContractFlags>>): Promise<Record<string, any>>;
-    createAll<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType[], model: Record<string, any>[], ...args: ContextualArgs<FabricContractContext>): Promise<Record<string, any>[]>;
-    /**
-     * @description Reads a record from the state database
-     * @summary Retrieves and deserializes a record from the Fabric state database
-     * @param {string} tableName - The name of the table/collection
-     * @param {string | number} id - The record identifier
-     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
-     * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record
-     */
-    read<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<Context<FabricContractFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Retrieves multiple records from the database
-     * @summary Fetches multiple records with the given IDs from the specified table
-     * @param {string} tableName - The name of the table to read from
-     * @param id - The identifiers of the records to retrieve
-     * @param {...any[]} args - Additional arguments specific to the adapter implementation
-     * @return A promise that resolves to an array of retrieved records
-     */
-    readAll<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType[], ...args: ContextualArgs<Context<FabricContractFlags>>): Promise<Record<string, any>[]>;
-    /**
-     * @description Updates a record in the state database
-     * @summary Serializes a model and updates it in the Fabric state database
-     * @param {string} tableName - The name of the table/collection
-     * @param {string | number} id - The record identifier
-     * @param {Record<string, any>} model - The updated record data
-     * @param {Record<string, any>} transient - Transient data (not used in this implementation)
-     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
-     * @return {Promise<Record<string, any>>} Promise resolving to the updated record
-     */
-    update<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<Context<FabricContractFlags>>): Promise<Record<string, any>>;
-    /**
-     * @description Deletes a record from the state database
-     * @summary Retrieves a record and then removes it from the Fabric state database
-     * @param {string} tableName - The name of the table/collection
-     * @param {string | number} id - The record identifier to delete
-     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
-     * @return {Promise<Record<string, any>>} Promise resolving to the deleted record
-     */
-    delete<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<Context<FabricContractFlags>>): Promise<Record<string, any>>;
-    protected deleteState(id: string, context: FabricContractContext): Promise<void>;
-    forPrivate(collection: string): FabricContractAdapter;
-    protected putState(id: string, model: Record<string, any>, ctx: FabricContractContext): Promise<Record<string, any>>;
-    protected readState(id: string, ctx: FabricContractContext): Promise<any>;
-    protected queryResult(stub: ChaincodeStub, rawInput: any, ...args: ContextualArgs<FabricContractContext>): Promise<Iterators.StateQueryIterator>;
-    protected queryResultPaginated(stub: ChaincodeStub, rawInput: any, limit?: number, page?: number, bookmark?: string | number, ...args: any[]): Promise<StateQueryResponse<Iterators.StateQueryIterator>>;
-    /**
-     * @description Decodes binary data to string
-     * @summary Converts a Uint8Array to a string using UTF-8 encoding
-     * @param {Uint8Array} buffer - The binary data to decode
-     * @return {string} The decoded string
-     */
-    protected decode(buffer: Uint8Array): string;
-    /**
-     * @description Creates operation flags for Fabric contract operations
-     * @summary Merges default flags with Fabric-specific context information
-     * @template M - Type extending Model
-     * @param {OperationKeys} operation - The operation being performed
-     * @param {Constructor<M>} model - The model constructor
-     * @param {Partial<FabricContractFlags>} flags - Partial flags to merge with defaults
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @return {FabricContractFlags} The merged flags
-     */
-    protected flags<M extends Model>(operation: AllOperationKeys, model: Constructor<M> | undefined, flags: Partial<FabricContractFlags> | FabricContractContext | Ctx | any): Promise<FabricContractFlags>;
-    /**
-     * @description Creates an index for a model
-     * @summary This method is not implemented for Fabric contracts and returns a resolved promise
-     * @template M - Type extending Model
-     * @param {Constructor<M>} models - The model constructor
-     * @return {Promise<void>} Promise that resolves immediately
-     */
-    protected index<M>(models: Constructor<M>): Promise<void>;
-    /**
-     * @description Processes results from a state query iterator
-     * @summary Iterates through query results and converts them to a structured format
-     * @param {Logger} log - Logger instance for debugging
-     * @param {Iterators.StateQueryIterator} iterator - The state query iterator
-     * @param {boolean} [isHistory=false] - Whether this is a history query
-     * @return {Promise<any[]>} Promise resolving to an array of processed results
-     * @mermaid
-     * sequenceDiagram
-     *   participant Caller
-     *   participant ResultIterator
-     *   participant Iterator
-     *
-     *   Caller->>ResultIterator: resultIterator(log, iterator, isHistory)
-     *   loop Until done
-     *     ResultIterator->>Iterator: next()
-     *     Iterator-->>ResultIterator: { value, done }
-     *     alt Has value
-     *       ResultIterator->>ResultIterator: Process value based on isHistory
-     *       ResultIterator->>ResultIterator: Add to results array
-     *     end
-     *   end
-     *   ResultIterator->>Iterator: close()
-     *   ResultIterator-->>Caller: allResults
-     */
-    protected resultIterator(log: Logger, iterator: Iterators.StateQueryIterator, isHistory?: boolean): Promise<any[]>;
-    /**
-     * @description Executes a raw query against the state database
-     * @summary Performs a rich query using CouchDB syntax against the Fabric state database
-     * @template R - The return type
-     * @param {MangoQuery} rawInput - The Mango Query to execute
-     * @param {boolean} docsOnly - Whether to return only documents (not used in this implementation)
-     * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
-     * @return {Promise<R>} Promise resolving to the query results
-     * @mermaid
-     * sequenceDiagram
-     *   participant Caller
-     *   participant FabricContractAdapter
-     *   participant Stub
-     *   participant StateDB
-     *
-     *   Caller->>FabricContractAdapter: raw(rawInput, docsOnly, ctx)
-     *   FabricContractAdapter->>FabricContractAdapter: Extract limit and skip
-     *   alt With pagination
-     *     FabricContractAdapter->>Stub: getQueryResultWithPagination(query, limit, skip)
-     *   else Without pagination
-     *     FabricContractAdapter->>Stub: getQueryResult(query)
-     *   end
-     *   Stub->>StateDB: Execute query
-     *   StateDB-->>Stub: Iterator
-     *   Stub-->>FabricContractAdapter: Iterator
-     *   FabricContractAdapter->>FabricContractAdapter: resultIterator(log, iterator)
-     *   FabricContractAdapter-->>Caller: results
-     */
-    raw<R, D extends boolean>(rawInput: MangoQuery, docsOnly?: D, ...args: ContextualArgs<FabricContractContext>): Promise<RawResult<R, D>>;
-    view<R>(ddoc: string, viewName: string, options: Record<string, any>, ..._args: ContextualArgs<FabricContractContext>): Promise<ViewResponse<R>>;
-    Statement<M extends Model>(overrides?: Partial<AdapterFlags>): FabricStatement<M, any>;
-    updateAll<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType[], model: Record<string, any>[], ...args: ContextualArgs<FabricContractContext>): Promise<Record<string, any>[]>;
-    /**
-     *
-     * @param model
-     * @param {string} pk
-     * @param args
-     */
-    prepare<M extends Model>(model: M, ...args: ContextualArgs<FabricContractContext>): PreparedModel & {
-        segregated?: Record<string, Record<string, any>>;
-    };
-    revert<M extends Model>(obj: Record<string, any>, clazz: Constructor<M>, id: PrimaryKeyType, transient?: Record<string, any>, ...args: ContextualArgs<FabricContractContext>): M;
-    private shouldRebuildWithTransient;
-    private getContextMsp;
-    private enforceMirrorAuthorization;
-    createPrefix<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: MaybeContextualArg<FabricContractContext>): [Constructor<M>, PrimaryKeyType, Record<string, any>, ...any[], FabricContractContext];
-    updatePrefix<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: MaybeContextualArg<FabricContractContext>): any[];
-    protected createAllPrefix<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], models: Record<string, any>[], ...args: [...any, FabricContractContext]): (string | string[] | number[] | Record<string, any>[])[];
-    protected updateAllPrefix<M extends Model>(tableName: Constructor<M>, ids: PrimaryKeyType[], models: Record<string, any>[], ...args: [...any, FabricContractContext]): any[];
-    parseError<E extends BaseError>(err: Error | string, reason?: string): E;
-    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, overrides?: Partial<FlagsOf<FabricContractContext>>): Promise<FabricContextualizedArgs<ARGS, METHOD extends string ? true : false>>;
-    updateObservers(table: Constructor<any> | string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: ContextualArgs<FabricContractContext>): Promise<void>;
-    static parseError<E extends BaseError>(err: Error | string): E;
-    /**
-     * @description Static method for decoration overrides
-     * @summary Overrides/extends decaf decoration with Fabric-specific functionality
-     * @static
-     * @override
-     * @return {void}
-     */
-    static decoration(): void;
-}

package/lib/types/contracts/ContractContext.d.ts

@@ -1,89 +0,0 @@
-import { Context } from "@decaf-ts/core";
-import { FabricContractFlags } from "./types";
-import { ChaincodeStub, ClientIdentity } from "fabric-shim-api";
-/**
- * @description Context class for Fabric chaincode operations
- * @summary Provides access to Fabric-specific context elements like stub, identity, and logger to be used by repositories and adapters during contract execution.
- * @template F - Flags specific to Fabric contract operations
- * @param {object} [args] - Optional initialization arguments passed to the base Context
- * @return {void}
- * @class FabricContractContext
- * @example
- * ```typescript
- * // In a Fabric chaincode contract method
- * const context = new FabricContractContext();
- * // Optionally set values via the base Context API
- * context.set('stub', ctx.stub);
- * context.set('clientIdentity', ctx.clientIdentity);
- * context.set('logger', contractLogger);
- *
- * // Access context properties
- * const timestamp = context.timestamp;
- * const creator = context.identity.getID();
- * ```
- * @mermaid
- * sequenceDiagram
- *   participant Contract
- *   participant Context
- *   participant Ledger
- *   Contract->>Context: new FabricContractContext()
- *   Contract->>Context: set('stub'|'clientIdentity'|'logger', ...)
- *   Context-->>Contract: timestamp, identity, logger
- *   Contract->>Ledger: Interact via stub
- */
-export declare class FabricContractContext extends Context<FabricContractFlags> {
-    /**
-     * @description Creates a new FabricContractContext instance
-     * @summary Initializes the context with Fabric-specific flags
-     */
-    constructor(ctx?: FabricContractContext);
-    /**
-     * @description Gets the chaincode stub
-     * @summary Returns the ChaincodeStub instance for interacting with the ledger
-     * @return {ChaincodeStub} The chaincode stub
-     */
-    get stub(): ChaincodeStub;
-    /**
-     * @description Gets the transaction timestamp
-     * @summary Overrides the base timestamp getter to use the stub's timestamp
-     * @return {Date} The transaction timestamp
-     */
-    get timestamp(): Date;
-    /**
-     * @description Gets the client identity
-     * @summary Returns the ClientIdentity instance for the transaction submitter
-     * @return {ClientIdentity} The client identity
-     */
-    get identity(): ClientIdentity;
-    /**
-     * @description Stores segregation metadata per sequence name
-     * @summary Needed because the Sequence creates its own context (via logCtx),
-     * losing flags set by extractSegregatedCollections on the handler context.
-     * The adapter persists across operations, making it a reliable store.
-     */
-    setSequenceSegregation(seqName: string, fullySegregated: boolean, collections: string[]): void;
-    getSequenceSegregation(seqName: string): {
-        fullySegregated: boolean;
-        collections: string[];
-    } | undefined;
-    markFullySegregated(): void;
-    get isFullySegregated(): boolean;
-    writeTo(col: string, entry: string[]): void;
-    getSegregatedWrites(): Record<string, string[]> | undefined;
-    put(key: string, value: any): void;
-    readFrom(cols: string | string[]): void;
-    consumeReadCollections(): string[];
-    /**
-     * @description Gets the collections registered for writing
-     * @summary Returns collection names from segregateWrite, used by sequences to know where to replicate.
-     * @return {string[]} Array of collection names, empty if none registered
-     */
-    getWriteCollections(): string[];
-    /**
-     * @description Gets the collections registered for reading
-     * @summary Returns collection names from segregateRead.
-     * @return {string[]} Array of collection names, empty if none registered
-     */
-    getReadCollections(): string[];
-    toString(): string;
-}

package/lib/types/contracts/FabricContractDispatch.d.ts

@@ -1,7 +0,0 @@
-import { Dispatch, MaybeContextualArg } from "@decaf-ts/core";
-import { type FabricContractAdapter } from "./ContractAdapter";
-import { FabricContractContext } from "./ContractContext";
-export declare class FabricContractDispatch extends Dispatch<FabricContractAdapter> {
-    constructor();
-    protected initialize(...args: MaybeContextualArg<FabricContractContext>): Promise<void>;
-}

package/lib/types/contracts/FabricContractPaginator.d.ts

@@ -1,105 +0,0 @@
-import { MaybeContextualArg } from "@decaf-ts/core";
-import { Model } from "@decaf-ts/decorator-validation";
-import { Constructor } from "@decaf-ts/decoration";
-import { FabricContractAdapter } from "./ContractAdapter";
-import { CouchDBPaginator, MangoQuery } from "@decaf-ts/for-couchdb";
-/**
- * @description Paginator for CouchDB query results
- * @summary Implements pagination for CouchDB queries using bookmarks for efficient navigation through result sets
- * @template M - The model type that extends Model
- * @template R - The result type
- * @param {FabricCo<any, any, any>} adapter - The CouchDB adapter
- * @param {MangoQuery} query - The Mango query to paginate
- * @param {number} size - The page size
- * @param {Constructor<M>} clazz - The model constructor
- * @class CouchDBPaginator
- * @example
- * // Example of using CouchDBPaginator
- * const adapter = new MyCouchDBAdapter(scope);
- * const query = { selector: { type: "user" } };
- * const paginator = new CouchDBPaginator(adapter, query, 10, User);
- *
- * // Get the first page
- * const page1 = await paginator.page(1);
- *
- * // Get the next page
- * const page2 = await paginator.page(2);
- */
-export declare class FabricContractPaginator<M extends Model> extends CouchDBPaginator<M> {
-    /**
-     * @description Creates a new CouchDBPaginator instance
-     * @summary Initializes a paginator for CouchDB query results
-     * @param {CouchDBAdapter<any, any, any, any>} adapter - The CouchDB adapter
-     * @param {MangoQuery} query - The Mango query to paginate
-     * @param {number} size - The page size
-     * @param {Constructor<M>} clazz - The model constructor
-     */
-    constructor(adapter: FabricContractAdapter, query: MangoQuery, size: number, clazz: Constructor<M>);
-    /**
-     * @description Prepares a query for pagination
-     * @summary Modifies the raw query to include pagination parameters
-     * @param {MangoQuery} rawStatement - The original Mango query
-     * @return {MangoQuery} The prepared query with pagination parameters
-     */
-    protected prepare(rawStatement: MangoQuery): MangoQuery;
-    /**
-     * @description Retrieves a specific page of results
-     * @summary Executes the query with pagination and processes the results
-     * @param {number} [page=1] - The page number to retrieve
-     * @return {Promise<R[]>} A promise that resolves to an array of results
-     * @throws {PagingError} If trying to access a page other than the first without a bookmark, or if no class is defined
-     * @mermaid
-     * sequenceDiagram
-     *   participant Client
-     *   participant CouchDBPaginator
-     *   participant Adapter
-     *   participant CouchDB
-     *
-     *   Client->>CouchDBPaginator: page(pageNumber)
-     *   Note over CouchDBPaginator: Clone statement
-     *   CouchDBPaginator->>CouchDBPaginator: validatePage(page)
-     *
-     *   alt page !== 1
-     *     CouchDBPaginator->>CouchDBPaginator: Check bookmark
-     *     alt No bookmark
-     *       CouchDBPaginator-->>Client: Throw PagingError
-     *     else Has bookmark
-     *       CouchDBPaginator->>CouchDBPaginator: Add bookmark to statement
-     *     end
-     *   end
-     *
-     *   CouchDBPaginator->>Adapter: raw(statement, false)
-     *   Adapter->>CouchDB: Execute query
-     *   CouchDB-->>Adapter: Return results
-     *   Adapter-->>CouchDBPaginator: Return MangoResponse
-     *
-     *   Note over CouchDBPaginator: Process results
-     *
-     *   alt Has warning
-     *     CouchDBPaginator->>CouchDBPaginator: Log warning
-     *   end
-     *
-     *   CouchDBPaginator->>CouchDBPaginator: Check for clazz
-     *
-     *   alt No clazz
-     *     CouchDBPaginator-->>Client: Throw PagingError
-     *   else Has clazz
-     *     CouchDBPaginator->>CouchDBPaginator: Find primary key
-     *
-     *     alt Has fields in statement
-     *       CouchDBPaginator->>CouchDBPaginator: Use docs directly
-     *     else No fields
-     *       CouchDBPaginator->>CouchDBPaginator: Process each document
-     *       loop For each document
-     *         CouchDBPaginator->>CouchDBPaginator: Extract original ID
-     *         CouchDBPaginator->>Adapter: revert(doc, clazz, pkDef.id, parsedId)
-     *       end
-     *     end
-     *
-     *     CouchDBPaginator->>CouchDBPaginator: Store bookmark
-     *     CouchDBPaginator->>CouchDBPaginator: Update currentPage
-     *     CouchDBPaginator-->>Client: Return results
-     *   end
-     */
-    page(page?: number, bookmark?: any, ...args: MaybeContextualArg<any>): Promise<M[]>;
-}

package/lib/types/contracts/FabricContractRepository.d.ts

@@ -1,119 +0,0 @@
-import "./overrides";
-import { Repository, ObserverHandler, EventIds, ContextualArgs, MaybeContextualArg, OrderDirection, SerializedPage, DirectionLimitOffset, MethodOrOperation, ContextualizedArgs } from "@decaf-ts/core";
-import { FabricContractContext } from "./ContractContext";
-import { Model } from "@decaf-ts/decorator-validation";
-import { BulkCrudOperationKeys, OperationKeys } from "@decaf-ts/db-decorators";
-import { Constructor } from "@decaf-ts/decoration";
-import { FabricContractAdapter } from "./ContractAdapter";
-import { FabricContractFlags } from "./types";
-/**
- * @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, FabricContractAdapter> {
-    protected omittedEvents?: (OperationKeys | BulkCrudOperationKeys | string)[] | undefined;
-    protected _overrides: Partial<(import("@decaf-ts/db-decorators").ContextFlags<any> & Pick<import("@decaf-ts/db-decorators").RepositoryFlags<any>, "operation" | "correlationId" | "ignoreDevSafeGuards" | "parentContext" | "childContexts"> & {
-        pending?: Record<string, string[]>;
-        transactionLock?: import("@decaf-ts/core").ContextLock;
-    }) | import("@decaf-ts/core").AdapterFlags> & {
-        ignoreValidation: boolean;
-        ignoreHandlers: boolean;
-        allowRawStatements: boolean;
-        forcePrepareSimpleQueries: boolean;
-        forcePrepareComplexQueries: boolean;
-        rebuildWithTransient: boolean;
-    };
-    constructor(adapter?: FabricContractAdapter, clazz?: Constructor<M>, omittedEvents?: (OperationKeys | BulkCrudOperationKeys | string)[] | undefined);
-    create(model: M, ...args: MaybeContextualArg<FabricContractContext>): Promise<M>;
-    createAll(models: M[], ...args: MaybeContextualArg<FabricContractContext>): Promise<M[]>;
-    update(model: M, ...args: MaybeContextualArg<FabricContractContext>): Promise<M>;
-    updateAll(models: M[], ...args: MaybeContextualArg<FabricContractContext>): Promise<M[]>;
-    listBy(key: keyof M, order: OrderDirection, ...args: MaybeContextualArg<FabricContractContext>): Promise<M[]>;
-    paginateBy(key: keyof M, order: OrderDirection, ref?: Omit<DirectionLimitOffset, "direction">, ...args: MaybeContextualArg<FabricContractContext>): Promise<SerializedPage<M>>;
-    statement(name: string, ...args: MaybeContextualArg<FabricContractContext>): Promise<any>;
-    /**
-     * @description Gets the observer handler for this repository
-     * @summary Returns a FabricContractRepositoryObservableHandler instance
-     * @return {ObserverHandler} The observer handler
-     */
-    ObserverHandler(): ObserverHandler;
-    /**
-     * @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: Constructor<M> | string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: ContextualArgs<FabricContractContext>): Promise<void>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD): ContextualizedArgs<FabricContractContext, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: false): ContextualizedArgs<FabricContractContext, 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<ContextualizedArgs<FabricContractContext, ARGS, METHOD extends string ? true : false>>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: true, overrides?: Partial<FabricContractFlags>): Promise<ContextualizedArgs<FabricContractContext, ARGS, METHOD extends string ? true : false>>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<FabricContractContext, ARGS>, operation: METHOD, allowCreate: false, overrides?: Partial<FabricContractFlags>): ContextualizedArgs<FabricContractContext, ARGS, METHOD extends string ? true : false>;
-    private cleanContextualizedArgs;
-    private applyCleanContext;
-    private cleanContext;
-}