@decaf-ts/for-fabric 0.0.2

package/lib/esm/contracts/private-data.js

@@ -0,0 +1,113 @@
+import { getAllPropertyDecoratorsRecursive, InternalError, modelToTransient, SerializationError, } from "@decaf-ts/db-decorators";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Repository } from "@decaf-ts/core";
+import { getFabricModelKey } from "./../shared/decorators.js";
+import { FabricModelKeys } from "./../shared/constants.js";
+export const MISSING_PRIVATE_DATA_REGEX = /private\s+data\s+matching\s+public\s+hash\s+version\s+is\s+not\s+available/i;
+export const MISSING_PRIVATE_DATA_ERROR_MESSAGE = "private data matching public hash version is not available ...";
+export function processModel(adapter, model) {
+    const transient = 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 = Repository.column(model, key);
+            if (adapter.isReserved(mappedProp))
+                throw new 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),
+    };
+}
+export function hasPrivateData(model) {
+    const metadata = getClassPrivateDataMetadata(model);
+    if (!metadata)
+        return false;
+    return true;
+}
+export function getClassPrivateDataMetadata(model) {
+    let metadata = Reflect.getMetadata(getFabricModelKey(FabricModelKeys.PRIVATE), model);
+    metadata =
+        metadata ||
+            Reflect.getMetadata(getFabricModelKey(FabricModelKeys.PRIVATE), model.constructor);
+    return metadata;
+}
+export function isModelPrivate(model) {
+    const metadata = getClassPrivateDataMetadata(model);
+    if (!metadata || metadata.isPrivate === undefined)
+        return false;
+    return metadata.isPrivate;
+}
+export function modelToPrivate(model) {
+    if (!hasPrivateData(model))
+        return { model: model };
+    const decs = getAllPropertyDecoratorsRecursive(model, undefined, getFabricModelKey(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 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 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 = Model.build(result.model, model.constructor.name);
+    if (result.private) {
+        const collections = Object.keys(result.private);
+        for (const collection of collections) {
+            result.private[collection] = 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/esm/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;
+}

package/lib/esm/contracts/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29udHJhY3RzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXBvc2l0b3J5RmxhZ3MgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcbmltcG9ydCB7IENoYWluY29kZVN0dWIsIENsaWVudElkZW50aXR5IH0gZnJvbSBcImZhYnJpYy1zaGltLWFwaVwiO1xuaW1wb3J0IHsgTG9nZ2VyIH0gZnJvbSBcIkBkZWNhZi10cy9sb2dnaW5nXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEZsYWdzIGZvciBGYWJyaWMgY2hhaW5jb2RlIGNvbnRyYWN0IG9wZXJhdGlvbnNcbiAqIEBzdW1tYXJ5IEV4dGVuZHMgcmVwb3NpdG9yeSBmbGFncyB3aXRoIEZhYnJpYy1zcGVjaWZpYyBjb250ZXh0IGVsZW1lbnRzIGF2YWlsYWJsZSBkdXJpbmcgRmFicmljIGNoYWluY29kZSBleGVjdXRpb24sIHN1Y2ggYXMgdGhlIENoYWluY29kZVN0dWIsIENsaWVudElkZW50aXR5IGFuZCBhIHJlcXVlc3Qtc2NvcGVkIExvZ2dlci5cbiAqIEB0ZW1wbGF0ZSBUXG4gKiBAcGFyYW0ge1JlcG9zaXRvcnlGbGFnc30gW2Jhc2VdIC0gQmFzZSByZXBvc2l0b3J5IGZsYWdzIHRoYXQgdGhlc2UgRmFicmljLXNwZWNpZmljIGZsYWdzIGV4dGVuZFxuICogQHJldHVybiB7dm9pZH1cbiAqIEBpbnRlcmZhY2UgRmFicmljQ29udHJhY3RGbGFnc1xuICogQG1lbWJlck9mIG1vZHVsZTpmYWJyaWMuY29udHJhY3RzXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRmFicmljQ29udHJhY3RGbGFncyBleHRlbmRzIFJlcG9zaXRvcnlGbGFncyB7XG4gIC8qKlxuICAgKiBAZGVzY3JpcHRpb24gQ2hhaW5jb2RlIHN0dWIgZm9yIGludGVyYWN0aW5nIHdpdGggdGhlIGxlZGdlclxuICAgKi9cbiAgc3R1YjogQ2hhaW5jb2RlU3R1YjtcblxuICAvKipcbiAgICogQGRlc2NyaXB0aW9uIENsaWVudCBpZGVudGl0eSBmb3IgdGhlIHRyYW5zYWN0aW9uIHN1Ym1pdHRlclxuICAgKi9cbiAgY2xpZW50SWRlbnRpdHk6IENsaWVudElkZW50aXR5O1xuXG4gIC8qKlxuICAgKiBAZGVzY3JpcHRpb24gTG9nZ2VyIGluc3RhbmNlIGZvciB0aGUgY29udHJhY3RcbiAgICovXG4gIGxvZ2dlcjogTG9nZ2VyO1xufVxuIl19

package/lib/esm/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/esm/index.js

@@ -0,0 +1,9 @@
+/**
+ * @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/index.js";
+export * from "./contracts/index.js";
+export * from "./shared/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILGtDQUF5QjtBQUN6QixxQ0FBNEI7QUFDNUIsa0NBQXlCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAZGVzY3JpcHRpb24gSHlwZXJsZWRnZXIgRmFicmljIE1vZHVsZSBmb3IgRGVjYWYtdHNcbiAqIEBzdW1tYXJ5IFByb3ZpZGVzIGNsaWVudC1zaWRlIGFuZCBjaGFpbmNvZGUtc2lkZSB0b29saW5nIGZvciBidWlsZGluZyBIeXBlcmxlZGdlciBGYWJyaWMgYXBwbGljYXRpb25zIHdpdGggRGVjYWYtdHMuIEV4cG9zZXMgY2xpZW50IGFkYXB0ZXJzLCByZXBvc2l0b3JpZXMsIGNvbnRyYWN0IGFkYXB0ZXJzLCBzZXF1ZW5jZXMsIHV0aWxpdGllcywgYW5kIHNoYXJlZCB0eXBlcyB0byBzdHJlYW1saW5lIGRldmVsb3BtZW50IGFuZCBpbnRlcmFjdGlvbiB3aXRoIEZhYnJpYyBuZXR3b3Jrcy4gU2VlIHtAbGluayBtb2R1bGU6ZmFicmljLmNsaWVudH0sIHtAbGluayBtb2R1bGU6ZmFicmljLmNvbnRyYWN0c30sIGFuZCB7QGxpbmsgbW9kdWxlOmZhYnJpYy5zaGFyZWR9IGZvciBncm91cGVkIGV4cG9ydHMuXG4gKiBAbW9kdWxlIGZvci1mYWJyaWNcbiAqL1xuXG5leHBvcnQgKiBmcm9tIFwiLi9jbGllbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnRyYWN0c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2hhcmVkXCI7XG4iXX0=

package/lib/esm/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/esm/shared/ClientSerializer.js

@@ -0,0 +1,80 @@
+import { getMetadata, JSONSerializer, Model, ModelKeys, } from "@decaf-ts/decorator-validation";
+import { SerializationError } from "@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
+ */
+export class ClientSerializer extends 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 = getMetadata(model);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (e) {
+            metadata = table;
+        }
+        if (!metadata)
+            throw new SerializationError(`Could not find metadata for ${model.constructor.name}`);
+        toSerialize[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[ModelKeys.ANCHOR];
+        if (!className)
+            throw new Error("Could not find class reference in serialized model");
+        const model = 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));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/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/esm/shared/DeterministicSerializer.js

@@ -0,0 +1,50 @@
+/* eslint-disable @typescript-eslint/no-require-imports */
+import { JSONSerializer } 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 class DeterministicSerializer extends 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)));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/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/esm/shared/SimpleDeterministicSerializer.js

@@ -0,0 +1,42 @@
+import { JSONSerializer } from "@decaf-ts/decorator-validation";
+export class SimpleDeterministicSerializer extends 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/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";

package/lib/esm/shared/constants.js

@@ -0,0 +1,42 @@
+/**
+ * @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 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 || (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
+ */
+export var IdentityType;
+(function (IdentityType) {
+    /** Standard X.509 identity format used by Hyperledger Fabric */
+    IdentityType["X509"] = "X.509";
+})(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
+ */
+export 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 const VERSION = "0.0.2";
+//# sourceMappingURL=data:application/json;base64,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