@decaf-ts/for-fabric 0.0.2

package/lib/contracts/logging.cjs

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractLogger = void 0;
+const logging_1 = require("@decaf-ts/logging");
+/**
+ * @description Logger implementation for Fabric chaincode contracts
+ * @summary Adapts the standard logging interface to work with Fabric's chaincode context
+ *
+ * @param {string} context - The logging context name
+ * @param {Partial<LoggingConfig> | undefined} conf - Optional logging configuration
+ * @param {Ctx} ctx - The Fabric chaincode context
+ *
+ * @class ContractLogger
+ * @extends {MiniLogger}
+ * @example
+ * ```typescript
+ * // In a Fabric chaincode contract
+ * import { ContractLogger } from '@decaf-ts/for-fabric';
+ *
+ * export class MyContract extends Contract {
+ *   @Transaction()
+ *   async myFunction(ctx: Context): Promise<void> {
+ *     const logger = new ContractLogger('MyContract', { level: 'info' }, ctx);
+ *
+ *     logger.info('Processing transaction');
+ *     logger.debug('Transaction details:', { ... });
+ *
+ *     // Do something
+ *
+ *     logger.info('Transaction complete');
+ *   }
+ * }
+ * ```
+ */
+class ContractLogger extends logging_1.MiniLogger {
+    constructor(context, conf, ctx) {
+        super(context, conf);
+        if (!ctx) {
+            this.logger = new logging_1.MiniLogger(context, conf);
+        }
+        else {
+            this.logger = ctx.logger;
+        }
+    }
+    /**
+     * @description Logs a message at the specified level
+     * @summary Overrides the base log method to use the Fabric context's logger
+     * @param {LogLevel} level - The log level
+     * @param {StringLike | Error} msg - The message to log
+     * @param {Error} [stack] - Optional stack trace for errors
+     * @return {void}
+     */
+    log(level, msg, stack) {
+        if (logging_1.NumericLogLevels[this.config("level")] <
+            logging_1.NumericLogLevels[level])
+            return;
+        let method;
+        switch (level) {
+            case logging_1.LogLevel.info:
+                method = this.logger.info;
+                break;
+            case logging_1.LogLevel.verbose:
+                method = this.logger.verbose;
+                break;
+            case logging_1.LogLevel.debug:
+                method = this.logger.debug;
+                break;
+            case logging_1.LogLevel.error:
+                method = this.logger.error;
+                break;
+            case logging_1.LogLevel.silly:
+                method = this.logger.silly;
+                break;
+            default:
+                throw new Error("Invalid log level");
+        }
+        method.call(this.logger, this.createLog(level, msg, stack));
+    }
+}
+exports.ContractLogger = ContractLogger;
+/**
+ * @description Factory function for creating ContractLogger instances
+ * @summary Creates a new ContractLogger with the given context, config, and Fabric context
+ * @param {string} object - The logging context name
+ * @param {Partial<LoggingConfig> | undefined} config - Optional logging configuration
+ * @param {Ctx} ctx - The Fabric chaincode context
+ * @return {ContractLogger} A new ContractLogger instance
+ * @function factory
+ * @memberOf module:fabric.contracts
+ */
+const factory = (object, config, ctx) => {
+    return new ContractLogger(object, config || {}, ctx);
+};
+// Set the factory as the default logger factory
+logging_1.Logging.setFactory(factory);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/contracts/logging.d.ts

