@decaf-ts/for-fabric 0.0.2

package/lib/esm/shared/utils.js

@@ -0,0 +1,148 @@
+import { stringFormat } from "@decaf-ts/decorator-validation";
+import { Logging } from "@decaf-ts/logging";
+import { normalizeImport } from "@decaf-ts/utils";
+import { signers } from "@hyperledger/fabric-gateway";
+import { User } from "fabric-common";
+/**
+ * @description Core utilities for interacting with files, crypto identities, and Fabric SDK helpers
+ * @summary Provides static helper methods to read credentials and keys from disk or raw content, construct Fabric gateway Identities and Signers, and perform common filesystem operations used by the Fabric client tooling.
+ * @class CoreUtils
+ * @example
+ * // Read an identity and signer from directories
+ * const identity = await CoreUtils.getIdentity('Org1MSP', '/msp/signcerts');
+ * const signer = await CoreUtils.getSigner('/msp/keystore');
+ * // Build a CA user
+ * const user = await CoreUtils.getCAUser('appUser', pemKey, pemCert, 'Org1MSP');
+ */
+export class CoreUtils {
+    static { this.logger = Logging.for(CoreUtils.name); }
+    constructor() { }
+    /**
+     * @description Resolve file content from a path or return provided raw content
+     * @summary If the input is a Uint8Array or PEM content, returns it as-is; otherwise uses a provided async fileReader to load the content from disk.
+     * @param {string|Uint8Array} contentOrPath - Either a raw content buffer/string or a filesystem path
+     * @param {function(string): Promise<string|Uint8Array|Buffer>} fileReader - Async function to read file content when a path is provided
+     * @return {Promise<string|Uint8Array|Buffer>} The content to be used downstream
+     */
+    static async contentOfLoadFile(contentOrPath, fileReader) {
+        if (contentOrPath instanceof Uint8Array)
+            return contentOrPath;
+        if (contentOrPath.match(/-----BEGIN (CERTIFICATE|KEY|PRIVATE KEY)-----.+?-----END \1-----$/gms))
+            return contentOrPath;
+        return await fileReader(contentOrPath);
+    }
+    /**
+     * @description Read file content from a path or return provided Buffer
+     * @summary Convenience wrapper that loads a file using fs.promises when a path string is provided; otherwise returns the given Buffer directly.
+     * @param {string|Buffer} contentOrPath - Path to a file on disk or an already-loaded Buffer
+     * @return {Promise<string|Uint8Array|Buffer>} The file content as a Buffer/string depending on reader
+     */
+    static async readFile(contentOrPath) {
+        if (typeof contentOrPath !== "string")
+            return contentOrPath;
+        const fileReader = async (path) => {
+            const { promises } = await normalizeImport(import("fs"));
+            return await promises.readFile(path);
+        };
+        return await fileReader(contentOrPath);
+    }
+    /**
+     * @description Create a Fabric CA User object with enrollment
+     * @summary Constructs a fabric-common User, sets a crypto suite, imports the provided private key, and sets enrollment with certificate and MSP ID.
+     * @param {string} userName - The user name for the CA user
+     * @param {string} privateKey - PEM-encoded private key
+     * @param {string} certificate - PEM-encoded X.509 certificate
+     * @param {string} mspId - Membership Service Provider identifier
+     * @return {Promise<User>} The enrolled Fabric User instance
+     */
+    static async getCAUser(userName, privateKey, certificate, mspId) {
+        this.logger.debug(stringFormat("Creating CA {0} user {1} with certificate {2}", mspId, userName, certificate));
+        const user = new User(userName);
+        const cryptoSuite = User.newCryptoSuite();
+        user.setCryptoSuite(cryptoSuite);
+        const importedKey = cryptoSuite.createKeyFromRaw(privateKey);
+        await user.setEnrollment(importedKey, certificate, mspId);
+        return user;
+    }
+    /**
+     * @description Build a Fabric Gateway Identity from an MSP ID and certificate
+     * @summary Reads a certificate from a directory path or accepts raw content and returns an Identity object suitable for the Fabric Gateway.
+     * @param {string} mspId - Membership Service Provider ID
+     * @param {string} certDirectoryPath - Path to a directory containing the certificate file, or PEM content
+     * @return {Promise<Identity>} The identity containing mspId and certificate credentials
+     */
+    static async getIdentity(mspId, certDirectoryPath) {
+        const identityFileReader = async (path) => {
+            const { promises } = await normalizeImport(import("fs"));
+            const certPath = await this.getFirstDirFileName(path);
+            const credentials = await promises.readFile(certPath);
+            return credentials;
+        };
+        const credentials = (await this.contentOfLoadFile(certDirectoryPath, identityFileReader));
+        return { mspId, credentials };
+    }
+    static async getFirstDirFileName(dirPath) {
+        const { promises } = await normalizeImport(import("fs"));
+        const { join } = await normalizeImport(import("path"));
+        const files = await promises.readdir(dirPath);
+        return join(dirPath, files[0]);
+    }
+    static async getFirstDirFileNameContent(dirPath) {
+        const { promises } = await normalizeImport(import("fs"));
+        const { join } = await normalizeImport(import("path"));
+        const files = await promises.readdir(dirPath);
+        return (await promises.readFile(join(dirPath, files[0]))).toString();
+    }
+    static async getFileContent(filePath) {
+        const { promises } = await normalizeImport(import("fs"));
+        return (await promises.readFile(filePath)).toString();
+    }
+    static async getSigner(keyDirectoryPath) {
+        const signerFileReader = async (path) => {
+            const { promises } = await normalizeImport(import("fs"));
+            const keyPath = await this.getFirstDirFileName(path);
+            return await promises.readFile(keyPath);
+        };
+        const privateKeyPem = (await this.contentOfLoadFile(keyDirectoryPath, signerFileReader));
+        const privateKey = await this.extractPrivateKey(privateKeyPem);
+        const keys = Object.getOwnPropertySymbols(privateKey);
+        const k = privateKey[keys[0]];
+        // --
+        return signers.newPrivateKeySigner(k);
+    }
+    static async extractPrivateKey(pem) {
+        const libName = "crypto";
+        let subtle;
+        if (globalThis.window &&
+            globalThis.window.Crypto) {
+            subtle = globalThis.Crypto.subtle;
+        }
+        else {
+            const lib = (await normalizeImport(import(libName)));
+            subtle = lib.subtle || lib.webcrypto.subtle;
+        }
+        if (!subtle)
+            throw new Error("Could not load SubtleCrypto module");
+        function str2ab(str) {
+            const buf = new ArrayBuffer(str.length);
+            const bufView = new Uint8Array(buf);
+            for (let i = 0, strLen = str.length; i < strLen; i++) {
+                bufView[i] = str.charCodeAt(i);
+            }
+            return buf;
+        }
+        const str = pem
+            .toString("utf8")
+            .replace("-----BEGIN PRIVATE KEY-----", "")
+            .replaceAll("\n", "")
+            .replace("-----END PRIVATE KEY-----", "");
+        const decoded = Buffer.from(str, "base64").toString("binary");
+        const binaryDer = str2ab(decoded);
+        const key = await subtle.importKey("pkcs8", binaryDer, {
+            name: "ECDSA",
+            namedCurve: "P-256",
+        }, true, ["sign"]);
+        return key;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/shared/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { stringFormat } from \"@decaf-ts/decorator-validation\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\nimport { normalizeImport } from \"@decaf-ts/utils\";\nimport { Identity, Signer, signers } from \"@hyperledger/fabric-gateway\";\nimport { User } from \"fabric-common\";\n\n/**\n * @description Core utilities for interacting with files, crypto identities, and Fabric SDK helpers\n * @summary Provides static helper methods to read credentials and keys from disk or raw content, construct Fabric gateway Identities and Signers, and perform common filesystem operations used by the Fabric client tooling.\n * @class CoreUtils\n * @example\n * // Read an identity and signer from directories\n * const identity = await CoreUtils.getIdentity('Org1MSP', '/msp/signcerts');\n * const signer = await CoreUtils.getSigner('/msp/keystore');\n * // Build a CA user\n * const user = await CoreUtils.getCAUser('appUser', pemKey, pemCert, 'Org1MSP');\n */\nexport class CoreUtils {\n  private static logger: Logger = Logging.for(CoreUtils.name);\n\n  private constructor() {}\n\n  /**\n   * @description Resolve file content from a path or return provided raw content\n   * @summary If the input is a Uint8Array or PEM content, returns it as-is; otherwise uses a provided async fileReader to load the content from disk.\n   * @param {string|Uint8Array} contentOrPath - Either a raw content buffer/string or a filesystem path\n   * @param {function(string): Promise<string|Uint8Array|Buffer>} fileReader - Async function to read file content when a path is provided\n   * @return {Promise<string|Uint8Array|Buffer>} The content to be used downstream\n   */\n  private static async contentOfLoadFile(\n    contentOrPath: string | Uint8Array,\n    fileReader: (path: string) => Promise<string | Uint8Array | Buffer>\n  ) {\n    if (contentOrPath instanceof Uint8Array) return contentOrPath;\n    if (\n      contentOrPath.match(\n        /-----BEGIN (CERTIFICATE|KEY|PRIVATE KEY)-----.+?-----END \\1-----$/gms\n      )\n    )\n      return contentOrPath;\n    return await fileReader(contentOrPath);\n  }\n\n  /**\n   * @description Read file content from a path or return provided Buffer\n   * @summary Convenience wrapper that loads a file using fs.promises when a path string is provided; otherwise returns the given Buffer directly.\n   * @param {string|Buffer} contentOrPath - Path to a file on disk or an already-loaded Buffer\n   * @return {Promise<string|Uint8Array|Buffer>} The file content as a Buffer/string depending on reader\n   */\n  static async readFile(contentOrPath: string | Buffer) {\n    if (typeof contentOrPath !== \"string\") return contentOrPath;\n\n    const fileReader = async (path: string) => {\n      const { promises } = await normalizeImport(import(\"fs\"));\n      return await promises.readFile(path);\n    };\n\n    return await fileReader(contentOrPath);\n  }\n\n  /**\n   * @description Create a Fabric CA User object with enrollment\n   * @summary Constructs a fabric-common User, sets a crypto suite, imports the provided private key, and sets enrollment with certificate and MSP ID.\n   * @param {string} userName - The user name for the CA user\n   * @param {string} privateKey - PEM-encoded private key\n   * @param {string} certificate - PEM-encoded X.509 certificate\n   * @param {string} mspId - Membership Service Provider identifier\n   * @return {Promise<User>} The enrolled Fabric User instance\n   */\n  static async getCAUser(\n    userName: string,\n    privateKey: string,\n    certificate: string,\n    mspId: string\n  ): Promise<User> {\n    this.logger.debug(\n      stringFormat(\n        \"Creating CA {0} user {1} with certificate {2}\",\n        mspId,\n        userName,\n        certificate\n      )\n    );\n    const user = new User(userName);\n    const cryptoSuite = User.newCryptoSuite();\n    user.setCryptoSuite(cryptoSuite);\n    const importedKey = cryptoSuite.createKeyFromRaw(privateKey);\n    await user.setEnrollment(importedKey, certificate, mspId);\n    return user;\n  }\n\n  /**\n   * @description Build a Fabric Gateway Identity from an MSP ID and certificate\n   * @summary Reads a certificate from a directory path or accepts raw content and returns an Identity object suitable for the Fabric Gateway.\n   * @param {string} mspId - Membership Service Provider ID\n   * @param {string} certDirectoryPath - Path to a directory containing the certificate file, or PEM content\n   * @return {Promise<Identity>} The identity containing mspId and certificate credentials\n   */\n  static async getIdentity(\n    mspId: string,\n    certDirectoryPath: string\n  ): Promise<Identity> {\n    const identityFileReader = async (path: string) => {\n      const { promises } = await normalizeImport(import(\"fs\"));\n      const certPath = await this.getFirstDirFileName(path);\n      const credentials = await promises.readFile(certPath);\n      return credentials;\n    };\n\n    const credentials: Uint8Array = (await this.contentOfLoadFile(\n      certDirectoryPath,\n      identityFileReader\n    )) as Uint8Array;\n\n    return { mspId, credentials };\n  }\n\n  static async getFirstDirFileName(dirPath: string): Promise<string> {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    const { join } = await normalizeImport(import(\"path\"));\n    const files = await promises.readdir(dirPath);\n    return join(dirPath, files[0]);\n  }\n\n  static async getFirstDirFileNameContent(dirPath: string): Promise<string> {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    const { join } = await normalizeImport(import(\"path\"));\n    const files = await promises.readdir(dirPath);\n    return (await promises.readFile(join(dirPath, files[0]))).toString();\n  }\n\n  static async getFileContent(filePath: string): Promise<string> {\n    const { promises } = await normalizeImport(import(\"fs\"));\n    return (await promises.readFile(filePath)).toString();\n  }\n\n  static async getSigner(keyDirectoryPath: string): Promise<Signer> {\n    const signerFileReader = async (path: string) => {\n      const { promises } = await normalizeImport(import(\"fs\"));\n      const keyPath = await this.getFirstDirFileName(path);\n      return await promises.readFile(keyPath);\n    };\n\n    const privateKeyPem = (await this.contentOfLoadFile(\n      keyDirectoryPath,\n      signerFileReader\n    )) as Buffer;\n    const privateKey = await this.extractPrivateKey(privateKeyPem);\n    const keys = Object.getOwnPropertySymbols(privateKey);\n    const k = (privateKey as any)[keys[0]];\n    // --\n\n    return signers.newPrivateKeySigner(k as any);\n  }\n\n  private static async extractPrivateKey(pem: Buffer) {\n    const libName = \"crypto\";\n    let subtle: any;\n    if (\n      (globalThis as any).window &&\n      ((globalThis as any).window as { Crypto: any }).Crypto\n    ) {\n      subtle = ((globalThis as any).Crypto as any).subtle;\n    } else {\n      const lib = (await normalizeImport(import(libName))) as any;\n      subtle = lib.subtle || lib.webcrypto.subtle;\n    }\n\n    if (!subtle) throw new Error(\"Could not load SubtleCrypto module\");\n\n    function str2ab(str: string) {\n      const buf = new ArrayBuffer(str.length);\n      const bufView = new Uint8Array(buf);\n      for (let i = 0, strLen = str.length; i < strLen; i++) {\n        bufView[i] = str.charCodeAt(i);\n      }\n      return buf;\n    }\n\n    const str = pem\n      .toString(\"utf8\")\n      .replace(\"-----BEGIN PRIVATE KEY-----\", \"\")\n      .replaceAll(\"\\n\", \"\")\n      .replace(\"-----END PRIVATE KEY-----\", \"\");\n    const decoded = Buffer.from(str, \"base64\").toString(\"binary\");\n    const binaryDer = str2ab(decoded);\n    const key = await subtle.importKey(\n      \"pkcs8\",\n      binaryDer,\n      {\n        name: \"ECDSA\",\n        namedCurve: \"P-256\",\n      },\n      true,\n      [\"sign\"]\n    );\n\n    return key;\n  }\n}\n"]}

