@decaf-ts/for-fabric 0.0.2

package/lib/esm/contracts/ContractAdapter.js

@@ -0,0 +1,724 @@
+import { CouchDBAdapter, CouchDBKeys } from "@decaf-ts/for-couchdb";
+import { Decoration, list, Model, prop, propMetadata, required, type, } from "@decaf-ts/decorator-validation";
+import { FabricContractContext } from "./ContractContext.js";
+import { afterAny, DBKeys, InternalError, modelToTransient, 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 { OrderDirection, PersistenceKeys, Repository, sequenceNameForModel, UnsupportedError, index, NumericSequence, Adapter, oneToManyOnUpdate, } 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";
+import { apply } from "@decaf-ts/reflection";
+/**
+ * @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 async function createdByOnFabricCreateUpdate(context, data, key, model) {
+    try {
+        const user = context.get("clientIdentity");
+        model[key] = user.getID();
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (e) {
+        throw new UnsupportedError("No User found in context. Please provide a user in the context");
+    }
+}
+/**
+ * @description Primary key auto-assignment callback for Fabric models
+ * @summary Generates and assigns a primary key value to the specified model property using a Fabric-backed sequence when the model is created. If the sequence name is not provided in options, it is derived from the model via sequenceNameForModel. The assigned key is defined as non-writable and enumerable.
+ * @template M - Type extending Model for the target instance
+ * @template R - Type extending FabricContractRepository for repository context
+ * @template V - Type extending SequenceOptions to configure sequence behavior
+ * @template F - Type extending FabricContractFlags for contextual flags
+ * @param {R} this - The repository instance invoking the callback
+ * @param {FabricContractContext} context - Fabric contract context containing invocation metadata
+ * @param {V} data - Sequence options used to configure or locate the sequence
+ * @param {string} key - The primary key property name to assign on the model
+ * @param {M} model - The model instance to receive the generated primary key
+ * @return {Promise<void>} Resolves when the key is assigned or when no action is required
+ * @function pkFabricOnCreate
+ * @memberOf module:for-fabric.contracts
+ * @mermaid
+ * sequenceDiagram
+ *   participant R as Repository
+ *   participant C as Context<F>
+ *   participant S as FabricContractDBSequence
+ *   participant M as Model
+ *   R->>R: derive sequence name if missing
+ *   R->>S: adapter.Sequence(options)
+ *   S-->>R: sequence instance
+ *   R->>S: next(context)
+ *   S-->>R: next value
+ *   R->>M: define non-writable primary key
+ */
+export async function pkFabricOnCreate(context, data, key, model) {
+    if (!data.type || model[key]) {
+        return;
+    }
+    const setPrimaryKeyValue = function (target, propertyKey, value) {
+        Object.defineProperty(target, propertyKey, {
+            enumerable: true,
+            writable: false,
+            configurable: true,
+            value: value,
+        });
+    };
+    if (!data.name)
+        data.name = sequenceNameForModel(model, "pk");
+    let sequence;
+    try {
+        sequence = (await this.adapter.Sequence(data));
+    }
+    catch (e) {
+        throw new InternalError(`Failed to instantiate Sequence ${data.name}: ${e}`);
+    }
+    const next = await sequence.next(context);
+    setPrimaryKeyValue(model, key, next);
+}
+/**
+ * @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 class FabricContractAdapter extends CouchDBAdapter {
+    getClient() {
+        throw new UnsupportedError("Client is not supported in Fabric contracts");
+    }
+    /**
+     * @description Text decoder for converting binary data to strings
+     */
+    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
+     * @template M - Type extending Model
+     * @return {Constructor<Repository<M, MangoQuery, FabricContractAdapter, FabricContractFlags, FabricContractContext>>} The repository constructor
+     */
+    repository() {
+        return FabricContractRepository;
+    }
+    /**
+     * @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, alias) {
+        super(scope, FabricFlavour, alias);
+        /**
+         * @description Context constructor for this adapter
+         * @summary Overrides the base Context constructor with FabricContractContext
+         */
+        this.Context = FabricContractContext;
+    }
+    for(config, ...args) {
+        return super.for(config, ...args);
+    }
+    /**
+     * @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
+     */
+    async create(tableName, id, model, ...args) {
+        const { stub, logger } = args.pop();
+        const log = logger.for(this.create);
+        try {
+            log.info(`adding entry to ${tableName} table with pk ${id}`);
+            model = await this.putState(stub, id.toString(), model);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        return model;
+    }
+    /**
+     * @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
+     */
+    async read(tableName, id, ...args) {
+        const { stub, logger } = args.pop();
+        const log = logger.for(this.read);
+        let model;
+        try {
+            const results = await this.readState(stub, tableName, id.toString());
+            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`);
+            }
+            else if (results.length < 2) {
+                log.debug(`No record found for id ${id} in ${tableName} table`);
+                model = results.pop();
+            }
+            else {
+                model = this.mergeModels(results);
+            }
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        return model;
+    }
+    /**
+     * @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
+     */
+    async update(tableName, id, model, ...args) {
+        const { stub, logger } = args.pop();
+        const log = logger.for(this.update);
+        try {
+            log.info(`updating entry to ${tableName} table with pk ${id}`);
+            model = await this.putState(stub, id.toString(), model);
+        }
+        catch (e) {
+            throw this.parseError(e);
+        }
+        return model;
+    }
+    /**
+     * @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
+     */
+    async delete(tableName, id, ...args) {
+        const ctx = args.pop();
+        const { stub, logger } = ctx;
+        const log = logger.for(this.delete);
+        args.push(ctx);
+        let model;
+        try {
+            model = await this.read(tableName, id, ...args);
+            log.verbose(`deleting entry with pk ${id} from ${tableName} table`);
+            this.deleteState(stub, tableName, id.toString());
+        }
+        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 putState(stub, id, model, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        let data;
+        try {
+            data = Buffer.from(FabricContractAdapter.serializer.serialize(model));
+        }
+        catch (e) {
+            throw new SerializationError(`Failed to serialize record with id ${id}: ${e}`);
+        }
+        await stub.putState(id.toString(), data);
+        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() === "")
+            throw new NotFoundError(`Record with id ${id} not found`);
+        try {
+            res = FabricContractAdapter.serializer.deserialize(res.toString()
+            // model.constructor.name
+            );
+        }
+        catch (e) {
+            throw new SerializationError(`Failed to parse record: ${e}`);
+        }
+        results.push(res);
+        return results;
+    }
+    async queryResult(stub, rawInput, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        return (await stub.getQueryResult(JSON.stringify(rawInput)));
+    }
+    async queryResultPaginated(stub, rawInput, limit = 250, skip, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        return (await stub.getQueryResultWithPagination(JSON.stringify(rawInput), limit, skip?.toString()));
+    }
+    mergeModels(results) {
+        const extract = (model) => Object.entries(model).reduce((accum, [key, val]) => {
+            if (typeof val !== "undefined")
+                accum[key] = val;
+            return accum;
+        }, {});
+        let finalModel = results.pop();
+        for (const res of results) {
+            finalModel = Object.assign({}, extract(finalModel), extract(res));
+        }
+        return finalModel;
+    }
+    /**
+     * @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
+     */
+    decode(buffer) {
+        return FabricContractAdapter.textDecoder.decode(buffer);
+    }
+    /**
+     * @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
+     */
+    async flags(operation, model, flags, ctx, ...args) {
+        return Object.assign(await super.flags(operation, model, flags, ...args), {
+            stub: ctx.stub,
+            identity: ctx.clientIdentity,
+            logger: this.logFor(ctx),
+        });
+    }
+    /**
+     * @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
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    index(models) {
+        return Promise.resolve(undefined);
+    }
+    /**
+     * @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
+     */
+    async resultIterator(log, iterator, isHistory = false) {
+        const allResults = [];
+        let res = await iterator.next();
+        while (!res.done) {
+            if (res.value && res.value.value.toString()) {
+                let jsonRes = {};
+                log.debug(res.value.value.toString("utf8"));
+                if (isHistory /* && isHistory === true*/) {
+                    jsonRes.TxId = res.value.txId;
+                    jsonRes.Timestamp = res.value.timestamp;
+                    try {
+                        jsonRes.Value = JSON.parse(res.value.value.toString("utf8"));
+                    }
+                    catch (err) {
+                        log.error(err);
+                        jsonRes.Value = res.value.value.toString("utf8");
+                    }
+                }
+                else {
+                    try {
+                        jsonRes = JSON.parse(res.value.value.toString("utf8"));
+                    }
+                    catch (err) {
+                        log.error(err);
+                        jsonRes = res.value.value.toString("utf8");
+                    }
+                }
+                allResults.push(jsonRes);
+            }
+            res = await iterator.next();
+        }
+        log.debug(`Closing iterator after ${allResults.length} results`);
+        iterator.close(); // purposely not await. let iterator close on its own
+        return allResults;
+    }
+    /**
+     * @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
+     */
+    async raw(rawInput, docsOnly, ...args) {
+        const { stub, logger } = args.pop();
+        const log = logger.for(this.raw);
+        const { skip, limit } = rawInput;
+        let iterator;
+        if (limit || skip) {
+            delete rawInput["limit"];
+            delete rawInput["skip"];
+            log.debug(`Retrieving paginated iterator: limit: ${limit}/ skip: ${skip}`);
+            const response = (await this.queryResultPaginated(stub, rawInput, limit || 250, skip?.toString()));
+            iterator = response.iterator;
+        }
+        else {
+            log.debug("Retrieving iterator");
+            iterator = (await this.queryResult(stub, rawInput));
+        }
+        log.debug("Iterator acquired");
+        const results = (await this.resultIterator(log, iterator));
+        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);
+    }
+    async Sequence(options) {
+        return new FabricContractSequence(options, this);
+    }
+    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);
+        }));
+    }
+    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);
+        }));
+    }
+    /**
+     *
+     * @param model
+     * @param {string} pk
+     * @param args
+     */
+    prepare(model, pk, ...args) {
+        const { stub, logger } = args.pop();
+        const tableName = args.shift();
+        const log = logger.for(this.prepare);
+        const split = modelToTransient(model);
+        const result = Object.entries(split.model).reduce((accum, [key, val]) => {
+            if (typeof val === "undefined")
+                return accum;
+            const mappedProp = Repository.column(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]}`);
+        return {
+            record: result,
+            id: stub.createCompositeKey(tableName, [String(model[pk])]),
+            transient: split.transient,
+        };
+    }
+    revert(obj, clazz, pk, id, transient) {
+        const log = this.log.for(this.revert);
+        const ob = {};
+        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)];
+            return accum;
+        }, m);
+        if (transient) {
+            log.verbose(`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 record = {};
+        record[CouchDBKeys.TABLE] = tableName;
+        // record[CouchDBKeys.ID] = this.generateId(tableName, id);
+        Object.assign(record, model);
+        return [tableName, id, record, ctx];
+    }
+    updatePrefix(tableName, id, model, ...args) {
+        const ctx = args.pop();
+        const record = {};
+        record[CouchDBKeys.TABLE] = tableName;
+        // record[CouchDBKeys.ID] = this.generateId(tableName, id);
+        Object.assign(record, model);
+        return [tableName, id, record, ctx];
+    }
+    createAllPrefix(tableName, ids, models, ...args) {
+        if (ids.length !== models.length)
+            throw new InternalError("Ids and models must have the same length");
+        const ctx = args.pop();
+        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;
+        });
+        return [tableName, ids, records, ctx];
+    }
+    updateAllPrefix(tableName, ids, models, ...args) {
+        if (ids.length !== models.length)
+            throw new InternalError("Ids and models must have the same length");
+        const ctx = args.pop();
+        const records = ids.map((id, count) => {
+            const record = {};
+            record[CouchDBKeys.TABLE] = tableName;
+            Object.assign(record, models[count]);
+            return record;
+        });
+        return [tableName, ids, records, ctx];
+    }
+    /**
+     * @description Static method for decoration overrides
+     * @summary Overrides/extends decaf decoration with Fabric-specific functionality
+     * @static
+     * @override
+     * @return {void}
+     */
+    static decoration() {
+        super.decoration();
+        const createdByKey = Repository.key(PersistenceKeys.CREATED_BY);
+        const updatedByKey = Repository.key(PersistenceKeys.UPDATED_BY);
+        Decoration.flavouredAs(FabricFlavour)
+            .for(createdByKey)
+            .define(onCreate(createdByOnFabricCreateUpdate), propMetadata(createdByKey, {}))
+            .apply();
+        Decoration.flavouredAs(FabricFlavour)
+            .for(updatedByKey)
+            .define(onCreateUpdate(createdByOnFabricCreateUpdate), propMetadata(updatedByKey, {}))
+            .apply();
+        const pkKey = Repository.key(DBKeys.ID);
+        Decoration.flavouredAs(FabricFlavour)
+            .for(pkKey)
+            .define(index([OrderDirection.ASC, OrderDirection.DSC]), required(), readonly(), 
+        // type([String.name, Number.name, BigInt.name]),
+        propMetadata(pkKey, NumericSequence), onCreate(pkFabricOnCreate, NumericSequence))
+            .apply();
+        const columnKey = Adapter.key(PersistenceKeys.COLUMN);
+        Decoration.flavouredAs(FabricFlavour)
+            .for(columnKey)
+            .extend(FabricProperty())
+            .apply();
+        const tableKey = Adapter.key(PersistenceKeys.TABLE);
+        Decoration.flavouredAs(FabricFlavour)
+            .for(tableKey)
+            .extend(function table(obj) {
+            // const chain: any[] = [];
+            // let current = obj;
+            // do {
+            //   chain.push(current);
+            //   console.log(`Found class: ${current}`);
+            // } while (current && current !== Object.prototype);
+            // do {
+            //   current = chain.pop();
+            //   console.log(`Applying @Object() to class: ${current}`);
+            //   //TODO: THIS IS NOT WORKING AND THROWS ERROR
+            //   // FabricObject()(current);
+            // } while (chain.length > 1);
+            return FabricObject()(obj);
+        })
+            .apply();
+        const oneToOnekey = Repository.key(PersistenceKeys.ONE_TO_ONE);
+        function oneToOneDec(clazz, cascade, populate, joinColumnOpts, fk) {
+            const meta = {
+                class: clazz.name ? clazz.name : clazz,
+                cascade: cascade,
+                populate: populate,
+            };
+            if (joinColumnOpts)
+                meta.joinTable = joinColumnOpts;
+            if (fk)
+                meta.name = fk;
+            return apply(prop(PersistenceKeys.RELATIONS), type([
+                clazz.name ? clazz.name : clazz,
+                String.name,
+                Number.name,
+                BigInt.name,
+            ]), onCreate(oneToOneOnCreate, meta), onUpdate(oneToOneOnUpdate, meta), onDelete(oneToOneOnDelete, meta), afterAny(pop, meta), propMetadata(oneToOnekey, meta));
+        }
+        Decoration.flavouredAs(FabricFlavour)
+            .for(oneToOnekey)
+            .define({
+            decorator: oneToOneDec,
+        })
+            .apply();
+        const oneToManyKey = Repository.key(PersistenceKeys.ONE_TO_MANY);
+        function oneToManyDec(clazz, cascade, populate, joinTableOpts, fk) {
+            const metadata = {
+                class: clazz.name ? clazz.name : clazz,
+                cascade: cascade,
+                populate: populate,
+            };
+            if (joinTableOpts)
+                metadata.joinTable = joinTableOpts;
+            if (fk)
+                metadata.name = fk;
+            return apply(prop(PersistenceKeys.RELATIONS), list([clazz, String, Number, BigInt]), onCreate(oneToManyOnCreate, metadata), onUpdate(oneToManyOnUpdate, metadata), onDelete(oneToManyOnDelete, metadata), afterAny(pop, metadata), propMetadata(oneToManyKey, metadata));
+        }
+        Decoration.for(oneToManyKey)
+            .define({
+            decorator: oneToManyDec,
+        })
+            .apply();
+    }
+}
+FabricContractAdapter.decoration();
+Adapter.setCurrent(FabricFlavour);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ContractAdapter.js","sourceRoot":"","sources":["../../../src/contracts/ContractAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAc,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAEL,UAAU,EACV,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,IAAI,GACL,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,qBAAqB,EAAE,6BAA0B;AAC1D,OAAO,EACL,QAAQ,EAER,MAAM,EACN,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,QAAQ,EACR,cAAc,EACd,QAAQ,EACR,QAAQ,EAER,QAAQ,EACR,kBAAkB,GACnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAEL,MAAM,IAAI,YAAY,EACtB,QAAQ,IAAI,cAAc,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAU,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EACL,cAAc,EACd,eAAe,EAEf,UAAU,EAEV,oBAAoB,EAEpB,gBAAgB,EAChB,KAAK,EACL,eAAe,EACf,OAAO,EAGP,iBAAiB,GAGlB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,wBAAwB,EAAE,sCAAmC;AAOtE,OAAO,EAAE,eAAe,EAAE,qCAAkC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,oCAAiC;AAClE,OAAO,EAAE,mBAAmB,EAAE,8BAAyB;AACvD,OAAO,EAAE,aAAa,EAAE,iCAA4B;AACpD,OAAO,EAAE,6BAA6B,EAAE,qDAAgD;AACxF,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,IAAI,GAAG,GAChB,gCAA6B;AAC9B,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,KAAK,UAAU,6BAA6B,CAMjD,OAAqC,EACrC,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAmB,CAAC;QAC7D,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,EAAmB,CAAC;QAC3C,6DAA6D;IAC/D,CAAC;IAAC,OAAO,CAAU,EAAE,CAAC;QACpB,MAAM,IAAI,gBAAgB,CACxB,gEAAgE,CACjE,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAOpC,OAAmB,EACnB,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7B,OAAO;IACT,CAAC;IAED,MAAM,kBAAkB,GAAG,UACzB,MAAS,EACT,WAAmB,EACnB,KAA+B;QAE/B,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE;YACzC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,KAAK;YACf,YAAY,EAAE,IAAI;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;IACL,CAAC,CAAC;IACF,IAAI,CAAC,IAAI,CAAC,IAAI;QAAE,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC9D,IAAI,QAAgC,CAAC;IACrC,IAAI,CAAC;QACH,QAAQ,GAAG,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAA2B,CAAC;IAC3E,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,MAAM,IAAI,aAAa,CACrB,kCAAkC,IAAI,CAAC,IAAI,KAAK,CAAC,EAAE,CACpD,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,OAAgC,CAAC,CAAC;IACnE,kBAAkB,CAAC,KAAK,EAAE,GAAa,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,OAAO,qBAAsB,SAAQ,cAK1C;IACoB,SAAS;QAC1B,MAAM,IAAI,gBAAgB,CAAC,6CAA6C,CAAC,CAAC;IAC5E,CAAC;IACD;;OAEG;aACY,gBAAW,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,AAA1B,CAA2B;aAE3B,eAAU,GAAG,IAAI,6BAA6B,EAAE,AAAtC,CAAuC;IAE3E;;;;;OAKG;IACI,MAAM,CAAC,GAAQ;QACpB,OAAO,OAAO,CAAC,GAAG,CAAC,qBAAqB,EAAE,EAAE,EAAE,GAAG,CAAmB,CAAC;IACvE,CAAC;IAQD;;;;;OAKG;IACM,UAAU;QASjB,OAAO,wBAAwB,CAAC;IAClC,CAAC;IAED;;;;;OAKG;IACH,YAAY,KAAW,EAAE,KAAc;QACrC,KAAK,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;QA/BrC;;;WAGG;QACM,YAAO,GAAG,qBAAqB,CAAC;IA4BzC,CAAC;IAEQ,GAAG,CAAC,MAAoB,EAAE,GAAG,IAAS;QAC7C,OAAO,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;;;OASG;IACM,KAAK,CAAC,MAAM,CACnB,SAAiB,EACjB,EAAmB,EACnB,KAA0B,EAC1B,GAAG,IAAW;QAEd,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAEpC,IAAI,CAAC;YACH,GAAG,CAAC,IAAI,CAAC,mBAAmB,SAAS,kBAAkB,EAAE,EAAE,CAAC,CAAC;YAC7D,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,CAAC;QAC1D,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,MAAM,IAAI,CAAC,UAAU,CAAC,CAAU,CAAC,CAAC;QACpC,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;OAOG;IACM,KAAK,CAAC,IAAI,CACjB,SAAiB,EACjB,EAAmB,EACnB,GAAG,IAAW;QAEd,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAElC,IAAI,KAA0B,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC;YAErE,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvB,GAAG,CAAC,KAAK,CAAC,0BAA0B,EAAE,OAAO,SAAS,QAAQ,CAAC,CAAC;gBAChE,MAAM,IAAI,aAAa,CACrB,0BAA0B,EAAE,OAAO,SAAS,QAAQ,CACrD,CAAC;YACJ,CAAC;iBAAM,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC9B,GAAG,CAAC,KAAK,CAAC,0BAA0B,EAAE,OAAO,SAAS,QAAQ,CAAC,CAAC;gBAChE,KAAK,GAAG,OAAO,CAAC,GAAG,EAAyB,CAAC;YAC/C,CAAC;iBAAM,CAAC;gBACN,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,MAAM,IAAI,CAAC,UAAU,CAAC,CAAU,CAAC,CAAC;QACpC,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;OASG;IACM,KAAK,CAAC,MAAM,CACnB,SAAiB,EACjB,EAAmB,EACnB,KAA0B,EAC1B,GAAG,IAAW;QAEd,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAEpC,IAAI,CAAC;YACH,GAAG,CAAC,IAAI,CAAC,qBAAqB,SAAS,kBAAkB,EAAE,EAAE,CAAC,CAAC;YAC/D,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,CAAC;QAC1D,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,MAAM,IAAI,CAAC,UAAU,CAAC,CAAU,CAAC,CAAC;QACpC,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,MAAM,CACV,SAAiB,EACjB,EAAmB,EACnB,GAAG,IAAW;QAEd,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC;QAC7B,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAEpC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEf,IAAI,KAA0B,CAAC;QAC/B,IAAI,CAAC;YACH,KAAK,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC;YAChD,GAAG,CAAC,OAAO,CAAC,0BAA0B,EAAE,SAAS,SAAS,QAAQ,CAAC,CAAC;YACpE,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC;QACnD,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,MAAM,IAAI,CAAC,UAAU,CAAC,CAAU,CAAC,CAAC;QACpC,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAES,KAAK,CAAC,WAAW,CACzB,IAAmB,EACnB,SAAiB,EACjB,EAAU;IACV,6DAA6D;IAC7D,GAAG,IAAW;QAEd,MAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACrE,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;IACtC,CAAC;IAES,KAAK,CAAC,QAAQ,CACtB,IAAmB,EACnB,EAAU,EACV,KAA0B;IAC1B,6DAA6D;IAC7D,GAAG,IAAW;QAEd,IAAI,IAAY,CAAC;QAEjB,IAAI,CAAC;YACH,IAAI,GAAG,MAAM,CAAC,IAAI,CAChB,qBAAqB,CAAC,UAAU,CAAC,SAAS,CAAC,KAAc,CAAC,CAC3D,CAAC;QACJ,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,MAAM,IAAI,kBAAkB,CAC1B,sCAAsC,EAAE,KAAK,CAAC,EAAE,CACjD,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,CAAC;QAEzC,OAAO,KAAK,CAAC;IACf,CAAC;IAES,KAAK,CAAC,SAAS,CACvB,IAAmB,EACnB,SAAiB,EACjB,EAAU;IACV,6DAA6D;IAC7D,GAAG,IAAW;QAEd,MAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACrE,MAAM,OAAO,GAAU,EAAE,CAAC;QAE1B,IAAI,GAAG,GAAiC,MAAM,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;QAEzE,IAAI,GAAG,CAAC,QAAQ,EAAE,KAAK,EAAE;YACvB,MAAM,IAAI,aAAa,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;QAE5D,IAAI,CAAC;YACH,GAAG,GAAG,qBAAqB,CAAC,UAAU,CAAC,WAAW,CAChD,GAAG,CAAC,QAAQ,EAAE;YACd,yBAAyB;aAC1B,CAAC;QACJ,CAAC;QAAC,OAAO,CAAU,EAAE,CAAC;YACpB,MAAM,IAAI,kBAAkB,CAAC,2BAA2B,CAAC,EAAE,CAAC,CAAC;QAC/D,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAElB,OAAO,OAAO,CAAC;IACjB,CAAC;IAES,KAAK,CAAC,WAAW,CACzB,IAAmB,EACnB,QAAa;IACb,6DAA6D;IAC7D,GAAG,IAAW;QAEd,OAAO,CAAC,MAAM,IAAI,CAAC,cAAc,CAC/B,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CACzB,CAAiC,CAAC;IACrC,CAAC;IAES,KAAK,CAAC,oBAAoB,CAClC,IAAmB,EACnB,QAAa,EACb,QAAgB,GAAG,EACnB,IAAa;IACb,6DAA6D;IAC7D,GAAG,IAAW;QAEd,OAAO,CAAC,MAAM,IAAI,CAAC,4BAA4B,CAC7C,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,EACxB,KAAK,EACL,IAAI,EAAE,QAAQ,EAAE,CACjB,CAAqD,CAAC;IACzD,CAAC;IAES,WAAW,CAAC,OAA8B;QAClD,MAAM,OAAO,GAAG,CAAC,KAA0B,EAAE,EAAE,CAC7C,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,KAA0B,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;YACtE,IAAI,OAAO,GAAG,KAAK,WAAW;gBAAE,KAAK,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;YACjD,OAAO,KAAK,CAAC;QACf,CAAC,EAAE,EAAE,CAAC,CAAC;QAET,IAAI,UAAU,GAAwB,OAAO,CAAC,GAAG,EAAyB,CAAC;QAE3E,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;YAC1B,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;QACpE,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACO,MAAM,CAAC,MAAkB;QACjC,OAAO,qBAAqB,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC1D,CAAC;IAED;;;;;;;;;OASG;IACgB,KAAK,CAAC,KAAK,CAC5B,SAAwB,EACxB,KAAqB,EACrB,KAAmC,EACnC,GAAQ,EACR,GAAG,IAAW;QAEd,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,EAAE;YACxE,IAAI,EAAE,GAAG,CAAC,IAAI;YACd,QAAQ,EAAE,GAAG,CAAC,cAAc;YAC5B,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;SACzB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACH,6DAA6D;IACnD,KAAK,CAAI,MAAsB;QACvC,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACO,KAAK,CAAC,cAAc,CAC5B,GAAW,EACX,QAAsC,EACtC,SAAS,GAAG,KAAK;QAEjB,MAAM,UAAU,GAAG,EAAE,CAAC;QACtB,IAAI,GAAG,GAAkC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;QAC/D,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;YACjB,IAAI,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC;gBAC5C,IAAI,OAAO,GAAQ,EAAE,CAAC;gBACtB,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;gBAC5C,IAAI,SAAS,CAAC,0BAA0B,EAAE,CAAC;oBACzC,OAAO,CAAC,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;oBAC9B,OAAO,CAAC,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC;oBACxC,IAAI,CAAC;wBACH,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;oBAC/D,CAAC;oBAAC,OAAO,GAAQ,EAAE,CAAC;wBAClB,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;wBACf,OAAO,CAAC,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;oBACnD,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC;wBACH,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC;oBACzD,CAAC;oBAAC,OAAO,GAAQ,EAAE,CAAC;wBAClB,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;wBACf,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;oBAC7C,CAAC;gBACH,CAAC;gBACD,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC3B,CAAC;YACD,GAAG,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;QAC9B,CAAC;QACD,GAAG,CAAC,KAAK,CAAC,0BAA0B,UAAU,CAAC,MAAM,UAAU,CAAC,CAAC;QACjE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,qDAAqD;QACvE,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,KAAK,CAAC,GAAG,CACP,QAAoB,EACpB,QAAiB,EACjB,GAAG,IAAW;QAEd,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACjC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC;QACjC,IAAI,QAAsC,CAAC;QAC3C,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;YAClB,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC;YACzB,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC;YACxB,GAAG,CAAC,KAAK,CACP,yCAAyC,KAAK,WAAW,IAAI,EAAE,CAChE,CAAC;YACF,MAAM,QAAQ,GACZ,CAAC,MAAM,IAAI,CAAC,oBAAoB,CAC9B,IAAI,EACJ,QAAQ,EACR,KAAK,IAAI,GAAG,EACX,IAAY,EAAE,QAAQ,EAAE,CAC1B,CAAqD,CAAC;YACzD,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC;QAC/B,CAAC;aAAM,CAAC;YACN,GAAG,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;YACjC,QAAQ,GAAG,CAAC,MAAM,IAAI,CAAC,WAAW,CAChC,IAAI,EACJ,QAAQ,CACT,CAAiC,CAAC;QACrC,CAAC;QACD,GAAG,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;QAE/B,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAM,CAAC;QAChE,GAAG,CAAC,KAAK,CACP,uBAAuB,EACvB,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CACjD,CAAC;QACF,OAAO,OAAO,CAAC;IACjB,CAAC;IAEQ,SAAS,CAChB,GAA2B;QAE3B,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,mBAAmB,CAAC,qBAAqB,CAAC,CAAC;QACvD,CAAC;QACD,OAAO,IAAI,eAAe,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IACxC,CAAC;IAEQ,KAAK,CAAC,QAAQ,CAAC,OAAwB;QAC9C,OAAO,IAAI,sBAAsB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACnD,CAAC;IAEQ,KAAK,CAAC,SAAS,CACtB,SAAiB,EACjB,EAAuB,EACvB,KAA4B,EAC5B,GAAG,IAAW;QAEd,IAAI,EAAE,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM;YAC5B,MAAM,IAAI,aAAa,CAAC,0CAA0C,CAAC,CAAC;QAEtE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAA0B,CAAC;QAClE,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACvC,GAAG,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,MAAM,YAAY,SAAS,QAAQ,CAAC,CAAC;QAC7D,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAExB,OAAO,OAAO,CAAC,GAAG,CAChB,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE;YACxB,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;QAC1D,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAEQ,KAAK,CAAC,SAAS,CACtB,SAAiB,EACjB,EAAuB,EACvB,KAA4B,EAC5B,GAAG,IAAW;QAEd,IAAI,EAAE,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM;YAC5B,MAAM,IAAI,aAAa,CAAC,0CAA0C,CAAC,CAAC;QAEtE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAA0B,CAAC;QAElE,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACvC,GAAG,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,MAAM,YAAY,SAAS,QAAQ,CAAC,CAAC;QAC7D,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAExB,OAAO,OAAO,CAAC,GAAG,CAChB,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE;YACxB,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC;QAC1D,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACM,OAAO,CACd,KAAQ,EACR,EAAW,EACX,GAAG,IAAW;QAMd,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC;QAC/B,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAErC,MAAM,KAAK,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACtC,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAC/C,CAAC,KAA0B,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;YACzC,IAAI,OAAO,GAAG,KAAK,WAAW;gBAAE,OAAO,KAAK,CAAC;YAC7C,MAAM,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACjD,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC;gBAC7B,MAAM,IAAI,aAAa,CAAC,iBAAiB,UAAU,cAAc,CAAC,CAAC;YACrE,KAAK,CAAC,UAAU,CAAC,GAAG,GAAG,CAAC;YACxB,OAAO,KAAK,CAAC;QACf,CAAC,EACD,EAAE,CACH,CAAC;QACF,IAAK,KAAa,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7C,GAAG,CAAC,KAAK,CACP,0CAA2C,KAAa,CAAC,eAAe,CAAC,QAAQ,CAAC,EAAE,CACrF,CAAC;YACF,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,eAAe,CAAC,QAAQ,EAAE;gBACtD,UAAU,EAAE,KAAK;gBACjB,QAAQ,EAAE,KAAK;gBACf,YAAY,EAAE,IAAI;gBAClB,KAAK,EAAG,KAAa,CAAC,eAAe,CAAC,QAAQ,CAAC;aAChD,CAAC,CAAC;QACL,CAAC;QAED,GAAG,CAAC,IAAI,CAAC,wBAAwB,SAAS,kBAAkB,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAEzE,OAAO;YACL,MAAM,EAAE,MAAM;YACd,EAAE,EAAE,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC3D,SAAS,EAAE,KAAK,CAAC,SAAS;SAC3B,CAAC;IACJ,CAAC;IAEQ,MAAM,CACb,GAAwB,EACxB,KAA8B,EAC9B,EAAW,EACX,EAAmB,EACnB,SAA+B;QAE/B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACtC,MAAM,EAAE,GAAwB,EAAE,CAAC;QACnC,EAAE,CAAC,EAAY,CAAC,GAAG,EAAE,CAAC;QACtB,MAAM,CAAC,GAAG,CACR,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC,CAC9D,CAAC;QACP,GAAG,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,WAAW,CAAC,IAAI,OAAO,EAAE,EAAE,CAAC,CAAC;QAC7D,MAAM,QAAQ,GAAG,GAAG,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,KAAQ,EAAE,GAAG,EAAE,EAAE;YACpD,KAA6B,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;YACzE,OAAO,KAAK,CAAC;QACf,CAAC,EAAE,CAAC,CAAC,CAAC;QAEN,IAAI,SAAS,EAAE,CAAC;YACd,GAAG,CAAC,OAAO,CACT,mCAAmC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CACvE,CAAC;YACF,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;gBAC/C,IAAI,GAAG,IAAI,MAAM,IAAK,MAAc,CAAC,GAAG,CAAC,KAAK,SAAS;oBACrD,MAAM,IAAI,aAAa,CACrB,sBAAsB,GAAG,4BAA4B,CAAC,CAAC,WAAW,CAAC,IAAI,wBAAwB,CAChG,CAAC;gBACJ,MAAM,CAAC,GAAc,CAAC,GAAG,GAAG,CAAC;YAC/B,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,QAAQ,EAAE,CAAC;YACb,GAAG,CAAC,KAAK,CACP,iBAAiB,IAAI,CAAC,OAAO,6BAA6B,CAAC,CAAC,WAAW,CAAC,IAAI,OAAO,EAAE,KAAK,QAAQ,EAAE,CACrG,CAAC;YACF,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,eAAe,CAAC,QAAQ,EAAE;gBACtD,UAAU,EAAE,KAAK;gBACjB,YAAY,EAAE,KAAK;gBACnB,QAAQ,EAAE,KAAK;gBACf,KAAK,EAAE,QAAQ;aAChB,CAAC,CAAC;QACL,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEQ,YAAY,CACnB,SAAiB,EACjB,EAAmB,EACnB,KAA0B,EAC1B,GAAG,IAAW;QAEd,MAAM,GAAG,GAA0B,IAAI,CAAC,GAAG,EAAE,CAAC;QAC9C,MAAM,MAAM,GAAwB,EAAE,CAAC;QACvC,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;QACtC,2DAA2D;QAC3D,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC7B,OAAO,CAAC,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IACtC,CAAC;IAEQ,YAAY,CACnB,SAAiB,EACjB,EAAmB,EACnB,KAA0B,EAC1B,GAAG,IAAW;QAEd,MAAM,GAAG,GAA0B,IAAI,CAAC,GAAG,EAAE,CAAC;QAC9C,MAAM,MAAM,GAAwB,EAAE,CAAC;QACvC,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;QACtC,2DAA2D;QAC3D,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC7B,OAAO,CAAC,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IACtC,CAAC;IAEkB,eAAe,CAChC,SAAiB,EACjB,GAAwB,EACxB,MAA6B,EAC7B,GAAG,IAAW;QAEd,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM;YAC9B,MAAM,IAAI,aAAa,CAAC,0CAA0C,CAAC,CAAC;QAEtE,MAAM,GAAG,GAA0B,IAAI,CAAC,GAAG,EAAE,CAAC;QAE9C,MAAM,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE;YACpC,MAAM,MAAM,GAAwB,EAAE,CAAC;YACvC,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;YACtC,2DAA2D;YAC3D,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YACrC,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;QACH,OAAO,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,EAAE,GAAU,CAAC,CAAC;IAC/C,CAAC;IAEkB,eAAe,CAChC,SAAiB,EACjB,GAAwB,EACxB,MAA6B,EAC7B,GAAG,IAAW;QAEd,IAAI,GAAG,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM;YAC9B,MAAM,IAAI,aAAa,CAAC,0CAA0C,CAAC,CAAC;QAEtE,MAAM,GAAG,GAA0B,IAAI,CAAC,GAAG,EAAE,CAAC;QAE9C,MAAM,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE;YACpC,MAAM,MAAM,GAAwB,EAAE,CAAC;YACvC,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;YACtC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YACrC,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;QACH,OAAO,CAAC,SAAS,EAAE,GAAG,EAAE,OAAO,EAAE,GAAU,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAU,UAAU;QACxB,KAAK,CAAC,UAAU,EAAE,CAAC;QACnB,MAAM,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QAChE,MAAM,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QAChE,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC;aAClC,GAAG,CAAC,YAAY,CAAC;aACjB,MAAM,CACL,QAAQ,CAAC,6BAA6B,CAAC,EACvC,YAAY,CAAC,YAAY,EAAE,EAAE,CAAC,CAC/B;aACA,KAAK,EAAE,CAAC;QAEX,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC;aAClC,GAAG,CAAC,YAAY,CAAC;aACjB,MAAM,CACL,cAAc,CAAC,6BAA6B,CAAC,EAC7C,YAAY,CAAC,YAAY,EAAE,EAAE,CAAC,CAC/B;aACA,KAAK,EAAE,CAAC;QAEX,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACxC,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC;aAClC,GAAG,CAAC,KAAK,CAAC;aACV,MAAM,CACL,KAAK,CAAC,CAAC,cAAc,CAAC,GAAG,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC,EAC/C,QAAQ,EAAE,EACV,QAAQ,EAAE;QACV,iDAAiD;QACjD,YAAY,CAAC,KAAK,EAAE,eAAe,CAAC,EACpC,QAAQ,CAAC,gBAAgB,EAAE,eAAe,CAAC,CAC5C;aACA,KAAK,EAAE,CAAC;QAEX,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QACtD,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC;aAClC,GAAG,CAAC,SAAS,CAAC;aACd,MAAM,CAAC,cAAc,EAAE,CAAC;aACxB,KAAK,EAAE,CAAC;QAEX,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;QACpD,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC;aAClC,GAAG,CAAC,QAAQ,CAAC;aACb,MAAM,CAAC,SAAS,KAAK,CAAC,GAAQ;YAC7B,2BAA2B;YAE3B,qBAAqB;YAErB,OAAO;YACP,yBAAyB;YACzB,4CAA4C;YAC5C,qDAAqD;YAErD,OAAO;YACP,2BAA2B;YAC3B,4DAA4D;YAC5D,iDAAiD;YACjD,gCAAgC;YAChC,8BAA8B;YAE9B,OAAO,YAAY,EAAE,CAAC,GAAG,CAAC,CAAC;QAC7B,CAAC,CAAC;aACD,KAAK,EAAE,CAAC;QAEX,MAAM,WAAW,GAAG,UAAU,CAAC,GAAG,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QAE/D,SAAS,WAAW,CAClB,KAA8C,EAC9C,OAAwB,EACxB,QAAiB,EACjB,cAAkC,EAClC,EAAW;YAEX,MAAM,IAAI,GAAsB;gBAC9B,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAE,KAAa;gBAC/C,OAAO,EAAE,OAAO;gBAChB,QAAQ,EAAE,QAAQ;aACnB,CAAC;YACF,IAAI,cAAc;gBAAE,IAAI,CAAC,SAAS,GAAG,cAAc,CAAC;YACpD,IAAI,EAAE;gBAAE,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;YACvB,OAAO,KAAK,CACV,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,EAC/B,IAAI,CAAC;gBACH,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAE,KAAa;gBACxC,MAAM,CAAC,IAAI;gBACX,MAAM,CAAC,IAAI;gBACX,MAAM,CAAC,IAAI;aACZ,CAAC,EACF,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAC,EAChC,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAC,EAChC,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAC,EAChC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,EACnB,YAAY,CAAC,WAAW,EAAE,IAAI,CAAC,CAChC,CAAC;QACJ,CAAC;QAED,UAAU,CAAC,WAAW,CAAC,aAAa,CAAC;aAClC,GAAG,CAAC,WAAW,CAAC;aAChB,MAAM,CAAC;YACN,SAAS,EAAE,WAAW;SACvB,CAAC;aACD,KAAK,EAAE,CAAC;QAEX,MAAM,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;QAEjE,SAAS,YAAY,CACnB,KAA8C,EAC9C,OAAwB,EACxB,QAAiB,EACjB,aAAkE,EAClE,EAAW;YAEX,MAAM,QAAQ,GAAsB;gBAClC,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAE,KAAa;gBAC/C,OAAO,EAAE,OAAO;gBAChB,QAAQ,EAAE,QAAQ;aACnB,CAAC;YACF,IAAI,aAAa;gBAAE,QAAQ,CAAC,SAAS,GAAG,aAAa,CAAC;YACtD,IAAI,EAAE;gBAAE,QAAQ,CAAC,IAAI,GAAG,EAAE,CAAC;YAC3B,OAAO,KAAK,CACV,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,EAC/B,IAAI,CAAC,CAAC,KAAuB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EACvD,QAAQ,CAAC,iBAAiB,EAAE,QAAQ,CAAC,EACrC,QAAQ,CAAC,iBAAiB,EAAE,QAAQ,CAAC,EACrC,QAAQ,CAAC,iBAAiB,EAAE,QAAQ,CAAC,EACrC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,EACvB,YAAY,CAAC,YAAY,EAAE,QAAQ,CAAC,CACrC,CAAC;QACJ,CAAC;QAED,UAAU,CAAC,GAAG,CAAC,YAAY,CAAC;aACzB,MAAM,CAAC;YACN,SAAS,EAAE,YAAY;SACxB,CAAC;aACD,KAAK,EAAE,CAAC;IACb,CAAC;;AAGH,qBAAqB,CAAC,UAAU,EAAE,CAAC;AACnC,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC","sourcesContent":["import { CouchDBAdapter, CouchDBKeys, MangoQuery } from \"@decaf-ts/for-couchdb\";\nimport {\n  Constructor,\n  Decoration,\n  list,\n  Model,\n  prop,\n  propMetadata,\n  required,\n  type,\n} from \"@decaf-ts/decorator-validation\";\nimport { FabricContractFlags } from \"./types\";\nimport { FabricContractContext } from \"./ContractContext\";\nimport {\n  afterAny,\n  Context,\n  DBKeys,\n  InternalError,\n  modelToTransient,\n  NotFoundError,\n  onCreate,\n  onCreateUpdate,\n  onDelete,\n  onUpdate,\n  OperationKeys,\n  readonly,\n  SerializationError,\n} from \"@decaf-ts/db-decorators\";\nimport {\n  Context as Ctx,\n  Object as FabricObject,\n  Property as FabricProperty,\n} from \"fabric-contract-api\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { ContractLogger } from \"./logging\";\nimport {\n  OrderDirection,\n  PersistenceKeys,\n  RelationsMetadata,\n  Repository,\n  Sequence,\n  sequenceNameForModel,\n  SequenceOptions,\n  UnsupportedError,\n  index,\n  NumericSequence,\n  Adapter,\n  CascadeMetadata,\n  JoinColumnOptions,\n  oneToManyOnUpdate,\n  JoinTableOptions,\n  JoinTableMultipleColumnsOptions,\n} from \"@decaf-ts/core\";\nimport { FabricContractRepository } from \"./FabricContractRepository\";\nimport {\n  ChaincodeStub,\n  ClientIdentity,\n  Iterators,\n  StateQueryResponse,\n} from \"fabric-shim-api\";\nimport { FabricStatement } from \"./FabricContractStatement\";\nimport { FabricContractSequence } from \"./FabricContractSequence\";\nimport { MissingContextError } from \"../shared/errors\";\nimport { FabricFlavour } from \"../shared/constants\";\nimport { SimpleDeterministicSerializer } from \"../shared/SimpleDeterministicSerializer\";\nimport {\n  oneToManyOnCreate,\n  oneToManyOnDelete,\n  oneToOneOnCreate,\n  oneToOneOnDelete,\n  oneToOneOnUpdate,\n  populate as pop,\n} from \"./FabricConstruction\";\nimport { apply } from \"@decaf-ts/reflection\";\n\n/**\n * @description Sets the creator or updater field in a model based on the user in the context\n * @summary Callback function used in decorators to automatically set the created_by or updated_by fields\n * with the username from the context when a document is created or updated\n * @template M - Type extending Model\n * @template R - Type extending NanoRepository<M>\n * @template V - Type extending RelationsMetadata\n * @param {R} this - The repository instance\n * @param {FabricContractContext} context - The operation context containing user information\n * @param {V} data - The relation metadata\n * @param {string} key - The property key to set with the username\n * @param {M} model - The model instance being created or updated\n * @return {Promise<void>} A promise that resolves when the operation is complete\n * @function createdByOnFabricCreateUpdate\n * @memberOf module:fabric.contracts\n * @mermaid\n * sequenceDiagram\n *   participant F as createdByOnNanoCreateUpdate\n *   participant C as Context\n *   participant M as Model\n *   F->>C: get(\"user\")\n *   C-->>F: user object\n *   F->>M: set key to user.name\n *   Note over F: If no user in context\n *   F-->>F: throw UnsupportedError\n */\nexport async function createdByOnFabricCreateUpdate<\n  M extends Model,\n  R extends FabricContractRepository<M>,\n  V extends RelationsMetadata,\n>(\n  this: R,\n  context: Context<FabricContractFlags>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  try {\n    const user = context.get(\"clientIdentity\") as ClientIdentity;\n    model[key] = user.getID() as M[typeof key];\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    throw new UnsupportedError(\n      \"No User found in context. Please provide a user in the context\"\n    );\n  }\n}\n\n/**\n * @description Primary key auto-assignment callback for Fabric models\n * @summary Generates and assigns a primary key value to the specified model property using a Fabric-backed sequence when the model is created. If the sequence name is not provided in options, it is derived from the model via sequenceNameForModel. The assigned key is defined as non-writable and enumerable.\n * @template M - Type extending Model for the target instance\n * @template R - Type extending FabricContractRepository for repository context\n * @template V - Type extending SequenceOptions to configure sequence behavior\n * @template F - Type extending FabricContractFlags for contextual flags\n * @param {R} this - The repository instance invoking the callback\n * @param {FabricContractContext} context - Fabric contract context containing invocation metadata\n * @param {V} data - Sequence options used to configure or locate the sequence\n * @param {string} key - The primary key property name to assign on the model\n * @param {M} model - The model instance to receive the generated primary key\n * @return {Promise<void>} Resolves when the key is assigned or when no action is required\n * @function pkFabricOnCreate\n * @memberOf module:for-fabric.contracts\n * @mermaid\n * sequenceDiagram\n *   participant R as Repository\n *   participant C as Context<F>\n *   participant S as FabricContractDBSequence\n *   participant M as Model\n *   R->>R: derive sequence name if missing\n *   R->>S: adapter.Sequence(options)\n *   S-->>R: sequence instance\n *   R->>S: next(context)\n *   S-->>R: next value\n *   R->>M: define non-writable primary key\n */\nexport async function pkFabricOnCreate<\n  M extends Model,\n  R extends FabricContractRepository<M>,\n  V extends SequenceOptions,\n  F extends FabricContractFlags,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!data.type || model[key]) {\n    return;\n  }\n\n  const setPrimaryKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n  if (!data.name) data.name = sequenceNameForModel(model, \"pk\");\n  let sequence: FabricContractSequence;\n  try {\n    sequence = (await this.adapter.Sequence(data)) as FabricContractSequence;\n  } catch (e: any) {\n    throw new InternalError(\n      `Failed to instantiate Sequence ${data.name}: ${e}`\n    );\n  }\n\n  const next = await sequence.next(context as FabricContractContext);\n  setPrimaryKeyValue(model, key as string, next);\n}\n\n/**\n * @description Adapter for Hyperledger Fabric chaincode state database operations\n * @summary Provides a CouchDB-like interface for interacting with the Fabric state database from within a chaincode contract\n * @template void - No configuration needed for contract adapter\n * @template FabricContractFlags - Flags specific to Fabric contract operations\n * @template FabricContractContext - Context type for Fabric contract operations\n * @class FabricContractAdapter\n * @example\n * ```typescript\n * // In a Fabric chaincode contract class\n * import { FabricContractAdapter } from '@decaf-ts/for-fabric';\n *\n * export class MyContract extends Contract {\n *   private adapter = new FabricContractAdapter();\n *\n *   @Transaction()\n *   async createAsset(ctx: Context, id: string, data: string): Promise<void> {\n *     const model = { id, data, timestamp: Date.now() };\n *     await this.adapter.create('assets', id, model, {}, { stub: ctx.stub });\n *   }\n * }\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Contract\n *   participant FabricContractAdapter\n *   participant Stub\n *   participant StateDB\n *\n *   Contract->>FabricContractAdapter: create(tableName, id, model, transient, ctx)\n *   FabricContractAdapter->>FabricContractAdapter: Serialize model to JSON\n *   FabricContractAdapter->>Stub: putState(id, serializedData)\n *   Stub->>StateDB: Write data\n *   StateDB-->>Stub: Success\n *   Stub-->>FabricContractAdapter: Success\n *   FabricContractAdapter-->>Contract: model\n */\nexport class FabricContractAdapter extends CouchDBAdapter<\n  any,\n  void,\n  FabricContractFlags,\n  FabricContractContext\n> {\n  protected override getClient(): void {\n    throw new UnsupportedError(\"Client is not supported in Fabric contracts\");\n  }\n  /**\n   * @description Text decoder for converting binary data to strings\n   */\n  private static textDecoder = new TextDecoder(\"utf8\");\n\n  protected static readonly serializer = new SimpleDeterministicSerializer();\n\n  /**\n   * @description Creates a logger for a specific chaincode context\n   * @summary Returns a ContractLogger instance configured for the current context\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @return {ContractLogger} The logger instance\n   */\n  public logFor(ctx: Ctx): ContractLogger {\n    return Logging.for(FabricContractAdapter, {}, ctx) as ContractLogger;\n  }\n\n  /**\n   * @description Context constructor for this adapter\n   * @summary Overrides the base Context constructor with FabricContractContext\n   */\n  override Context = FabricContractContext;\n\n  /**\n   * @description Gets the repository constructor for this adapter\n   * @summary Returns the FabricContractRepository constructor for creating repositories\n   * @template M - Type extending Model\n   * @return {Constructor<Repository<M, MangoQuery, FabricContractAdapter, FabricContractFlags, FabricContractContext>>} The repository constructor\n   */\n  override repository<M extends Model>(): Constructor<\n    Repository<\n      M,\n      MangoQuery,\n      Adapter<any, any, MangoQuery, FabricContractFlags, FabricContractContext>,\n      FabricContractFlags,\n      FabricContractContext\n    >\n  > {\n    return FabricContractRepository;\n  }\n\n  /**\n   * @description Creates a new FabricContractAdapter instance\n   * @summary Initializes an adapter for interacting with the Fabric state database\n   * @param {void} scope - Not used in this adapter\n   * @param {string} [alias] - Optional alias for the adapter instance\n   */\n  constructor(scope: void, alias?: string) {\n    super(scope, FabricFlavour, alias);\n  }\n\n  override for(config: Partial<any>, ...args: any): typeof this {\n    return super.for(config, ...args);\n  }\n\n  /**\n   * @description Creates a record in the state database\n   * @summary Serializes a model and stores it in the Fabric state database\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier\n   * @param {Record<string, any>} model - The record data\n   * @param {Record<string, any>} transient - Transient data (not used in this implementation)\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<Record<string, any>>} Promise resolving to the created record\n   */\n  override async create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>> {\n    const { stub, logger } = args.pop();\n    const log = logger.for(this.create);\n\n    try {\n      log.info(`adding entry to ${tableName} table with pk ${id}`);\n      model = await this.putState(stub, id.toString(), model);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n\n    return model;\n  }\n\n  /**\n   * @description Reads a record from the state database\n   * @summary Retrieves and deserializes a record from the Fabric state database\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<Record<string, any>>} Promise resolving to the retrieved record\n   */\n  override async read(\n    tableName: string,\n    id: string | number,\n    ...args: any[]\n  ): Promise<Record<string, any>> {\n    const { stub, logger } = args.pop();\n    const log = logger.for(this.read);\n\n    let model: Record<string, any>;\n    try {\n      const results = await this.readState(stub, tableName, id.toString());\n\n      if (results.length < 1) {\n        log.debug(`No record found for id ${id} in ${tableName} table`);\n        throw new NotFoundError(\n          `No record found for id ${id} in ${tableName} table`\n        );\n      } else if (results.length < 2) {\n        log.debug(`No record found for id ${id} in ${tableName} table`);\n        model = results.pop() as Record<string, any>;\n      } else {\n        model = this.mergeModels(results);\n      }\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n\n    return model;\n  }\n\n  /**\n   * @description Updates a record in the state database\n   * @summary Serializes a model and updates it in the Fabric state database\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier\n   * @param {Record<string, any>} model - The updated record data\n   * @param {Record<string, any>} transient - Transient data (not used in this implementation)\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<Record<string, any>>} Promise resolving to the updated record\n   */\n  override async update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): Promise<Record<string, any>> {\n    const { stub, logger } = args.pop();\n    const log = logger.for(this.update);\n\n    try {\n      log.info(`updating entry to ${tableName} table with pk ${id}`);\n      model = await this.putState(stub, id.toString(), model);\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n\n    return model;\n  }\n\n  /**\n   * @description Deletes a record from the state database\n   * @summary Retrieves a record and then removes it from the Fabric state database\n   * @param {string} tableName - The name of the table/collection\n   * @param {string | number} id - The record identifier to delete\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<Record<string, any>>} Promise resolving to the deleted record\n   */\n  async delete(\n    tableName: string,\n    id: string | number,\n    ...args: any[]\n  ): Promise<Record<string, any>> {\n    const ctx = args.pop();\n    const { stub, logger } = ctx;\n    const log = logger.for(this.delete);\n\n    args.push(ctx);\n\n    let model: Record<string, any>;\n    try {\n      model = await this.read(tableName, id, ...args);\n      log.verbose(`deleting entry with pk ${id} from ${tableName} table`);\n      this.deleteState(stub, tableName, id.toString());\n    } catch (e: unknown) {\n      throw this.parseError(e as Error);\n    }\n\n    return model;\n  }\n\n  protected async deleteState(\n    stub: ChaincodeStub,\n    tableName: string,\n    id: string,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ) {\n    const composedKey = stub.createCompositeKey(tableName, [String(id)]);\n    await stub.deleteState(composedKey);\n  }\n\n  protected async putState(\n    stub: ChaincodeStub,\n    id: string,\n    model: Record<string, any>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ) {\n    let data: Buffer;\n\n    try {\n      data = Buffer.from(\n        FabricContractAdapter.serializer.serialize(model as Model)\n      );\n    } catch (e: unknown) {\n      throw new SerializationError(\n        `Failed to serialize record with id ${id}: ${e}`\n      );\n    }\n    await stub.putState(id.toString(), data);\n\n    return model;\n  }\n\n  protected async readState(\n    stub: ChaincodeStub,\n    tableName: string,\n    id: string,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ) {\n    const composedKey = stub.createCompositeKey(tableName, [String(id)]);\n    const results: any[] = [];\n\n    let res: Buffer | Record<string, any> = await stub.getState(composedKey);\n\n    if (res.toString() === \"\")\n      throw new NotFoundError(`Record with id ${id} not found`);\n\n    try {\n      res = FabricContractAdapter.serializer.deserialize(\n        res.toString()\n        // model.constructor.name\n      );\n    } catch (e: unknown) {\n      throw new SerializationError(`Failed to parse record: ${e}`);\n    }\n\n    results.push(res);\n\n    return results;\n  }\n\n  protected async queryResult(\n    stub: ChaincodeStub,\n    rawInput: any,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<Iterators.StateQueryIterator> {\n    return (await stub.getQueryResult(\n      JSON.stringify(rawInput)\n    )) as Iterators.StateQueryIterator;\n  }\n\n  protected async queryResultPaginated(\n    stub: ChaincodeStub,\n    rawInput: any,\n    limit: number = 250,\n    skip?: number,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<StateQueryResponse<Iterators.StateQueryIterator>> {\n    return (await stub.getQueryResultWithPagination(\n      JSON.stringify(rawInput),\n      limit,\n      skip?.toString()\n    )) as StateQueryResponse<Iterators.StateQueryIterator>;\n  }\n\n  protected mergeModels(results: Record<string, any>[]): Record<string, any> {\n    const extract = (model: Record<string, any>) =>\n      Object.entries(model).reduce((accum: Record<string, any>, [key, val]) => {\n        if (typeof val !== \"undefined\") accum[key] = val;\n        return accum;\n      }, {});\n\n    let finalModel: Record<string, any> = results.pop() as Record<string, any>;\n\n    for (const res of results) {\n      finalModel = Object.assign({}, extract(finalModel), extract(res));\n    }\n\n    return finalModel;\n  }\n\n  /**\n   * @description Decodes binary data to string\n   * @summary Converts a Uint8Array to a string using UTF-8 encoding\n   * @param {Uint8Array} buffer - The binary data to decode\n   * @return {string} The decoded string\n   */\n  protected decode(buffer: Uint8Array) {\n    return FabricContractAdapter.textDecoder.decode(buffer);\n  }\n\n  /**\n   * @description Creates operation flags for Fabric contract operations\n   * @summary Merges default flags with Fabric-specific context information\n   * @template M - Type extending Model\n   * @param {OperationKeys} operation - The operation being performed\n   * @param {Constructor<M>} model - The model constructor\n   * @param {Partial<FabricContractFlags>} flags - Partial flags to merge with defaults\n   * @param {Ctx} ctx - The Fabric chaincode context\n   * @return {FabricContractFlags} The merged flags\n   */\n  protected override async flags<M extends Model>(\n    operation: OperationKeys,\n    model: Constructor<M>,\n    flags: Partial<FabricContractFlags>,\n    ctx: Ctx,\n    ...args: any[]\n  ): Promise<FabricContractFlags> {\n    return Object.assign(await super.flags(operation, model, flags, ...args), {\n      stub: ctx.stub,\n      identity: ctx.clientIdentity,\n      logger: this.logFor(ctx),\n    });\n  }\n\n  /**\n   * @description Creates an index for a model\n   * @summary This method is not implemented for Fabric contracts and returns a resolved promise\n   * @template M - Type extending Model\n   * @param {Constructor<M>} models - The model constructor\n   * @return {Promise<void>} Promise that resolves immediately\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected index<M>(models: Constructor<M>): Promise<void> {\n    return Promise.resolve(undefined);\n  }\n\n  /**\n   * @description Processes results from a state query iterator\n   * @summary Iterates through query results and converts them to a structured format\n   * @param {Logger} log - Logger instance for debugging\n   * @param {Iterators.StateQueryIterator} iterator - The state query iterator\n   * @param {boolean} [isHistory=false] - Whether this is a history query\n   * @return {Promise<any[]>} Promise resolving to an array of processed results\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant ResultIterator\n   *   participant Iterator\n   *\n   *   Caller->>ResultIterator: resultIterator(log, iterator, isHistory)\n   *   loop Until done\n   *     ResultIterator->>Iterator: next()\n   *     Iterator-->>ResultIterator: { value, done }\n   *     alt Has value\n   *       ResultIterator->>ResultIterator: Process value based on isHistory\n   *       ResultIterator->>ResultIterator: Add to results array\n   *     end\n   *   end\n   *   ResultIterator->>Iterator: close()\n   *   ResultIterator-->>Caller: allResults\n   */\n  protected async resultIterator(\n    log: Logger,\n    iterator: Iterators.StateQueryIterator,\n    isHistory = false\n  ) {\n    const allResults = [];\n    let res: { value: any; done: boolean } = await iterator.next();\n    while (!res.done) {\n      if (res.value && res.value.value.toString()) {\n        let jsonRes: any = {};\n        log.debug(res.value.value.toString(\"utf8\"));\n        if (isHistory /* && isHistory === true*/) {\n          jsonRes.TxId = res.value.txId;\n          jsonRes.Timestamp = res.value.timestamp;\n          try {\n            jsonRes.Value = JSON.parse(res.value.value.toString(\"utf8\"));\n          } catch (err: any) {\n            log.error(err);\n            jsonRes.Value = res.value.value.toString(\"utf8\");\n          }\n        } else {\n          try {\n            jsonRes = JSON.parse(res.value.value.toString(\"utf8\"));\n          } catch (err: any) {\n            log.error(err);\n            jsonRes = res.value.value.toString(\"utf8\");\n          }\n        }\n        allResults.push(jsonRes);\n      }\n      res = await iterator.next();\n    }\n    log.debug(`Closing iterator after ${allResults.length} results`);\n    iterator.close(); // purposely not await. let iterator close on its own\n    return allResults;\n  }\n\n  /**\n   * @description Executes a raw query against the state database\n   * @summary Performs a rich query using CouchDB syntax against the Fabric state database\n   * @template R - The return type\n   * @param {MangoQuery} rawInput - The Mango Query to execute\n   * @param {boolean} docsOnly - Whether to return only documents (not used in this implementation)\n   * @param {...any[]} args - Additional arguments, including the chaincode stub and logger\n   * @return {Promise<R>} Promise resolving to the query results\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant FabricContractAdapter\n   *   participant Stub\n   *   participant StateDB\n   *\n   *   Caller->>FabricContractAdapter: raw(rawInput, docsOnly, ctx)\n   *   FabricContractAdapter->>FabricContractAdapter: Extract limit and skip\n   *   alt With pagination\n   *     FabricContractAdapter->>Stub: getQueryResultWithPagination(query, limit, skip)\n   *   else Without pagination\n   *     FabricContractAdapter->>Stub: getQueryResult(query)\n   *   end\n   *   Stub->>StateDB: Execute query\n   *   StateDB-->>Stub: Iterator\n   *   Stub-->>FabricContractAdapter: Iterator\n   *   FabricContractAdapter->>FabricContractAdapter: resultIterator(log, iterator)\n   *   FabricContractAdapter-->>Caller: results\n   */\n  async raw<R>(\n    rawInput: MangoQuery,\n    docsOnly: boolean,\n    ...args: any[]\n  ): Promise<R> {\n    const { stub, logger } = args.pop();\n    const log = logger.for(this.raw);\n    const { skip, limit } = rawInput;\n    let iterator: Iterators.StateQueryIterator;\n    if (limit || skip) {\n      delete rawInput[\"limit\"];\n      delete rawInput[\"skip\"];\n      log.debug(\n        `Retrieving paginated iterator: limit: ${limit}/ skip: ${skip}`\n      );\n      const response: StateQueryResponse<Iterators.StateQueryIterator> =\n        (await this.queryResultPaginated(\n          stub,\n          rawInput,\n          limit || 250,\n          (skip as any)?.toString()\n        )) as StateQueryResponse<Iterators.StateQueryIterator>;\n      iterator = response.iterator;\n    } else {\n      log.debug(\"Retrieving iterator\");\n      iterator = (await this.queryResult(\n        stub,\n        rawInput\n      )) as Iterators.StateQueryIterator;\n    }\n    log.debug(\"Iterator acquired\");\n\n    const results = (await this.resultIterator(log, iterator)) as R;\n    log.debug(\n      `returning {0} results`,\n      `${Array.isArray(results) ? results.length : 1}`\n    );\n    return results;\n  }\n\n  override Statement<M extends Model>(\n    ctx?: FabricContractContext\n  ): FabricStatement<M, any> {\n    if (!ctx) {\n      throw new MissingContextError(\"Context is required\");\n    }\n    return new FabricStatement(this, ctx);\n  }\n\n  override async Sequence(options: SequenceOptions): Promise<Sequence> {\n    return new FabricContractSequence(options, this);\n  }\n\n  override async createAll(\n    tableName: string,\n    id: (string | number)[],\n    model: Record<string, any>[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    if (id.length !== model.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const { logger } = args[args.length - 1] as FabricContractContext;\n    const log = logger.for(this.createAll);\n    log.info(`Creating ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\n\n    return Promise.all(\n      id.map(async (i, index) => {\n        return this.create(tableName, i, model[index], ...args);\n      })\n    );\n  }\n\n  override async updateAll(\n    tableName: string,\n    id: string[] | number[],\n    model: Record<string, any>[],\n    ...args: any[]\n  ): Promise<Record<string, any>[]> {\n    if (id.length !== model.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const { logger } = args[args.length - 1] as FabricContractContext;\n\n    const log = logger.for(this.createAll);\n    log.info(`Updating ${id.length} entries ${tableName} table`);\n    log.debug(`pks: ${id}`);\n\n    return Promise.all(\n      id.map(async (i, index) => {\n        return this.update(tableName, i, model[index], ...args);\n      })\n    );\n  }\n\n  /**\n   *\n   * @param model\n   * @param {string} pk\n   * @param args\n   */\n  override prepare<M extends Model>(\n    model: M,\n    pk: keyof M,\n    ...args: any[]\n  ): {\n    record: Record<string, any>;\n    id: string;\n    transient?: Record<string, any>;\n  } {\n    const { stub, logger } = args.pop();\n    const tableName = args.shift();\n    const log = logger.for(this.prepare);\n\n    const split = modelToTransient(model);\n    const result = Object.entries(split.model).reduce(\n      (accum: Record<string, any>, [key, val]) => {\n        if (typeof val === \"undefined\") return accum;\n        const mappedProp = Repository.column(model, key);\n        if (this.isReserved(mappedProp))\n          throw new InternalError(`Property name ${mappedProp} is reserved`);\n        accum[mappedProp] = val;\n        return accum;\n      },\n      {}\n    );\n    if ((model as any)[PersistenceKeys.METADATA]) {\n      log.silly(\n        `Passing along persistence metadata for ${(model as any)[PersistenceKeys.METADATA]}`\n      );\n      Object.defineProperty(result, PersistenceKeys.METADATA, {\n        enumerable: false,\n        writable: false,\n        configurable: true,\n        value: (model as any)[PersistenceKeys.METADATA],\n      });\n    }\n\n    log.info(`Preparing record for ${tableName} table with pk ${model[pk]}`);\n\n    return {\n      record: result,\n      id: stub.createCompositeKey(tableName, [String(model[pk])]),\n      transient: split.transient,\n    };\n  }\n\n  override revert<M extends Model>(\n    obj: Record<string, any>,\n    clazz: string | Constructor<M>,\n    pk: keyof M,\n    id: string | number,\n    transient?: Record<string, any>\n  ): M {\n    const log = this.log.for(this.revert);\n    const ob: Record<string, any> = {};\n    ob[pk as string] = id;\n    const m = (\n      typeof clazz === \"string\" ? Model.build(ob, clazz) : new clazz(ob)\n    ) as M;\n    log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);\n    const metadata = obj[PersistenceKeys.METADATA];\n    const result = Object.keys(m).reduce((accum: M, key) => {\n      (accum as Record<string, any>)[key] = obj[Repository.column(accum, key)];\n      return accum;\n    }, m);\n\n    if (transient) {\n      log.verbose(\n        `re-adding transient properties: ${Object.keys(transient).join(\", \")}`\n      );\n      Object.entries(transient).forEach(([key, val]) => {\n        if (key in result && (result as any)[key] !== undefined)\n          throw new InternalError(\n            `Transient property ${key} already exists on model ${m.constructor.name}. should be impossible`\n          );\n        result[key as keyof M] = val;\n      });\n    }\n\n    if (metadata) {\n      log.silly(\n        `Passing along ${this.flavour} persistence metadata for ${m.constructor.name} id ${id}: ${metadata}`\n      );\n      Object.defineProperty(result, PersistenceKeys.METADATA, {\n        enumerable: false,\n        configurable: false,\n        writable: false,\n        value: metadata,\n      });\n    }\n\n    return result;\n  }\n\n  override createPrefix(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ) {\n    const ctx: FabricContractContext = args.pop();\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    // record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    Object.assign(record, model);\n    return [tableName, id, record, ctx];\n  }\n\n  override updatePrefix(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>,\n    ...args: any[]\n  ): (string | number | Record<string, any>)[] {\n    const ctx: FabricContractContext = args.pop();\n    const record: Record<string, any> = {};\n    record[CouchDBKeys.TABLE] = tableName;\n    // record[CouchDBKeys.ID] = this.generateId(tableName, id);\n    Object.assign(record, model);\n    return [tableName, id, record, ctx];\n  }\n\n  protected override createAllPrefix(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[],\n    ...args: any[]\n  ): (string | string[] | number[] | Record<string, any>[])[] {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const ctx: FabricContractContext = args.pop();\n\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      // record[CouchDBKeys.ID] = this.generateId(tableName, id);\n      Object.assign(record, models[count]);\n      return record;\n    });\n    return [tableName, ids, records, ctx as any];\n  }\n\n  protected override updateAllPrefix(\n    tableName: string,\n    ids: string[] | number[],\n    models: Record<string, any>[],\n    ...args: any[]\n  ) {\n    if (ids.length !== models.length)\n      throw new InternalError(\"Ids and models must have the same length\");\n\n    const ctx: FabricContractContext = args.pop();\n\n    const records = ids.map((id, count) => {\n      const record: Record<string, any> = {};\n      record[CouchDBKeys.TABLE] = tableName;\n      Object.assign(record, models[count]);\n      return record;\n    });\n    return [tableName, ids, records, ctx as any];\n  }\n\n  /**\n   * @description Static method for decoration overrides\n   * @summary Overrides/extends decaf decoration with Fabric-specific functionality\n   * @static\n   * @override\n   * @return {void}\n   */\n  static override decoration(): void {\n    super.decoration();\n    const createdByKey = Repository.key(PersistenceKeys.CREATED_BY);\n    const updatedByKey = Repository.key(PersistenceKeys.UPDATED_BY);\n    Decoration.flavouredAs(FabricFlavour)\n      .for(createdByKey)\n      .define(\n        onCreate(createdByOnFabricCreateUpdate),\n        propMetadata(createdByKey, {})\n      )\n      .apply();\n\n    Decoration.flavouredAs(FabricFlavour)\n      .for(updatedByKey)\n      .define(\n        onCreateUpdate(createdByOnFabricCreateUpdate),\n        propMetadata(updatedByKey, {})\n      )\n      .apply();\n\n    const pkKey = Repository.key(DBKeys.ID);\n    Decoration.flavouredAs(FabricFlavour)\n      .for(pkKey)\n      .define(\n        index([OrderDirection.ASC, OrderDirection.DSC]),\n        required(),\n        readonly(),\n        // type([String.name, Number.name, BigInt.name]),\n        propMetadata(pkKey, NumericSequence),\n        onCreate(pkFabricOnCreate, NumericSequence)\n      )\n      .apply();\n\n    const columnKey = Adapter.key(PersistenceKeys.COLUMN);\n    Decoration.flavouredAs(FabricFlavour)\n      .for(columnKey)\n      .extend(FabricProperty())\n      .apply();\n\n    const tableKey = Adapter.key(PersistenceKeys.TABLE);\n    Decoration.flavouredAs(FabricFlavour)\n      .for(tableKey)\n      .extend(function table(obj: any) {\n        // const chain: any[] = [];\n\n        // let current = obj;\n\n        // do {\n        //   chain.push(current);\n        //   console.log(`Found class: ${current}`);\n        // } while (current && current !== Object.prototype);\n\n        // do {\n        //   current = chain.pop();\n        //   console.log(`Applying @Object() to class: ${current}`);\n        //   //TODO: THIS IS NOT WORKING AND THROWS ERROR\n        //   // FabricObject()(current);\n        // } while (chain.length > 1);\n\n        return FabricObject()(obj);\n      })\n      .apply();\n\n    const oneToOnekey = Repository.key(PersistenceKeys.ONE_TO_ONE);\n\n    function oneToOneDec<M extends Model>(\n      clazz: Constructor<M> | (() => Constructor<M>),\n      cascade: CascadeMetadata,\n      populate: boolean,\n      joinColumnOpts?: JoinColumnOptions,\n      fk?: string\n    ) {\n      const meta: RelationsMetadata = {\n        class: clazz.name ? clazz.name : (clazz as any),\n        cascade: cascade,\n        populate: populate,\n      };\n      if (joinColumnOpts) meta.joinTable = joinColumnOpts;\n      if (fk) meta.name = fk;\n      return apply(\n        prop(PersistenceKeys.RELATIONS),\n        type([\n          clazz.name ? clazz.name : (clazz as any),\n          String.name,\n          Number.name,\n          BigInt.name,\n        ]),\n        onCreate(oneToOneOnCreate, meta),\n        onUpdate(oneToOneOnUpdate, meta),\n        onDelete(oneToOneOnDelete, meta),\n        afterAny(pop, meta),\n        propMetadata(oneToOnekey, meta)\n      );\n    }\n\n    Decoration.flavouredAs(FabricFlavour)\n      .for(oneToOnekey)\n      .define({\n        decorator: oneToOneDec,\n      })\n      .apply();\n\n    const oneToManyKey = Repository.key(PersistenceKeys.ONE_TO_MANY);\n\n    function oneToManyDec<M extends Model>(\n      clazz: Constructor<M> | (() => Constructor<M>),\n      cascade: CascadeMetadata,\n      populate: boolean,\n      joinTableOpts?: JoinTableOptions | JoinTableMultipleColumnsOptions,\n      fk?: string\n    ) {\n      const metadata: RelationsMetadata = {\n        class: clazz.name ? clazz.name : (clazz as any),\n        cascade: cascade,\n        populate: populate,\n      };\n      if (joinTableOpts) metadata.joinTable = joinTableOpts;\n      if (fk) metadata.name = fk;\n      return apply(\n        prop(PersistenceKeys.RELATIONS),\n        list([clazz as Constructor<M>, String, Number, BigInt]),\n        onCreate(oneToManyOnCreate, metadata),\n        onUpdate(oneToManyOnUpdate, metadata),\n        onDelete(oneToManyOnDelete, metadata),\n        afterAny(pop, metadata),\n        propMetadata(oneToManyKey, metadata)\n      );\n    }\n\n    Decoration.for(oneToManyKey)\n      .define({\n        decorator: oneToManyDec,\n      })\n      .apply();\n  }\n}\n\nFabricContractAdapter.decoration();\nAdapter.setCurrent(FabricFlavour);\n"]}