@@ -0,0 +1,49 @@
+import { Logger, LogLevel, MiniLogger, StringLike } from "@decaf-ts/logging";
+import { LoggingConfig } from "@decaf-ts/logging";
+import { FabricContractContext } from "./ContractContext";
+/**
+ * @description Logger implementation for Fabric chaincode contracts
+ * @summary Adapts the standard logging interface to work with Fabric's chaincode context
+ *
+ * @param {string} context - The logging context name
+ * @param {Partial<LoggingConfig> | undefined} conf - Optional logging configuration
+ * @param {Ctx} ctx - The Fabric chaincode context
+ *
+ * @class ContractLogger
+ * @extends {MiniLogger}
+ * @example
+ * ```typescript
+ * // In a Fabric chaincode contract
+ * import { ContractLogger } from '@decaf-ts/for-fabric';
+ *
+ * export class MyContract extends Contract {
+ *   @Transaction()
+ *   async myFunction(ctx: Context): Promise<void> {
+ *     const logger = new ContractLogger('MyContract', { level: 'info' }, ctx);
+ *
+ *     logger.info('Processing transaction');
+ *     logger.debug('Transaction details:', { ... });
+ *
+ *     // Do something
+ *
+ *     logger.info('Transaction complete');
+ *   }
+ * }
+ * ```
+ */
+export declare class ContractLogger extends MiniLogger {
+    /**
+     * @description The underlying Fabric logger instance
+     */
+    protected logger: Logger;
+    constructor(context: string, conf: Partial<LoggingConfig> | undefined, ctx?: FabricContractContext);
+    /**
+     * @description Logs a message at the specified level
+     * @summary Overrides the base log method to use the Fabric context's logger
+     * @param {LogLevel} level - The log level
+     * @param {StringLike | Error} msg - The message to log
+     * @param {Error} [stack] - Optional stack trace for errors
+     * @return {void}
+     */
+    protected log(level: LogLevel, msg: StringLike | Error, stack?: Error): void;
+}