package/lib/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * @description Hyperledger Fabric Module for Decaf-ts
+ * @summary Provides client-side and chaincode-side tooling for building Hyperledger Fabric applications with Decaf-ts. Exposes client adapters, repositories, contract adapters, sequences, utilities, and shared types to streamline development and interaction with Fabric networks. See {@link module:fabric.client}, {@link module:fabric.contracts}, and {@link module:fabric.shared} for grouped exports.
+ * @module for-fabric
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client/index.cjs"), exports);
+__exportStar(require("./contracts/index.cjs"), exports);
+__exportStar(require("./shared/index.cjs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7O0dBSUc7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCxxREFBeUI7QUFDekIsd0RBQTRCO0FBQzVCLHFEQUF5QiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlc2NyaXB0aW9uIEh5cGVybGVkZ2VyIEZhYnJpYyBNb2R1bGUgZm9yIERlY2FmLXRzXG4gKiBAc3VtbWFyeSBQcm92aWRlcyBjbGllbnQtc2lkZSBhbmQgY2hhaW5jb2RlLXNpZGUgdG9vbGluZyBmb3IgYnVpbGRpbmcgSHlwZXJsZWRnZXIgRmFicmljIGFwcGxpY2F0aW9ucyB3aXRoIERlY2FmLXRzLiBFeHBvc2VzIGNsaWVudCBhZGFwdGVycywgcmVwb3NpdG9yaWVzLCBjb250cmFjdCBhZGFwdGVycywgc2VxdWVuY2VzLCB1dGlsaXRpZXMsIGFuZCBzaGFyZWQgdHlwZXMgdG8gc3RyZWFtbGluZSBkZXZlbG9wbWVudCBhbmQgaW50ZXJhY3Rpb24gd2l0aCBGYWJyaWMgbmV0d29ya3MuIFNlZSB7QGxpbmsgbW9kdWxlOmZhYnJpYy5jbGllbnR9LCB7QGxpbmsgbW9kdWxlOmZhYnJpYy5jb250cmFjdHN9LCBhbmQge0BsaW5rIG1vZHVsZTpmYWJyaWMuc2hhcmVkfSBmb3IgZ3JvdXBlZCBleHBvcnRzLlxuICogQG1vZHVsZSBmb3ItZmFicmljXG4gKi9cblxuZXhwb3J0ICogZnJvbSBcIi4vY2xpZW50XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb250cmFjdHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NoYXJlZFwiO1xuIl19

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @description Hyperledger Fabric Module for Decaf-ts
+ * @summary Provides client-side and chaincode-side tooling for building Hyperledger Fabric applications with Decaf-ts. Exposes client adapters, repositories, contract adapters, sequences, utilities, and shared types to streamline development and interaction with Fabric networks. See {@link module:fabric.client}, {@link module:fabric.contracts}, and {@link module:fabric.shared} for grouped exports.
+ * @module for-fabric
+ */
+export * from "./client";
+export * from "./contracts";
+export * from "./shared";

package/lib/shared/ClientSerializer.cjs

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientSerializer = void 0;
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+/**
+ * @description Client-side JSON serializer for Decaf models targeting Hyperledger Fabric
+ * @summary Extends the base JSONSerializer to embed model metadata (anchor) required to reconstruct instances on the client, and to safely serialize/deserialize Fabric-bound models.
+ * @template M extends Model - The Decaf model type handled by this serializer
+ * @param {void} [constructor] No public constructor arguments; provided for documentation completeness
+ * @return {void}
+ * @class ClientSerializer
+ * @example
+ * const serializer = new ClientSerializer<User>();
+ * const json = serializer.serialize(new User({ id: "1", name: "Alice" }));
+ * const user = serializer.deserialize(json);
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Serializer as ClientSerializer
+ *   participant Model
+ *   App->>Serializer: serialize(model)
+ *   Serializer->>Serializer: preSerialize(model)
+ *   Serializer-->>App: JSON string
+ *   App->>Serializer: deserialize(json)
+ *   Serializer->>Serializer: JSON.parse(json)
+ *   Serializer->>Model: Model.build(parsed, anchor)
+ *   Model-->>App: instance
+ */
+class ClientSerializer extends decorator_validation_1.JSONSerializer {
+    constructor() {
+        super();
+    }
+    /**
+     * @description Prepare a model for JSON serialization embedding class anchor
+     * @summary Clones the model and injects the class metadata anchor so it can be reconstructed during deserialization. Falls back to provided table name if metadata is not available.
+     * @template M - Model type handled by this serializer
+     * @param {M} model - The model instance to serialize
+     * @param {string} [table] - Optional table name to use when metadata cannot be derived
+     * @return {Record<string, any>} A plain object ready to be JSON.stringify'd
+     */
+    preSerialize(model, table) {
+        // TODO: nested preserialization (so increase performance when deserializing)
+        const toSerialize = Object.assign({}, model);
+        let metadata;
+        try {
+            metadata = (0, decorator_validation_1.getMetadata)(model);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            metadata = table;
+        }
+        if (!metadata)
+            throw new db_decorators_1.SerializationError(`Could not find metadata for ${model.constructor.name}`);
+        toSerialize[decorator_validation_1.ModelKeys.ANCHOR] = metadata;
+        return toSerialize;
+    }
+    /**
+     * @description Rebuilds a model from its JSON serialization
+     * @summary Parses the JSON string, retrieves the embedded model anchor, and uses Model.build to reconstruct the original instance
+     * @param {string} str - The JSON string previously produced by serialize
+     * @return {M} The reconstructed model instance
+     */
+    deserialize(str) {
+        const deserialization = JSON.parse(str);
+        const className = deserialization[decorator_validation_1.ModelKeys.ANCHOR];
+        if (!className)
+            throw new Error("Could not find class reference in serialized model");
+        const model = decorator_validation_1.Model.build(deserialization, className);
+        return model;
+    }
+    /**
+     * @description Serializes a model to a JSON string
+     * @summary Prepares the model via preSerialize, embedding metadata needed for reconstruction, and returns a JSON string representation
+     * @param {M} model - The model instance to serialize
+     * @param {string} [table] - Optional table name to include as anchor when metadata is unavailable
+     * @return {string} A JSON string containing the serialized model with anchor metadata
+     */
+    serialize(model, table) {
+        return JSON.stringify(this.preSerialize(model, table));
+    }
+}
+exports.ClientSerializer = ClientSerializer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2xpZW50U2VyaWFsaXplci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zaGFyZWQvQ2xpZW50U2VyaWFsaXplci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx5RUFLd0M7QUFDeEMsMkRBQTZEO0FBRTdEOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXVCRztBQUNILE1BQWEsZ0JBQWtDLFNBQVEscUNBQWlCO0lBQ3RFO1FBQ0UsS0FBSyxFQUFFLENBQUM7SUFDVixDQUFDO0lBQ0Q7Ozs7Ozs7T0FPRztJQUNnQixZQUFZLENBQUMsS0FBUSxFQUFFLEtBQWM7UUFDdEQsNkVBQTZFO1FBQzdFLE1BQU0sV0FBVyxHQUF3QixNQUFNLENBQUMsTUFBTSxDQUFDLEVBQUUsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUNsRSxJQUFJLFFBQVEsQ0FBQztRQUNiLElBQUksQ0FBQztZQUNILFFBQVEsR0FBRyxJQUFBLGtDQUFXLEVBQUMsS0FBSyxDQUFDLENBQUM7WUFDOUIsNkRBQTZEO1FBQy9ELENBQUM7UUFBQyxPQUFPLENBQVUsRUFBRSxDQUFDO1lBQ3BCLFFBQVEsR0FBRyxLQUFLLENBQUM7UUFDbkIsQ0FBQztRQUNELElBQUksQ0FBQyxRQUFRO1lBQ1gsTUFBTSxJQUFJLGtDQUFrQixDQUMxQiwrQkFBK0IsS0FBSyxDQUFDLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FDeEQsQ0FBQztRQUNKLFdBQVcsQ0FBQyxnQ0FBUyxDQUFDLE1BQU0sQ0FBQyxHQUFHLFFBQVEsQ0FBQztRQUN6QyxPQUFPLFdBQVcsQ0FBQztJQUNyQixDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDTSxXQUFXLENBQUMsR0FBVztRQUM5QixNQUFNLGVBQWUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3hDLE1BQU0sU0FBUyxHQUFHLGVBQWUsQ0FBQyxnQ0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ3BELElBQUksQ0FBQyxTQUFTO1lBQ1osTUFBTSxJQUFJLEtBQUssQ0FBQyxvREFBb0QsQ0FBQyxDQUFDO1FBQ3hFLE1BQU0sS0FBSyxHQUFNLDRCQUFLLENBQUMsS0FBSyxDQUFDLGVBQWUsRUFBRSxTQUFTLENBQWlCLENBQUM7UUFDekUsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ00sU0FBUyxDQUFDLEtBQVEsRUFBRSxLQUFjO1FBQ3pDLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBRSxLQUFLLENBQUMsQ0FBQyxDQUFDO0lBQ3pELENBQUM7Q0FDRjtBQXZERCw0Q0F1REMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBnZXRNZXRhZGF0YSxcbiAgSlNPTlNlcmlhbGl6ZXIsXG4gIE1vZGVsLFxuICBNb2RlbEtleXMsXG59IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB7IFNlcmlhbGl6YXRpb25FcnJvciB9IGZyb20gXCJAZGVjYWYtdHMvZGItZGVjb3JhdG9yc1wiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDbGllbnQtc2lkZSBKU09OIHNlcmlhbGl6ZXIgZm9yIERlY2FmIG1vZGVscyB0YXJnZXRpbmcgSHlwZXJsZWRnZXIgRmFicmljXG4gKiBAc3VtbWFyeSBFeHRlbmRzIHRoZSBiYXNlIEpTT05TZXJpYWxpemVyIHRvIGVtYmVkIG1vZGVsIG1ldGFkYXRhIChhbmNob3IpIHJlcXVpcmVkIHRvIHJlY29uc3RydWN0IGluc3RhbmNlcyBvbiB0aGUgY2xpZW50LCBhbmQgdG8gc2FmZWx5IHNlcmlhbGl6ZS9kZXNlcmlhbGl6ZSBGYWJyaWMtYm91bmQgbW9kZWxzLlxuICogQHRlbXBsYXRlIE0gZXh0ZW5kcyBNb2RlbCAtIFRoZSBEZWNhZiBtb2RlbCB0eXBlIGhhbmRsZWQgYnkgdGhpcyBzZXJpYWxpemVyXG4gKiBAcGFyYW0ge3ZvaWR9IFtjb25zdHJ1Y3Rvcl0gTm8gcHVibGljIGNvbnN0cnVjdG9yIGFyZ3VtZW50czsgcHJvdmlkZWQgZm9yIGRvY3VtZW50YXRpb24gY29tcGxldGVuZXNzXG4gKiBAcmV0dXJuIHt2b2lkfVxuICogQGNsYXNzIENsaWVudFNlcmlhbGl6ZXJcbiAqIEBleGFtcGxlXG4gKiBjb25zdCBzZXJpYWxpemVyID0gbmV3IENsaWVudFNlcmlhbGl6ZXI8VXNlcj4oKTtcbiAqIGNvbnN0IGpzb24gPSBzZXJpYWxpemVyLnNlcmlhbGl6ZShuZXcgVXNlcih7IGlkOiBcIjFcIiwgbmFtZTogXCJBbGljZVwiIH0pKTtcbiAqIGNvbnN0IHVzZXIgPSBzZXJpYWxpemVyLmRlc2VyaWFsaXplKGpzb24pO1xuICogQG1lcm1haWRcbiAqIHNlcXVlbmNlRGlhZ3JhbVxuICogICBwYXJ0aWNpcGFudCBBcHBcbiAqICAgcGFydGljaXBhbnQgU2VyaWFsaXplciBhcyBDbGllbnRTZXJpYWxpemVyXG4gKiAgIHBhcnRpY2lwYW50IE1vZGVsXG4gKiAgIEFwcC0+PlNlcmlhbGl6ZXI6IHNlcmlhbGl6ZShtb2RlbClcbiAqICAgU2VyaWFsaXplci0+PlNlcmlhbGl6ZXI6IHByZVNlcmlhbGl6ZShtb2RlbClcbiAqICAgU2VyaWFsaXplci0tPj5BcHA6IEpTT04gc3RyaW5nXG4gKiAgIEFwcC0+PlNlcmlhbGl6ZXI6IGRlc2VyaWFsaXplKGpzb24pXG4gKiAgIFNlcmlhbGl6ZXItPj5TZXJpYWxpemVyOiBKU09OLnBhcnNlKGpzb24pXG4gKiAgIFNlcmlhbGl6ZXItPj5Nb2RlbDogTW9kZWwuYnVpbGQocGFyc2VkLCBhbmNob3IpXG4gKiAgIE1vZGVsLS0+PkFwcDogaW5zdGFuY2VcbiAqL1xuZXhwb3J0IGNsYXNzIENsaWVudFNlcmlhbGl6ZXI8TSBleHRlbmRzIE1vZGVsPiBleHRlbmRzIEpTT05TZXJpYWxpemVyPE0+IHtcbiAgY29uc3RydWN0b3IoKSB7XG4gICAgc3VwZXIoKTtcbiAgfVxuICAvKipcbiAgICogQGRlc2NyaXB0aW9uIFByZXBhcmUgYSBtb2RlbCBmb3IgSlNPTiBzZXJpYWxpemF0aW9uIGVtYmVkZGluZyBjbGFzcyBhbmNob3JcbiAgICogQHN1bW1hcnkgQ2xvbmVzIHRoZSBtb2RlbCBhbmQgaW5qZWN0cyB0aGUgY2xhc3MgbWV0YWRhdGEgYW5jaG9yIHNvIGl0IGNhbiBiZSByZWNvbnN0cnVjdGVkIGR1cmluZyBkZXNlcmlhbGl6YXRpb24uIEZhbGxzIGJhY2sgdG8gcHJvdmlkZWQgdGFibGUgbmFtZSBpZiBtZXRhZGF0YSBpcyBub3QgYXZhaWxhYmxlLlxuICAgKiBAdGVtcGxhdGUgTSAtIE1vZGVsIHR5cGUgaGFuZGxlZCBieSB0aGlzIHNlcmlhbGl6ZXJcbiAgICogQHBhcmFtIHtNfSBtb2RlbCAtIFRoZSBtb2RlbCBpbnN0YW5jZSB0byBzZXJpYWxpemVcbiAgICogQHBhcmFtIHtzdHJpbmd9IFt0YWJsZV0gLSBPcHRpb25hbCB0YWJsZSBuYW1lIHRvIHVzZSB3aGVuIG1ldGFkYXRhIGNhbm5vdCBiZSBkZXJpdmVkXG4gICAqIEByZXR1cm4ge1JlY29yZDxzdHJpbmcsIGFueT59IEEgcGxhaW4gb2JqZWN0IHJlYWR5IHRvIGJlIEpTT04uc3RyaW5naWZ5J2RcbiAgICovXG4gIHByb3RlY3RlZCBvdmVycmlkZSBwcmVTZXJpYWxpemUobW9kZWw6IE0sIHRhYmxlPzogc3RyaW5nKSB7XG4gICAgLy8gVE9ETzogbmVzdGVkIHByZXNlcmlhbGl6YXRpb24gKHNvIGluY3JlYXNlIHBlcmZvcm1hbmNlIHdoZW4gZGVzZXJpYWxpemluZylcbiAgICBjb25zdCB0b1NlcmlhbGl6ZTogUmVjb3JkPHN0cmluZywgYW55PiA9IE9iamVjdC5hc3NpZ24oe30sIG1vZGVsKTtcbiAgICBsZXQgbWV0YWRhdGE7XG4gICAgdHJ5IHtcbiAgICAgIG1ldGFkYXRhID0gZ2V0TWV0YWRhdGEobW9kZWwpO1xuICAgICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby11bnVzZWQtdmFyc1xuICAgIH0gY2F0Y2ggKGU6IHVua25vd24pIHtcbiAgICAgIG1ldGFkYXRhID0gdGFibGU7XG4gICAgfVxuICAgIGlmICghbWV0YWRhdGEpXG4gICAgICB0aHJvdyBuZXcgU2VyaWFsaXphdGlvbkVycm9yKFxuICAgICAgICBgQ291bGQgbm90IGZpbmQgbWV0YWRhdGEgZm9yICR7bW9kZWwuY29uc3RydWN0b3IubmFtZX1gXG4gICAgICApO1xuICAgIHRvU2VyaWFsaXplW01vZGVsS2V5cy5BTkNIT1JdID0gbWV0YWRhdGE7XG4gICAgcmV0dXJuIHRvU2VyaWFsaXplO1xuICB9XG5cbiAgLyoqXG4gICAqIEBkZXNjcmlwdGlvbiBSZWJ1aWxkcyBhIG1vZGVsIGZyb20gaXRzIEpTT04gc2VyaWFsaXphdGlvblxuICAgKiBAc3VtbWFyeSBQYXJzZXMgdGhlIEpTT04gc3RyaW5nLCByZXRyaWV2ZXMgdGhlIGVtYmVkZGVkIG1vZGVsIGFuY2hvciwgYW5kIHVzZXMgTW9kZWwuYnVpbGQgdG8gcmVjb25zdHJ1Y3QgdGhlIG9yaWdpbmFsIGluc3RhbmNlXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBzdHIgLSBUaGUgSlNPTiBzdHJpbmcgcHJldmlvdXNseSBwcm9kdWNlZCBieSBzZXJpYWxpemVcbiAgICogQHJldHVybiB7TX0gVGhlIHJlY29uc3RydWN0ZWQgbW9kZWwgaW5zdGFuY2VcbiAgICovXG4gIG92ZXJyaWRlIGRlc2VyaWFsaXplKHN0cjogc3RyaW5nKTogTSB7XG4gICAgY29uc3QgZGVzZXJpYWxpemF0aW9uID0gSlNPTi5wYXJzZShzdHIpO1xuICAgIGNvbnN0IGNsYXNzTmFtZSA9IGRlc2VyaWFsaXphdGlvbltNb2RlbEtleXMuQU5DSE9SXTtcbiAgICBpZiAoIWNsYXNzTmFtZSlcbiAgICAgIHRocm93IG5ldyBFcnJvcihcIkNvdWxkIG5vdCBmaW5kIGNsYXNzIHJlZmVyZW5jZSBpbiBzZXJpYWxpemVkIG1vZGVsXCIpO1xuICAgIGNvbnN0IG1vZGVsOiBNID0gTW9kZWwuYnVpbGQoZGVzZXJpYWxpemF0aW9uLCBjbGFzc05hbWUpIGFzIHVua25vd24gYXMgTTtcbiAgICByZXR1cm4gbW9kZWw7XG4gIH1cblxuICAvKipcbiAgICogQGRlc2NyaXB0aW9uIFNlcmlhbGl6ZXMgYSBtb2RlbCB0byBhIEpTT04gc3RyaW5nXG4gICAqIEBzdW1tYXJ5IFByZXBhcmVzIHRoZSBtb2RlbCB2aWEgcHJlU2VyaWFsaXplLCBlbWJlZGRpbmcgbWV0YWRhdGEgbmVlZGVkIGZvciByZWNvbnN0cnVjdGlvbiwgYW5kIHJldHVybnMgYSBKU09OIHN0cmluZyByZXByZXNlbnRhdGlvblxuICAgKiBAcGFyYW0ge019IG1vZGVsIC0gVGhlIG1vZGVsIGluc3RhbmNlIHRvIHNlcmlhbGl6ZVxuICAgKiBAcGFyYW0ge3N0cmluZ30gW3RhYmxlXSAtIE9wdGlvbmFsIHRhYmxlIG5hbWUgdG8gaW5jbHVkZSBhcyBhbmNob3Igd2hlbiBtZXRhZGF0YSBpcyB1bmF2YWlsYWJsZVxuICAgKiBAcmV0dXJuIHtzdHJpbmd9IEEgSlNPTiBzdHJpbmcgY29udGFpbmluZyB0aGUgc2VyaWFsaXplZCBtb2RlbCB3aXRoIGFuY2hvciBtZXRhZGF0YVxuICAgKi9cbiAgb3ZlcnJpZGUgc2VyaWFsaXplKG1vZGVsOiBNLCB0YWJsZT86IHN0cmluZyk6IHN0cmluZyB7XG4gICAgcmV0dXJuIEpTT04uc3RyaW5naWZ5KHRoaXMucHJlU2VyaWFsaXplKG1vZGVsLCB0YWJsZSkpO1xuICB9XG59XG4iXX0=

package/lib/shared/ClientSerializer.d.ts

@@ -0,0 +1,52 @@
+import { JSONSerializer, Model } from "@decaf-ts/decorator-validation";
+/**
+ * @description Client-side JSON serializer for Decaf models targeting Hyperledger Fabric
+ * @summary Extends the base JSONSerializer to embed model metadata (anchor) required to reconstruct instances on the client, and to safely serialize/deserialize Fabric-bound models.
+ * @template M extends Model - The Decaf model type handled by this serializer
+ * @param {void} [constructor] No public constructor arguments; provided for documentation completeness
+ * @return {void}
+ * @class ClientSerializer
+ * @example
+ * const serializer = new ClientSerializer<User>();
+ * const json = serializer.serialize(new User({ id: "1", name: "Alice" }));
+ * const user = serializer.deserialize(json);
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Serializer as ClientSerializer
+ *   participant Model
+ *   App->>Serializer: serialize(model)
+ *   Serializer->>Serializer: preSerialize(model)
+ *   Serializer-->>App: JSON string
+ *   App->>Serializer: deserialize(json)
+ *   Serializer->>Serializer: JSON.parse(json)
+ *   Serializer->>Model: Model.build(parsed, anchor)
+ *   Model-->>App: instance
+ */
+export declare class ClientSerializer<M extends Model> extends JSONSerializer<M> {
+    constructor();
+    /**
+     * @description Prepare a model for JSON serialization embedding class anchor
+     * @summary Clones the model and injects the class metadata anchor so it can be reconstructed during deserialization. Falls back to provided table name if metadata is not available.
+     * @template M - Model type handled by this serializer
+     * @param {M} model - The model instance to serialize
+     * @param {string} [table] - Optional table name to use when metadata cannot be derived
+     * @return {Record<string, any>} A plain object ready to be JSON.stringify'd
+     */
+    protected preSerialize(model: M, table?: string): Record<string, any>;
+    /**
+     * @description Rebuilds a model from its JSON serialization
+     * @summary Parses the JSON string, retrieves the embedded model anchor, and uses Model.build to reconstruct the original instance
+     * @param {string} str - The JSON string previously produced by serialize
+     * @return {M} The reconstructed model instance
+     */
+    deserialize(str: string): M;
+    /**
+     * @description Serializes a model to a JSON string
+     * @summary Prepares the model via preSerialize, embedding metadata needed for reconstruction, and returns a JSON string representation
+     * @param {M} model - The model instance to serialize
+     * @param {string} [table] - Optional table name to include as anchor when metadata is unavailable
+     * @return {string} A JSON string containing the serialized model with anchor metadata
+     */
+    serialize(model: M, table?: string): string;
+}

package/lib/shared/DeterministicSerializer.cjs

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeterministicSerializer = void 0;
+/* eslint-disable @typescript-eslint/no-require-imports */
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+/**
+ * @description Deterministic JSON serializer for Fabric models
+ * @summary Ensures stable, deterministic JSON output by sorting object keys recursively before stringification, which is important for Fabric endorsement and hashing. Extends JSONSerializer to plug into existing Decaf model serialization flow.
+ * @template M - The Decaf Model subtype serialized by this instance
+ * @param {void} [constructor] No public constructor arguments
+ * @class DeterministicSerializer
+ * @example
+ * const serializer = new DeterministicSerializer<MyModel>();
+ * const json = serializer.serialize(model);
+ * const rebuilt = serializer.deserialize(json);
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant DS as DeterministicSerializer
+ *   Caller->>DS: serialize(model)
+ *   DS->>DS: preSerialize(model)
+ *   DS->>DS: sort-keys-recursive
+ *   DS->>DS: json-stringify-deterministic
+ *   DS-->>Caller: string
+ *   Caller->>DS: deserialize(string)
+ *   DS-->>Caller: model
+ */
+class DeterministicSerializer extends decorator_validation_1.JSONSerializer {
+    constructor() {
+        super();
+    }
+    /**
+     * @description Deserialize a JSON string into a model instance
+     * @summary Delegates to the base JSONSerializer implementation to rebuild the model
+     * @param {string} str - The JSON string to deserialize
+     * @return {M} The reconstructed model instance
+     */
+    deserialize(str) {
+        return super.deserialize(str);
+    }
+    /**
+     * @description Serialize a model into a deterministic JSON string
+     * @summary Prepares the model with preSerialize, sorts keys recursively, and stringifies deterministically for stable ordering
+     * @param {M} model - The model instance to serialize
+     * @return {string} Deterministic JSON representation of the model
+     */
+    serialize(model) {
+        const stringify = require("json-stringify-deterministic");
+        const sortKeysRecursive = require("sort-keys-recursive");
+        return stringify(sortKeysRecursive(this.preSerialize(model)));
+    }
+}
+exports.DeterministicSerializer = DeterministicSerializer;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/shared/DeterministicSerializer.d.ts

@@ -0,0 +1,40 @@
+import { JSONSerializer, Model } from "@decaf-ts/decorator-validation";
+/**
+ * @description Deterministic JSON serializer for Fabric models
+ * @summary Ensures stable, deterministic JSON output by sorting object keys recursively before stringification, which is important for Fabric endorsement and hashing. Extends JSONSerializer to plug into existing Decaf model serialization flow.
+ * @template M - The Decaf Model subtype serialized by this instance
+ * @param {void} [constructor] No public constructor arguments
+ * @class DeterministicSerializer
+ * @example
+ * const serializer = new DeterministicSerializer<MyModel>();
+ * const json = serializer.serialize(model);
+ * const rebuilt = serializer.deserialize(json);
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant DS as DeterministicSerializer
+ *   Caller->>DS: serialize(model)
+ *   DS->>DS: preSerialize(model)
+ *   DS->>DS: sort-keys-recursive
+ *   DS->>DS: json-stringify-deterministic
+ *   DS-->>Caller: string
+ *   Caller->>DS: deserialize(string)
+ *   DS-->>Caller: model
+ */
+export declare class DeterministicSerializer<M extends Model> extends JSONSerializer<M> {
+    constructor();
+    /**
+     * @description Deserialize a JSON string into a model instance
+     * @summary Delegates to the base JSONSerializer implementation to rebuild the model
+     * @param {string} str - The JSON string to deserialize
+     * @return {M} The reconstructed model instance
+     */
+    deserialize(str: string): M;
+    /**
+     * @description Serialize a model into a deterministic JSON string
+     * @summary Prepares the model with preSerialize, sorts keys recursively, and stringifies deterministically for stable ordering
+     * @param {M} model - The model instance to serialize
+     * @return {string} Deterministic JSON representation of the model
+     */
+    serialize(model: M): string;
+}

package/lib/shared/SimpleDeterministicSerializer.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleDeterministicSerializer = void 0;
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+class SimpleDeterministicSerializer extends decorator_validation_1.JSONSerializer {
+    constructor() {
+        super();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    deserialize(str, tableName) {
+        const deserialization = JSON.parse(str);
+        // const className = tableName;
+        // if (!className)
+        //   throw new Error("Could not find class reference in serialized model");
+        // // this will return undefined values
+        // const model: M = Model.build(deserialization, className) as unknown as M;
+        // // Populate Model
+        // const processedDesealization = Object.keys(model).reduce(
+        //   (accum: M, key) => {
+        //     (accum as Record<string, any>)[key] =
+        //       deserialization[Repository.column(accum, key)];
+        //     return accum;
+        //   },
+        //   model
+        // );
+        // const result = Model.build(
+        //   processedDesealization,
+        //   className
+        // ) as unknown as M;
+        // return result;
+        return deserialization;
+    }
+    serialize(model) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const stringify = require("json-stringify-deterministic");
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const sortKeysRecursive = require("sort-keys-recursive");
+        return stringify(sortKeysRecursive(this.preSerialize(model)));
+    }
+    preSerialize(model) {
+        const toSerialize = Object.assign({}, model);
+        return toSerialize;
+    }
+}
+exports.SimpleDeterministicSerializer = SimpleDeterministicSerializer;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/shared/SimpleDeterministicSerializer.d.ts

@@ -0,0 +1,7 @@
+import { JSONSerializer, Model } from "@decaf-ts/decorator-validation";
+export declare class SimpleDeterministicSerializer<M extends Model> extends JSONSerializer<M> {
+    constructor();
+    deserialize(str: string, tableName?: string): M;
+    serialize(model: M): string;
+    preSerialize(model: M): Record<string, any>;
+}

package/lib/shared/constants.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.FabricFlavour = exports.IdentityType = exports.FabricModelKeys = void 0;
+/**
+ * @description Keys used to mark Fabric-specific model metadata
+ * @summary Enumeration of special keys used by the serialization layer to persist Fabric-related flags on models
+ * @enum {string}
+ * @readonly
+ * @memberOf module:for-fabric.shared
+ */
+var FabricModelKeys;
+(function (FabricModelKeys) {
+    /** Private data marker used to tag properties or models for Fabric private collections */
+    FabricModelKeys["PRIVATE"] = "private";
+    /** Namespace prefix used for Fabric-specific metadata keys */
+    FabricModelKeys["FABRIC"] = "fabric.";
+    FabricModelKeys["OWNEDBY"] = "owned-by";
+})(FabricModelKeys || (exports.FabricModelKeys = FabricModelKeys = {}));
+/**
+ * @description Supported identity types for Fabric credentials
+ * @summary Enumeration of identity formats recognized by this library
+ * @enum {string}
+ * @readonly
+ * @memberOf module:for-fabric.shared
+ */
+var IdentityType;
+(function (IdentityType) {
+    /** Standard X.509 identity format used by Hyperledger Fabric */
+    IdentityType["X509"] = "X.509";
+})(IdentityType || (exports.IdentityType = IdentityType = {}));
+/**
+ * @description String identifier for the Fabric adapter flavour
+ * @summary Used to tag adapters/repositories that operate against Hyperledger Fabric
+ * @const FabricFlavour
+ * @memberOf module:for-fabric.shared
+ */
+exports.FabricFlavour = "hlf-fabric";
+/**
+ * @description Package version placeholder replaced at build time
+ * @summary Constant holding the current package version injected by the build pipeline
+ * @const VERSION
+ * @memberOf module:for-fabric.shared
+ */
+exports.VERSION = "0.0.2";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/shared/constants.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @description Keys used to mark Fabric-specific model metadata
+ * @summary Enumeration of special keys used by the serialization layer to persist Fabric-related flags on models
+ * @enum {string}
+ * @readonly
+ * @memberOf module:for-fabric.shared
+ */
+export declare enum FabricModelKeys {
+    /** Private data marker used to tag properties or models for Fabric private collections */
+    PRIVATE = "private",
+    /** Namespace prefix used for Fabric-specific metadata keys */
+    FABRIC = "fabric.",
+    OWNEDBY = "owned-by"
+}
+/**
+ * @description Supported identity types for Fabric credentials
+ * @summary Enumeration of identity formats recognized by this library
+ * @enum {string}
+ * @readonly
+ * @memberOf module:for-fabric.shared
+ */
+export declare enum IdentityType {
+    /** Standard X.509 identity format used by Hyperledger Fabric */
+    X509 = "X.509"
+}
+/**
+ * @description String identifier for the Fabric adapter flavour
+ * @summary Used to tag adapters/repositories that operate against Hyperledger Fabric
+ * @const FabricFlavour
+ * @memberOf module:for-fabric.shared
+ */
+export declare const FabricFlavour = "hlf-fabric";
+/**
+ * @description Package version placeholder replaced at build time
+ * @summary Constant holding the current package version injected by the build pipeline
+ * @const VERSION
+ * @memberOf module:for-fabric.shared
+ */
+export declare const VERSION = "0.0.2";