@decaf-ts/for-fabric 0.1.1 → 0.1.3

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

@@ -2,11 +2,11 @@ import { CouchDBAdapter, MangoQuery } from "@decaf-ts/for-couchdb";
 import { Model } from "@decaf-ts/decorator-validation";
 import { FabricContractFlags } from "./types";
 import { FabricContractContext } from "./ContractContext";
-import { Context, OperationKeys } from "@decaf-ts/db-decorators";
+import { BaseError, Context, OperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorators";
 import { Context as Ctx } from "fabric-contract-api";
 import { Logger } from "@decaf-ts/logging";
-import { ContractLogger } from "./logging";
-import { RelationsMetadata, Repository, Sequence, SequenceOptions, Adapter } from "@decaf-ts/core";
+import { RelationsMetadata, Sequence, SequenceOptions, Adapter, PreparedModel, Repository } from "@decaf-ts/core";
+import type { ContextualArgs, MaybeContextualArg } from "@decaf-ts/core";
 import { FabricContractRepository } from "./FabricContractRepository";
 import { ChaincodeStub, Iterators, StateQueryResponse } from "fabric-shim-api";
 import { FabricStatement } from "./FabricContractStatement";
@@ -67,7 +67,7 @@ export declare function createdByOnFabricCreateUpdate<M extends Model, R extends
  *   S-->>R: next value
  *   R->>M: define non-writable primary key
  */
-export declare function pkFabricOnCreate<M extends Model, R extends FabricContractRepository<M>, V extends SequenceOptions, F extends FabricContractFlags>(this: R, context: Context<F>, data: V, key: keyof M, model: M): Promise<void>;
+export declare function pkFabricOnCreate<M extends Model, R extends FabricContractRepository<M>>(this: R, context: FabricContractContext, data: SequenceOptions, 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
@@ -105,20 +105,13 @@ export declare function pkFabricOnCreate<M extends Model, R extends FabricContra
  *   Stub-->>FabricContractAdapter: Success
  *   FabricContractAdapter-->>Contract: model
  */
-export declare class FabricContractAdapter extends CouchDBAdapter<any, void, FabricContractFlags, FabricContractContext> {
+export declare class FabricContractAdapter extends CouchDBAdapter<any, void, FabricContractContext> {
     protected getClient(): void;
     /**
      * @description Text decoder for converting binary data to strings
      */
     private static textDecoder;
     protected static readonly serializer: SimpleDeterministicSerializer<Model<false>>;
-    /**
-     * @description Creates a logger for a specific chaincode context
-     * @summary Returns a ContractLogger instance configured for the current context
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @return {ContractLogger} The logger instance
-     */
-    logFor(ctx: Ctx): ContractLogger;
     /**
      * @description Context constructor for this adapter
      * @summary Overrides the base Context constructor with FabricContractContext
@@ -130,7 +123,7 @@ export declare class FabricContractAdapter extends CouchDBAdapter<any, void, Fab
      * @template M - Type extending Model
      * @return {Constructor<Repository<M, MangoQuery, FabricContractAdapter, FabricContractFlags, FabricContractContext>>} The repository constructor
      */
-    repository<M extends Model>(): Constructor<Repository<M, MangoQuery, Adapter<any, any, MangoQuery, FabricContractFlags, FabricContractContext>, FabricContractFlags, FabricContractContext>>;
+    repository<R extends Repository<any, Adapter<any, void, MangoQuery, FabricContractContext>>>(): Constructor<R>;
     /**
      * @description Creates a new FabricContractAdapter instance
      * @summary Initializes an adapter for interacting with the Fabric state database
@@ -149,7 +142,7 @@ export declare class FabricContractAdapter extends CouchDBAdapter<any, void, Fab
      * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
      * @return {Promise<Record<string, any>>} Promise resolving to the created record
      */
-    create(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
+    create<M extends Model>(clazz: 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
@@ -158,7 +151,7 @@ export declare class FabricContractAdapter extends CouchDBAdapter<any, void, Fab
      * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
      * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record
      */
-    read(tableName: string, id: string | number, ...args: any[]): Promise<Record<string, any>>;
+    read<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<FabricContractContext>): Promise<Record<string, any>>;
     /**
      * @description Updates a record in the state database
      * @summary Serializes a model and updates it in the Fabric state database
@@ -169,7 +162,7 @@ export declare class FabricContractAdapter extends CouchDBAdapter<any, void, Fab
      * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
      * @return {Promise<Record<string, any>>} Promise resolving to the updated record
      */
-    update(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
+    update<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<FabricContractContext>): 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
@@ -178,10 +171,11 @@ export declare class FabricContractAdapter extends CouchDBAdapter<any, void, Fab
      * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
      * @return {Promise<Record<string, any>>} Promise resolving to the deleted record
      */
-    delete(tableName: string, id: string | number, ...args: any[]): Promise<Record<string, any>>;
-    protected deleteState(stub: ChaincodeStub, tableName: string, id: string, ...args: any[]): Promise<void>;
-    protected putState(stub: ChaincodeStub, id: string, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
-    protected readState(stub: ChaincodeStub, tableName: string, id: string, ...args: any[]): Promise<any[]>;
+    delete<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<FabricContractContext>): Promise<Record<string, any>>;
+    protected deleteState(id: string, ctx: 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: any[]): Promise<Iterators.StateQueryIterator>;
     protected queryResultPaginated(stub: ChaincodeStub, rawInput: any, limit?: number, skip?: number, ...args: any[]): Promise<StateQueryResponse<Iterators.StateQueryIterator>>;
     protected mergeModels(results: Record<string, any>[]): Record<string, any>;
@@ -265,27 +259,25 @@ export declare class FabricContractAdapter extends CouchDBAdapter<any, void, Fab
      *   FabricContractAdapter->>FabricContractAdapter: resultIterator(log, iterator)
      *   FabricContractAdapter-->>Caller: results
      */
-    raw<R>(rawInput: MangoQuery, docsOnly: boolean, ...args: any[]): Promise<R>;
-    Statement<M extends Model>(ctx?: FabricContractContext): FabricStatement<M, any>;
+    raw<R>(rawInput: MangoQuery, ...args: ContextualArgs<FabricContractContext>): Promise<R>;
+    Statement<M extends Model>(): FabricStatement<M, any>;
     Sequence(options: SequenceOptions): Promise<Sequence>;
-    createAll(tableName: string, id: (string | number)[], model: Record<string, any>[], ...args: any[]): Promise<Record<string, any>[]>;
-    updateAll(tableName: string, id: string[] | number[], model: Record<string, any>[], ...args: any[]): Promise<Record<string, any>[]>;
+    createAll<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType[], model: Record<string, any>[], ...args: ContextualArgs<FabricContractContext>): Promise<Record<string, 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, pk: keyof M, ...args: any[]): {
-        record: Record<string, any>;
-        id: string;
-        transient?: Record<string, any>;
-    };
-    revert<M extends Model>(obj: Record<string, any>, clazz: string | Constructor<M>, pk: keyof M, id: string | number, transient?: Record<string, any>): M;
-    createPrefix(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): (string | number | FabricContractContext | Record<string, any>)[];
-    updatePrefix(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): (string | number | Record<string, any>)[];
-    protected createAllPrefix(tableName: string, ids: string[] | number[], models: Record<string, any>[], ...args: any[]): (string | string[] | number[] | Record<string, any>[])[];
-    protected updateAllPrefix(tableName: string, ids: string[] | number[], models: Record<string, any>[], ...args: any[]): any[];
+    prepare<M extends Model>(model: M, ...args: ContextualArgs<FabricContractContext>): PreparedModel;
+    revert<M extends Model>(obj: Record<string, any>, clazz: Constructor<M>, id: PrimaryKeyType, transient?: Record<string, any>, ...args: ContextualArgs<FabricContractContext>): M;
+    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;
+    static parseError<E extends BaseError>(err: Error | string, reason?: string): E;
     /**
      * @description Static method for decoration overrides
      * @summary Overrides/extends decaf decoration with Fabric-specific functionality

package/lib/esm/contracts/ContractAdapter.js

@@ -3,12 +3,10 @@ import { list, Model, required, type } from "@decaf-ts/decorator-validation";
 import { FabricContractContext } from "./ContractContext.js";
 import { afterAny, DBKeys, InternalError, NotFoundError, onCreate, onCreateUpdate, onDelete, onUpdate, readonly, SerializationError, } from "@decaf-ts/db-decorators";
 import { Object as FabricObject, Property as FabricProperty, } from "fabric-contract-api";
-import { Logging } from "@decaf-ts/logging";
-import { PersistenceKeys, Repository, sequenceNameForModel, UnsupportedError, Adapter, oneToManyOnUpdate, relation, } from "@decaf-ts/core";
+import { PersistenceKeys, UnsupportedError, Adapter, oneToManyOnUpdate, relation, } from "@decaf-ts/core";
 import { FabricContractRepository } from "./FabricContractRepository.js";
 import { FabricStatement } from "./FabricContractStatement.js";
 import { FabricContractSequence } from "./FabricContractSequence.js";
-import { MissingContextError } from "./../shared/errors.js";
 import { FabricFlavour } from "./../shared/constants.js";
 import { SimpleDeterministicSerializer } from "./../shared/SimpleDeterministicSerializer.js";
 import { oneToManyOnCreate, oneToManyOnDelete, oneToOneOnCreate, oneToOneOnDelete, oneToOneOnUpdate, populate as pop, } from "./FabricConstruction.js";
@@ -41,7 +39,7 @@ import { apply, Decoration, prop, propMetadata, Metadata, } from "@decaf-ts/deco
  */
 export async function createdByOnFabricCreateUpdate(context, data, key, model) {
     try {
-        const user = context.get("clientIdentity");
+        const user = context.get("identity");
         model[key] = user.getID();
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
     }
@@ -90,7 +88,7 @@ export async function pkFabricOnCreate(context, data, key, model) {
         });
     };
     if (!data.name)
-        data.name = sequenceNameForModel(model, "pk");
+        data.name = Model.sequenceName(model, "pk");
     let sequence;
     try {
         sequence = (await this.adapter.Sequence(data));
@@ -147,15 +145,6 @@ export class FabricContractAdapter extends CouchDBAdapter {
      */
     static { this.textDecoder = new TextDecoder("utf8"); }
     static { this.serializer = new SimpleDeterministicSerializer(); }
-    /**
-     * @description Creates a logger for a specific chaincode context
-     * @summary Returns a ContractLogger instance configured for the current context
-     * @param {Ctx} ctx - The Fabric chaincode context
-     * @return {ContractLogger} The logger instance
-     */
-    logFor(ctx) {
-        return Logging.for(FabricContractAdapter, {}, ctx);
-    }
     /**
      * @description Gets the repository constructor for this adapter
      * @summary Returns the FabricContractRepository constructor for creating repositories
@@ -192,12 +181,14 @@ export class FabricContractAdapter extends CouchDBAdapter {
      * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
      * @return {Promise<Record<string, any>>} Promise resolving to the created record
      */
-    async create(tableName, id, model, ...args) {
-        const { stub, logger } = args.pop();
-        const log = logger.for(this.create);
+    async create(clazz, id, model, ...args) {
+        const { ctx, log } = this.logCtx(args, this.create);
+        const { stub } = ctx;
+        const tableName = Model.tableName(clazz);
         try {
             log.info(`adding entry to ${tableName} table with pk ${id}`);
-            model = await this.putState(stub, id.toString(), model);
+            const composedKey = stub.createCompositeKey(tableName, [String(id)]);
+            model = await this.putState(composedKey, model, ctx);
         }
         catch (e) {
             throw this.parseError(e);
@@ -212,12 +203,14 @@ export class FabricContractAdapter extends CouchDBAdapter {
      * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
      * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record
      */
-    async read(tableName, id, ...args) {
-        const { stub, logger } = args.pop();
-        const log = logger.for(this.read);
+    async read(clazz, id, ...args) {
+        const { ctx, log } = this.logCtx(args, this.read);
+        const { stub } = ctx;
+        const tableName = Model.tableName(clazz);
         let model;
         try {
-            const results = await this.readState(stub, tableName, id.toString());
+            const composedKey = stub.createCompositeKey(tableName, [String(id)]);
+            const results = await this.readState(composedKey, ctx);
             if (results.length < 1) {
                 log.debug(`No record found for id ${id} in ${tableName} table`);
                 throw new NotFoundError(`No record found for id ${id} in ${tableName} table`);
@@ -245,12 +238,14 @@ export class FabricContractAdapter extends CouchDBAdapter {
      * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
      * @return {Promise<Record<string, any>>} Promise resolving to the updated record
      */
-    async update(tableName, id, model, ...args) {
-        const { stub, logger } = args.pop();
-        const log = logger.for(this.update);
+    async update(clazz, id, model, ...args) {
+        const { ctx, log } = this.logCtx(args, this.update);
+        const { stub } = ctx;
+        const tableName = Model.tableName(clazz);
         try {
-            log.info(`updating entry to ${tableName} table with pk ${id}`);
-            model = await this.putState(stub, id.toString(), model);
+            log.verbose(`updating entry to ${tableName} table with pk ${id}`);
+            const composedKey = stub.createCompositeKey(tableName, [String(id)]);
+            model = await this.putState(composedKey, model, ctx);
         }
         catch (e) {
             throw this.parseError(e);
@@ -265,32 +260,120 @@ export class FabricContractAdapter extends CouchDBAdapter {
      * @param {...any[]} args - Additional arguments, including the chaincode stub and logger
      * @return {Promise<Record<string, any>>} Promise resolving to the deleted record
      */
-    async delete(tableName, id, ...args) {
-        const ctx = args.pop();
-        const { stub, logger } = ctx;
-        const log = logger.for(this.delete);
-        args.push(ctx);
+    async delete(clazz, id, ...args) {
+        const { ctx, log, ctxArgs } = this.logCtx(args, this.delete);
+        const { stub } = ctx;
+        const tableName = Model.tableName(clazz);
         let model;
         try {
-            model = await this.read(tableName, id, ...args);
+            const composedKey = stub.createCompositeKey(tableName, [String(id)]);
+            model = await this.read(clazz, id, ...ctxArgs);
             log.verbose(`deleting entry with pk ${id} from ${tableName} table`);
-            this.deleteState(stub, tableName, id.toString());
+            await this.deleteState(composedKey, ctx);
         }
         catch (e) {
             throw this.parseError(e);
         }
         return model;
     }
-    async deleteState(stub, tableName, id, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    ...args) {
-        const composedKey = stub.createCompositeKey(tableName, [String(id)]);
-        await stub.deleteState(composedKey);
+    async deleteState(id, ctx) {
+        const { stub, logger } = ctx;
+        const log = logger.for(this.deleteState);
+        await stub.deleteState(id);
+        log.trace(`Deleted state for id ${id}`);
+    }
+    forPrivate(collection) {
+        const toOverride = [
+            this.putState,
+            this.readState,
+            this.deleteState,
+            this.queryResult,
+            this.queryResultPaginated,
+        ].map((fn) => fn.name);
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                if (!toOverride.includes(prop))
+                    return Reflect.get(target, prop, receiver);
+                return new Proxy(target[prop], {
+                    async apply(fn, thisArg, argsList) {
+                        switch (prop) {
+                            case "putState": {
+                                const [stub, id, model] = argsList;
+                                await stub.putPrivateData(collection, id.toString(), model);
+                                return model;
+                            }
+                            case "deleteState": {
+                                const [stub, id] = argsList;
+                                return stub.deletePrivateData(collection, id);
+                            }
+                            case "readState": {
+                                const [stub, id] = argsList;
+                                return stub.getPrivateData(collection, id);
+                            }
+                            case "queryResult": {
+                                const [stub, rawInput] = argsList;
+                                return stub.getPrivateDataQueryResult(collection, rawInput);
+                            }
+                            case "queryResultPaginated": {
+                                const [stub, rawInput, limit, skip] = argsList;
+                                const iterator = await stub.getPrivateDataQueryResult(collection, rawInput);
+                                const results = [];
+                                let count = 0;
+                                let reachedBookmark = skip ? false : true;
+                                let lastKey = null;
+                                while (true) {
+                                    const res = await iterator.next();
+                                    if (res.value && res.value.value.toString()) {
+                                        const recordKey = res.value.key;
+                                        const recordValue = res.value.value.toString("utf8");
+                                        // If we have a skip, skip until we reach it
+                                        if (!reachedBookmark) {
+                                            if (recordKey === skip?.toString()) {
+                                                reachedBookmark = true;
+                                            }
+                                            continue;
+                                        }
+                                        results.push({
+                                            Key: recordKey,
+                                            Record: JSON.parse(recordValue),
+                                        });
+                                        lastKey = recordKey;
+                                        count++;
+                                        if (count >= limit) {
+                                            await iterator.close();
+                                            return {
+                                                iterator: results,
+                                                metadata: {
+                                                    fetchedRecordsCount: results.length,
+                                                    bookmark: lastKey,
+                                                },
+                                            };
+                                        }
+                                    }
+                                    if (res.done) {
+                                        await iterator.close();
+                                        return {
+                                            iterator: results,
+                                            metadata: {
+                                                fetchedRecordsCount: results.length,
+                                                bookmark: "",
+                                            },
+                                        };
+                                    }
+                                }
+                            }
+                            default:
+                                throw new InternalError(`Unsupported method override ${String(prop)}`);
+                        }
+                    },
+                });
+            },
+        });
     }
-    async putState(stub, id, model, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    ...args) {
+    async putState(id, model, ctx) {
         let data;
+        const { stub, logger } = ctx;
+        const log = logger.for(this.putState);
         try {
             data = Buffer.from(FabricContractAdapter.serializer.serialize(model));
         }
@@ -298,26 +381,24 @@ export class FabricContractAdapter extends CouchDBAdapter {
             throw new SerializationError(`Failed to serialize record with id ${id}: ${e}`);
         }
         await stub.putState(id.toString(), data);
+        log.silly(`state stored under id ${id}`);
         return model;
     }
-    async readState(stub, tableName, id, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    ...args) {
-        const composedKey = stub.createCompositeKey(tableName, [String(id)]);
-        const results = [];
-        let res = await stub.getState(composedKey);
-        if (res.toString() === "")
+    async readState(id, ctx) {
+        let result;
+        const { stub, logger } = ctx;
+        const log = logger.for(this.readState);
+        const res = (await stub.getState(id)).toString();
+        if (!res)
             throw new NotFoundError(`Record with id ${id} not found`);
+        log.silly(`Read state for id ${id}`);
         try {
-            res = FabricContractAdapter.serializer.deserialize(res.toString()
-            // model.constructor.name
-            );
+            result = FabricContractAdapter.serializer.deserialize(res.toString());
         }
         catch (e) {
             throw new SerializationError(`Failed to parse record: ${e}`);
         }
-        results.push(res);
-        return results;
+        return result;
     }
     async queryResult(stub, rawInput, 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -361,10 +442,32 @@ export class FabricContractAdapter extends CouchDBAdapter {
      * @return {FabricContractFlags} The merged flags
      */
     async flags(operation, model, flags, ctx, ...args) {
-        return Object.assign(await super.flags(operation, model, flags, ...args), {
+        const ensureLogger = (logger) => {
+            const base = logger ?? this.log.for(this.flags);
+            if (typeof base.clear !== "function")
+                base.clear = () => base;
+            if (typeof base.for !== "function")
+                base.for = () => base;
+            return base;
+        };
+        const fabricCtx = ctx instanceof FabricContractContext
+            ? ctx.accumulate({
+                logger: ensureLogger(ctx.logger),
+            })
+            : new FabricContractContext().accumulate({
+                stub: ctx.stub,
+                identity: ctx.clientIdentity,
+                logger: ensureLogger(),
+            });
+        const baseFlags = Object.assign({}, flags, {
+            logger: fabricCtx.logger,
+        });
+        return Object.assign(await super.flags(operation, model, baseFlags, ...args), {
             stub: ctx.stub,
-            identity: ctx.clientIdentity ?? ctx.identity,
-            logger: ctx.logger ?? this.logFor(ctx),
+            identity: (ctx.clientIdentity ??
+                fabricCtx.identity),
+            logger: fabricCtx.logger,
+            correlationId: ctx.stub.getTxID(),
         });
     }
     /**
@@ -466,9 +569,10 @@ export class FabricContractAdapter extends CouchDBAdapter {
      *   FabricContractAdapter->>FabricContractAdapter: resultIterator(log, iterator)
      *   FabricContractAdapter-->>Caller: results
      */
-    async raw(rawInput, docsOnly, ...args) {
-        const { stub, logger } = args.pop();
-        const log = logger.for(this.raw);
+    async raw(rawInput, ...args) {
+        const { ctx, log, ctxArgs } = this.logCtx(args, this.raw);
+        const docsOnly = typeof ctxArgs[0] === "boolean" ? ctxArgs.shift() : false;
+        const { stub } = ctx;
         const { skip, limit } = rawInput;
         let iterator;
         if (limit || skip) {
@@ -487,11 +591,8 @@ export class FabricContractAdapter extends CouchDBAdapter {
         log.debug(`returning {0} results`, `${Array.isArray(results) ? results.length : 1}`);
         return results;
     }
-    Statement(ctx) {
-        if (!ctx) {
-            throw new MissingContextError("Context is required");
-        }
-        return new FabricStatement(this, ctx);
+    Statement() {
+        return new FabricStatement(this);
     }
     async Sequence(options) {
         return new FabricContractSequence(options, this);
@@ -499,24 +600,18 @@ export class FabricContractAdapter extends CouchDBAdapter {
     async createAll(tableName, id, model, ...args) {
         if (id.length !== model.length)
             throw new InternalError("Ids and models must have the same length");
-        const { logger } = args[args.length - 1];
-        const log = logger.for(this.createAll);
-        log.info(`Creating ${id.length} entries ${tableName} table`);
-        log.debug(`pks: ${id}`);
-        return Promise.all(id.map(async (i, index) => {
-            return this.create(tableName, i, model[index], ...args);
-        }));
+        const { log, ctxArgs } = this.logCtx(args, this.createAll);
+        const tableLabel = Model.tableName(tableName);
+        log.debug(`Creating ${id.length} entries ${tableLabel} table`);
+        return Promise.all(id.map((i, count) => this.create(tableName, i, model[count], ...ctxArgs)));
     }
     async updateAll(tableName, id, model, ...args) {
         if (id.length !== model.length)
             throw new InternalError("Ids and models must have the same length");
-        const { logger } = args[args.length - 1];
-        const log = logger.for(this.createAll);
-        log.info(`Updating ${id.length} entries ${tableName} table`);
-        log.debug(`pks: ${id}`);
-        return Promise.all(id.map(async (i, index) => {
-            return this.update(tableName, i, model[index], ...args);
-        }));
+        const { log, ctxArgs } = this.logCtx(args, this.updateAll);
+        const tableLabel = Model.tableName(tableName);
+        log.debug(`Updating ${id.length} entries ${tableLabel} table`);
+        return Promise.all(id.map((i, count) => this.update(tableName, i, model[count], ...ctxArgs)));
     }
     /**
      *
@@ -524,79 +619,62 @@ export class FabricContractAdapter extends CouchDBAdapter {
      * @param {string} pk
      * @param args
      */
-    prepare(model, pk, ...args) {
-        const { stub, logger } = args.pop();
-        const tableName = args.shift();
-        const log = logger.for(this.prepare);
+    prepare(model, ...args) {
+        const { log } = this.logCtx(args, this.prepare);
+        const tableName = Model.tableName(model.constructor);
+        const pk = Model.pk(model.constructor);
         const split = Model.segregate(model);
         const result = Object.entries(split.model).reduce((accum, [key, val]) => {
             if (typeof val === "undefined")
                 return accum;
-            const mappedProp = Repository.column(model, key);
+            const mappedProp = Model.columnName(model, key);
             if (this.isReserved(mappedProp))
                 throw new InternalError(`Property name ${mappedProp} is reserved`);
             accum[mappedProp] = val;
             return accum;
         }, {});
-        if (model[PersistenceKeys.METADATA]) {
-            log.silly(`Passing along persistence metadata for ${model[PersistenceKeys.METADATA]}`);
-            Object.defineProperty(result, PersistenceKeys.METADATA, {
-                enumerable: false,
-                writable: false,
-                configurable: true,
-                value: model[PersistenceKeys.METADATA],
-            });
-        }
-        log.info(`Preparing record for ${tableName} table with pk ${model[pk]}`);
+        log.silly(`Preparing record for ${tableName} table with pk ${model[pk]}`);
         return {
             record: result,
-            id: stub.createCompositeKey(tableName, [String(model[pk])]),
+            id: model[pk],
             transient: split.transient,
         };
     }
-    revert(obj, clazz, pk, id, transient) {
-        const log = this.log.for(this.revert);
+    revert(obj, clazz, id, transient, ...args) {
+        const { log } = this.logCtx(args, this.revert);
         const ob = {};
+        const pk = Model.pk(clazz);
         ob[pk] = id;
         const m = (typeof clazz === "string" ? Model.build(ob, clazz) : new clazz(ob));
         log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);
-        const metadata = obj[PersistenceKeys.METADATA];
         const result = Object.keys(m).reduce((accum, key) => {
-            accum[key] = obj[Repository.column(accum, key)];
+            accum[key] =
+                obj[Model.columnName(accum, key)];
             return accum;
         }, m);
         if (transient) {
-            log.verbose(`re-adding transient properties: ${Object.keys(transient).join(", ")}`);
+            log.debug(`re-adding transient properties: ${Object.keys(transient).join(", ")}`);
             Object.entries(transient).forEach(([key, val]) => {
                 if (key in result && result[key] !== undefined)
                     throw new InternalError(`Transient property ${key} already exists on model ${m.constructor.name}. should be impossible`);
                 result[key] = val;
             });
         }
-        if (metadata) {
-            log.silly(`Passing along ${this.flavour} persistence metadata for ${m.constructor.name} id ${id}: ${metadata}`);
-            Object.defineProperty(result, PersistenceKeys.METADATA, {
-                enumerable: false,
-                configurable: false,
-                writable: false,
-                value: metadata,
-            });
-        }
         return result;
     }
     createPrefix(tableName, id, model, ...args) {
-        const ctx = args.pop();
+        const { ctxArgs } = this.logCtx(args, this.createPrefix);
         const record = {};
-        record[CouchDBKeys.TABLE] = tableName;
+        record[CouchDBKeys.TABLE] = Model.tableName(tableName);
         Object.assign(record, model);
-        return [tableName, id, record, ctx];
+        return [tableName, id, record, ...ctxArgs];
     }
     updatePrefix(tableName, id, model, ...args) {
-        const ctx = args.pop();
+        const { ctxArgs } = this.logCtx(args, this.updatePrefix);
         const record = {};
-        record[CouchDBKeys.TABLE] = tableName;
+        record[CouchDBKeys.TABLE] = Model.tableName(tableName);
         Object.assign(record, model);
-        return [tableName, id, record, ctx];
+        return [tableName, id, record, ...ctxArgs];
     }
     createAllPrefix(tableName, ids, models, ...args) {
         if (ids.length !== models.length)
@@ -605,7 +683,6 @@ export class FabricContractAdapter extends CouchDBAdapter {
         const records = ids.map((id, count) => {
             const record = {};
             record[CouchDBKeys.TABLE] = tableName;
-            // record[CouchDBKeys.ID] = this.generateId(tableName, id);
             Object.assign(record, models[count]);
             return record;
         });
@@ -623,6 +700,18 @@ export class FabricContractAdapter extends CouchDBAdapter {
         });
         return [tableName, ids, records, ctx];
     }
+    parseError(err, reason) {
+        return FabricContractAdapter.parseError(reason || err);
+    }
+    static parseError(err, reason) {
+        // if (
+        //   MISSING_PRIVATE_DATA_REGEX.test(
+        //     typeof err === "string" ? err : err.message
+        //   )
+        // )
+        //   return new UnauthorizedPrivateDataAccess(err) as E;
+        return super.parseError(err, reason);
+    }
     /**
      * @description Static method for decoration overrides
      * @summary Overrides/extends decaf decoration with Fabric-specific functionality