package/lib/contracts/private-data.cjs

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MISSING_PRIVATE_DATA_ERROR_MESSAGE = exports.MISSING_PRIVATE_DATA_REGEX = void 0;
+exports.processModel = processModel;
+exports.hasPrivateData = hasPrivateData;
+exports.getClassPrivateDataMetadata = getClassPrivateDataMetadata;
+exports.isModelPrivate = isModelPrivate;
+exports.modelToPrivate = modelToPrivate;
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const core_1 = require("@decaf-ts/core");
+const decorators_1 = require("./../shared/decorators.cjs");
+const constants_1 = require("./../shared/constants.cjs");
+exports.MISSING_PRIVATE_DATA_REGEX = /private\s+data\s+matching\s+public\s+hash\s+version\s+is\s+not\s+available/i;
+exports.MISSING_PRIVATE_DATA_ERROR_MESSAGE = "private data matching public hash version is not available ...";
+function processModel(adapter, model) {
+    const transient = (0, db_decorators_1.modelToTransient)(model);
+    const privateData = modelToPrivate(model);
+    const transformModel = (model) => {
+        return Object.entries(model).reduce((accum, [key, val]) => {
+            if (typeof val === "undefined")
+                return accum;
+            const mappedProp = core_1.Repository.column(model, key);
+            if (adapter.isReserved(mappedProp))
+                throw new db_decorators_1.InternalError(`Property name ${mappedProp} is reserved`);
+            accum[mappedProp] = val;
+            return accum;
+        }, {});
+    };
+    if (privateData.private) {
+        const collections = Object.keys(privateData.private);
+        for (const collection of collections) {
+            privateData.private[collection] = transformModel(privateData.private[collection]);
+        }
+    }
+    return {
+        model: transient.model,
+        transient: transient.transient,
+        privateData: privateData.private,
+        result: transformModel(transient.model),
+    };
+}
+function hasPrivateData(model) {
+    const metadata = getClassPrivateDataMetadata(model);
+    if (!metadata)
+        return false;
+    return true;
+}
+function getClassPrivateDataMetadata(model) {
+    let metadata = Reflect.getMetadata((0, decorators_1.getFabricModelKey)(constants_1.FabricModelKeys.PRIVATE), model);
+    metadata =
+        metadata ||
+            Reflect.getMetadata((0, decorators_1.getFabricModelKey)(constants_1.FabricModelKeys.PRIVATE), model.constructor);
+    return metadata;
+}
+function isModelPrivate(model) {
+    const metadata = getClassPrivateDataMetadata(model);
+    if (!metadata || metadata.isPrivate === undefined)
+        return false;
+    return metadata.isPrivate;
+}
+function modelToPrivate(model) {
+    if (!hasPrivateData(model))
+        return { model: model };
+    const decs = (0, db_decorators_1.getAllPropertyDecoratorsRecursive)(model, undefined, (0, decorators_1.getFabricModelKey)(constants_1.FabricModelKeys.PRIVATE));
+    const isPrivate = isModelPrivate(model);
+    const modelCollections = getClassPrivateDataMetadata(model);
+    let result = {
+        model: model,
+        private: undefined,
+    };
+    if (isPrivate) {
+        result = Object.keys(model).reduce((accum, k) => {
+            const collections = modelCollections.collections;
+            accum.private = accum.private || {};
+            for (const collection of collections) {
+                try {
+                    accum.private[collection] = accum.private[collection] || {};
+                    accum.private[collection][k] = model[k];
+                }
+                catch (e) {
+                    throw new db_decorators_1.SerializationError(`Failed to serialize private property ${k}: ${e}`);
+                }
+            }
+            return accum;
+        }, { model: {} });
+    }
+    else {
+        result = Object.entries(decs).reduce((accum, [k, val]) => {
+            const privateData = val.find((el) => el.key === "");
+            if (privateData) {
+                const collections = privateData.props.collections;
+                accum.private = accum.private || {};
+                for (const collection of collections) {
+                    try {
+                        accum.private[collection] = accum.private[collection] || {};
+                        accum.private[collection][k] = model[k];
+                    }
+                    catch (e) {
+                        throw new db_decorators_1.SerializationError(`Failed to serialize private property ${k}: ${e}`);
+                    }
+                }
+            }
+            else {
+                accum.model = accum.model || {};
+                accum.model[k] = model[k];
+            }
+            return accum;
+        }, {});
+    }
+    result.model = result.model || {};
+    result.model = decorator_validation_1.Model.build(result.model, model.constructor.name);
+    if (result.private) {
+        const collections = Object.keys(result.private);
+        for (const collection of collections) {
+            result.private[collection] = decorator_validation_1.Model.build(result.private[collection], model.constructor.name);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"private-data.js","sourceRoot":"","sources":["../../src/contracts/private-data.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  getAllPropertyDecoratorsRecursive,\n  InternalError,\n  modelToTransient,\n  SerializationError,\n} from \"@decaf-ts/db-decorators\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { Repository } from \"@decaf-ts/core\";\nimport { getFabricModelKey } from \"../shared/decorators\";\nimport { FabricModelKeys } from \"../shared/constants\";\n\nexport const MISSING_PRIVATE_DATA_REGEX =\n  /private\\s+data\\s+matching\\s+public\\s+hash\\s+version\\s+is\\s+not\\s+available/i;\n\nexport const MISSING_PRIVATE_DATA_ERROR_MESSAGE =\n  \"private data matching public hash version is not available ...\";\n\nexport function processModel<M extends Model>(adapter: any, model: M) {\n  const transient = modelToTransient(model);\n  const privateData = modelToPrivate(model);\n\n  const transformModel = (model: any) => {\n    return Object.entries(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 (adapter.isReserved(mappedProp))\n          throw new InternalError(`Property name ${mappedProp} is reserved`);\n        accum[mappedProp] = val;\n        return accum;\n      },\n      {}\n    );\n  };\n\n  if (privateData.private) {\n    const collections = Object.keys(privateData.private);\n\n    for (const collection of collections) {\n      privateData.private![collection] = transformModel(\n        privateData.private![collection]\n      );\n    }\n  }\n\n  return {\n    model: transient.model,\n    transient: transient.transient,\n    privateData: privateData.private,\n    result: transformModel(transient.model),\n  };\n}\n\nexport function hasPrivateData<M extends Model>(model: M) {\n  const metadata = getClassPrivateDataMetadata(model);\n  if (!metadata) return false;\n  return true;\n}\n\nexport function getClassPrivateDataMetadata<M extends Model>(\n  model: M\n): Record<string, any> {\n  let metadata = Reflect.getMetadata(\n    getFabricModelKey(FabricModelKeys.PRIVATE),\n    model\n  );\n\n  metadata =\n    metadata ||\n    Reflect.getMetadata(\n      getFabricModelKey(FabricModelKeys.PRIVATE),\n      model.constructor\n    );\n\n  return metadata;\n}\n\nexport function isModelPrivate<M extends Model>(model: M): boolean {\n  const metadata = getClassPrivateDataMetadata(model);\n  if (!metadata || metadata.isPrivate === undefined) return false;\n  return metadata.isPrivate;\n}\n\nexport function modelToPrivate<M extends Model>(\n  model: M\n): { model: M; private?: Record<string, Record<string, any>> } {\n  if (!hasPrivateData(model)) return { model: model };\n  const decs: Record<string, any[]> = getAllPropertyDecoratorsRecursive(\n    model,\n    undefined,\n    getFabricModelKey(FabricModelKeys.PRIVATE)\n  ) as Record<string, any[]>;\n\n  const isPrivate = isModelPrivate(model);\n  const modelCollections: Record<string, any> =\n    getClassPrivateDataMetadata(model);\n\n  let result: { model: Record<string, any>; private?: Record<string, any> } = {\n    model: model as Record<string, any>,\n    private: undefined,\n  };\n\n  if (isPrivate) {\n    result = Object.keys(model).reduce(\n      (\n        accum: { model: Record<string, any>; private?: Record<string, any> },\n        k\n      ) => {\n        const collections = modelCollections.collections;\n        accum.private = accum.private || {};\n\n        for (const collection of collections) {\n          try {\n            accum.private[collection] = accum.private[collection] || {};\n            accum.private[collection][k] = model[k as keyof M];\n          } catch (e: unknown) {\n            throw new SerializationError(\n              `Failed to serialize private property ${k}: ${e}`\n            );\n          }\n        }\n\n        return accum;\n      },\n      { model: {} } as {\n        model: Record<string, any>;\n        private?: Record<string, any>;\n      }\n    );\n  } else {\n    result = Object.entries(decs).reduce(\n      (\n        accum: { model: Record<string, any>; private?: Record<string, any> },\n        [k, val]\n      ) => {\n        const privateData = val.find((el) => el.key === \"\");\n\n        if (privateData) {\n          const collections = privateData.props.collections;\n\n          accum.private = accum.private || {};\n\n          for (const collection of collections) {\n            try {\n              accum.private[collection] = accum.private[collection] || {};\n              accum.private[collection][k] = model[k as keyof M];\n            } catch (e: unknown) {\n              throw new SerializationError(\n                `Failed to serialize private property ${k}: ${e}`\n              );\n            }\n          }\n        } else {\n          accum.model = accum.model || {};\n          accum.model[k] = (model as Record<string, any>)[k];\n        }\n        return accum;\n      },\n      {} as { model: Record<string, any>; private?: Record<string, any> }\n    );\n  }\n\n  result.model = result.model || {};\n\n  result.model = Model.build(result.model, model.constructor.name);\n\n  if (result.private) {\n    const collections = Object.keys(result.private);\n\n    for (const collection of collections) {\n      result.private![collection] = Model.build(\n        result.private![collection],\n        model.constructor.name\n      );\n    }\n  }\n  return result as { model: M; private?: Record<string, Record<string, any>> };\n}\n"]}

package/lib/contracts/private-data.d.ts

@@ -0,0 +1,16 @@
+import { Model } from "@decaf-ts/decorator-validation";
+export declare const MISSING_PRIVATE_DATA_REGEX: RegExp;
+export declare const MISSING_PRIVATE_DATA_ERROR_MESSAGE = "private data matching public hash version is not available ...";
+export declare function processModel<M extends Model>(adapter: any, model: M): {
+    model: M;
+    transient: Record<string, any> | undefined;
+    privateData: Record<string, Record<string, any>> | undefined;
+    result: Record<string, any>;
+};
+export declare function hasPrivateData<M extends Model>(model: M): boolean;
+export declare function getClassPrivateDataMetadata<M extends Model>(model: M): Record<string, any>;
+export declare function isModelPrivate<M extends Model>(model: M): boolean;
+export declare function modelToPrivate<M extends Model>(model: M): {
+    model: M;
+    private?: Record<string, Record<string, any>>;
+};

package/lib/contracts/types.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29udHJhY3RzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXBvc2l0b3J5RmxhZ3MgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcbmltcG9ydCB7IENoYWluY29kZVN0dWIsIENsaWVudElkZW50aXR5IH0gZnJvbSBcImZhYnJpYy1zaGltLWFwaVwiO1xuaW1wb3J0IHsgTG9nZ2VyIH0gZnJvbSBcIkBkZWNhZi10cy9sb2dnaW5nXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEZsYWdzIGZvciBGYWJyaWMgY2hhaW5jb2RlIGNvbnRyYWN0IG9wZXJhdGlvbnNcbiAqIEBzdW1tYXJ5IEV4dGVuZHMgcmVwb3NpdG9yeSBmbGFncyB3aXRoIEZhYnJpYy1zcGVjaWZpYyBjb250ZXh0IGVsZW1lbnRzIGF2YWlsYWJsZSBkdXJpbmcgRmFicmljIGNoYWluY29kZSBleGVjdXRpb24sIHN1Y2ggYXMgdGhlIENoYWluY29kZVN0dWIsIENsaWVudElkZW50aXR5IGFuZCBhIHJlcXVlc3Qtc2NvcGVkIExvZ2dlci5cbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1JlcG9zaXRvcnlGbGFnc30gW2Jhc2VdIC0gQmFzZSByZXBvc2l0b3J5IGZsYWdzIHRoYXQgdGhlc2UgRmFicmljLXNwZWNpZmljIGZsYWdzIGV4dGVuZFxuICogQHJldHVybiB7dm9pZH1cbiAqIEBpbnRlcmZhY2UgRmFicmljQ29udHJhY3RGbGFnc1xuICogQG1lbWJlck9mIG1vZHVsZTpmYWJyaWMuY29udHJhY3RzXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRmFicmljQ29udHJhY3RGbGFncyBleHRlbmRzIFJlcG9zaXRvcnlGbGFncyB7XG4gIC8qKlxuICAgKiBAZGVzY3JpcHRpb24gQ2hhaW5jb2RlIHN0dWIgZm9yIGludGVyYWN0aW5nIHdpdGggdGhlIGxlZGdlclxuICAgKi9cbiAgc3R1YjogQ2hhaW5jb2RlU3R1YjtcblxuICAvKipcbiAgICogQGRlc2NyaXB0aW9uIENsaWVudCBpZGVudGl0eSBmb3IgdGhlIHRyYW5zYWN0aW9uIHN1Ym1pdHRlclxuICAgKi9cbiAgY2xpZW50SWRlbnRpdHk6IENsaWVudElkZW50aXR5O1xuXG4gIC8qKlxuICAgKiBAZGVzY3JpcHRpb24gTG9nZ2VyIGluc3RhbmNlIGZvciB0aGUgY29udHJhY3RcbiAgICovXG4gIGxvZ2dlcjogTG9nZ2VyO1xufVxuIl19

package/lib/contracts/types.d.ts

@@ -0,0 +1,26 @@
+import { RepositoryFlags } from "@decaf-ts/db-decorators";
+import { ChaincodeStub, ClientIdentity } from "fabric-shim-api";
+import { Logger } from "@decaf-ts/logging";
+/**
+ * @description Flags for Fabric chaincode contract operations
+ * @summary Extends repository flags with Fabric-specific context elements available during Fabric chaincode execution, such as the ChaincodeStub, ClientIdentity and a request-scoped Logger.
+ * @template T
+ * @param {RepositoryFlags} [base] - Base repository flags that these Fabric-specific flags extend
+ * @return {void}
+ * @interface FabricContractFlags
+ * @memberOf module:fabric.contracts
+ */
+export interface FabricContractFlags extends RepositoryFlags {
+    /**
+     * @description Chaincode stub for interacting with the ledger
+     */
+    stub: ChaincodeStub;
+    /**
+     * @description Client identity for the transaction submitter
+     */
+    clientIdentity: ClientIdentity;
+    /**
+     * @description Logger instance for the contract
+     */
+    logger: Logger;
+}