@decaf-ts/for-fabric 0.0.2

package/lib/esm/shared/model/Identity.js

@@ -0,0 +1,78 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { BaseModel, Cascade, oneToOne, pk } from "@decaf-ts/core";
+import { model, required } from "@decaf-ts/decorator-validation";
+import { IdentityCredentials } from "./IdentityCredentials.js";
+import { IdentityType } from "./../constants.js";
+/**
+ * @description Identity model representing a Fabric wallet entry
+ * @summary Encapsulates an identity stored in a Fabric wallet, including its MSP identifier, credential linkage, and type information. Built on BaseModel for integration with Decaf validation and persistence.
+ * @param {ModelArg<Identity>} [arg] - Optional initialization object used to populate model fields
+ * @class Identity
+ * @example
+ * // Create a new identity referencing existing credentials
+ * const id = new Identity({ id: "user1", mspId: "Org1MSP", type: IdentityType.X509 });
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Model as Identity
+ *   App->>Model: new Identity({ id, mspId, type })
+ *   Model-->>App: instance
+ */
+let Identity = class Identity extends BaseModel {
+    constructor(arg) {
+        super(arg);
+        /**
+         * @description Unique identifier of the identity in the wallet
+         * @summary Primary key used to reference this identity record
+         */
+        this.id = undefined;
+        /**
+         * @description Link to the identity credentials stored separately
+         * @summary One-to-one relationship to the credentials entity; cascades on update and delete
+         */
+        this.credentials = undefined;
+        /**
+         * @description Membership Service Provider identifier
+         * @summary The MSP ID corresponding to the organization that issued this identity
+         */
+        this.mspId = undefined;
+        /**
+         * @description Type of identity
+         * @summary Indicates the identity encoding/format; defaults to X.509
+         */
+        this.type = IdentityType.X509;
+    }
+};
+__decorate([
+    pk(),
+    __metadata("design:type", String)
+], Identity.prototype, "id", void 0);
+__decorate([
+    oneToOne(IdentityCredentials, {
+        update: Cascade.CASCADE,
+        delete: Cascade.CASCADE,
+    }),
+    __metadata("design:type", IdentityCredentials)
+], Identity.prototype, "credentials", void 0);
+__decorate([
+    required(),
+    __metadata("design:type", String)
+], Identity.prototype, "mspId", void 0);
+__decorate([
+    required(),
+    __metadata("design:type", String)
+], Identity.prototype, "type", void 0);
+Identity = __decorate([
+    model(),
+    __metadata("design:paramtypes", [Object])
+], Identity);
+export { Identity };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/shared/model/IdentityCredentials.d.ts

@@ -0,0 +1,41 @@
+import { BaseModel } from "@decaf-ts/core";
+import { type ModelArg } from "@decaf-ts/decorator-validation";
+/**
+ * @description Identity credential model storing cryptographic materials
+ * @summary Holds certificate chain and private key information for a Fabric identity, managed as a separate entity linked from Identity
+ * @param {ModelArg<IdentityCredentials>} [arg] - Optional initialization object used to populate model fields
+ * @class IdentityCredentials
+ * @example
+ * // Create credentials entry
+ * const creds = new IdentityCredentials({ id: "creds1", certificate: "...", rootCertificate: "...", privateKey: "..." });
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Model as IdentityCredentials
+ *   App->>Model: new IdentityCredentials({ id, certificate, rootCertificate, privateKey })
+ *   Model-->>App: instance
+ * @see model
+ */
+export declare class IdentityCredentials extends BaseModel {
+    /**
+     * @description Unique identifier of the credentials record
+     * @summary Primary key for referencing this credentials entry
+     */
+    id?: string;
+    /**
+     * @description PEM-encoded X.509 certificate for the identity
+     * @summary Leaf certificate associated with the identity
+     */
+    certificate?: string;
+    /**
+     * @description PEM-encoded root or intermediate certificate
+     * @summary Root of trust used to validate the leaf certificate
+     */
+    rootCertificate?: string;
+    /**
+     * @description PEM-encoded private key material
+     * @summary Private key corresponding to the identity certificate
+     */
+    privateKey?: string;
+    constructor(arg?: ModelArg<IdentityCredentials>);
+}

package/lib/esm/shared/model/IdentityCredentials.js

@@ -0,0 +1,74 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { BaseModel, pk } from "@decaf-ts/core";
+import { model, required } from "@decaf-ts/decorator-validation";
+/**
+ * @description Identity credential model storing cryptographic materials
+ * @summary Holds certificate chain and private key information for a Fabric identity, managed as a separate entity linked from Identity
+ * @param {ModelArg<IdentityCredentials>} [arg] - Optional initialization object used to populate model fields
+ * @class IdentityCredentials
+ * @example
+ * // Create credentials entry
+ * const creds = new IdentityCredentials({ id: "creds1", certificate: "...", rootCertificate: "...", privateKey: "..." });
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Model as IdentityCredentials
+ *   App->>Model: new IdentityCredentials({ id, certificate, rootCertificate, privateKey })
+ *   Model-->>App: instance
+ * @see model
+ */
+let IdentityCredentials = class IdentityCredentials extends BaseModel {
+    constructor(arg) {
+        super(arg);
+        /**
+         * @description Unique identifier of the credentials record
+         * @summary Primary key for referencing this credentials entry
+         */
+        this.id = undefined;
+        /**
+         * @description PEM-encoded X.509 certificate for the identity
+         * @summary Leaf certificate associated with the identity
+         */
+        this.certificate = undefined;
+        /**
+         * @description PEM-encoded root or intermediate certificate
+         * @summary Root of trust used to validate the leaf certificate
+         */
+        this.rootCertificate = undefined;
+        /**
+         * @description PEM-encoded private key material
+         * @summary Private key corresponding to the identity certificate
+         */
+        this.privateKey = undefined;
+    }
+};
+__decorate([
+    pk(),
+    __metadata("design:type", String)
+], IdentityCredentials.prototype, "id", void 0);
+__decorate([
+    required(),
+    __metadata("design:type", String)
+], IdentityCredentials.prototype, "certificate", void 0);
+__decorate([
+    required(),
+    __metadata("design:type", String)
+], IdentityCredentials.prototype, "rootCertificate", void 0);
+__decorate([
+    required(),
+    __metadata("design:type", String)
+], IdentityCredentials.prototype, "privateKey", void 0);
+IdentityCredentials = __decorate([
+    model(),
+    __metadata("design:paramtypes", [Object])
+], IdentityCredentials);
+export { IdentityCredentials };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/shared/model/index.d.ts

@@ -0,0 +1 @@
+export * from "./Identity";

package/lib/esm/shared/model/index.js

@@ -0,0 +1,2 @@
+export * from "./Identity.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2hhcmVkL21vZGVsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDhCQUEyQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL0lkZW50aXR5XCI7XG4iXX0=

package/lib/esm/shared/model/utils.d.ts

@@ -0,0 +1,60 @@
+import { Model } from "@decaf-ts/decorator-validation";
+/**
+ * @description Checks whether a model or its class has private data metadata
+ * @summary Uses reflection metadata to determine if the given Decaf model includes Fabric private data annotations at instance or constructor level
+ * @template M extends Model
+ * @param {M} model - The model instance to inspect for private data metadata
+ * @return {boolean} True if private data metadata is present; otherwise false
+ * @function hasPrivateData
+ * @memberOf module:for-fabric.shared
+ */
+export declare function hasPrivateData<M extends Model>(model: M): boolean;
+/**
+ * @description Retrieves the Fabric private data metadata for a model
+ * @summary Looks up the metadata key on the instance first and then on the constructor to support both instance and static decorator placement
+ * @template M extends Model
+ * @param {M} model - The model whose Fabric private data metadata should be retrieved
+ * @return {Record<string, any>} The metadata object if present, otherwise undefined-like value
+ * @function getClassPrivateDataMetadata
+ * @memberOf module:for-fabric.shared
+ */
+export declare function getClassPrivateDataMetadata<M extends Model>(model: M): Record<string, any>;
+/**
+ * @description Determines if a model should be fully treated as private
+ * @summary Reads the metadata flag isPrivate from the model's Fabric private data metadata and returns its boolean value
+ * @template M extends Model
+ * @param {M} model - The model instance to check
+ * @return {boolean} True when model is marked as private; otherwise false
+ * @function isModelPrivate
+ * @memberOf module:for-fabric.shared
+ */
+export declare function isModelPrivate<M extends Model>(model: M): boolean;
+/**
+ * @description Splits a model into public and Fabric private data collections
+ * @summary Iterates over property decorators to collect attributes destined for private data collections while keeping public fields, returning a structure containing the rebuilt public model and a map of collection-name to private attributes
+ * @template M extends Model
+ * @param {M} model - The model instance to transform into public and private parts
+ * @return {{ model: M, private: Record<string, Record<string, any>> }} An object with the rebuilt public model and optional private collection maps
+ * @function modelToPrivate
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant Utils as modelToPrivate
+ *   participant Meta as Metadata
+ *   Caller->>Utils: modelToPrivate(model)
+ *   Utils->>Meta: getAllPropertyDecoratorsRecursive(model, PRIVATE)
+ *   Utils->>Meta: isModelPrivate(model)
+ *   alt model is private or has private props
+ *     Utils->>Utils: group properties by collection
+ *   else
+ *     Utils->>Utils: keep property in public model
+ *   end
+ *   Utils->>Meta: getClassPrivateDataMetadata(model)
+ *   Utils->>Utils: Model.build(public, anchor)
+ *   Utils-->>Caller: { model, private }
+ * @memberOf module:for-fabric.shared
+ */
+export declare function modelToPrivate<M extends Model>(model: M): {
+    model: M;
+    private?: Record<string, Record<string, any>>;
+};

package/lib/esm/shared/model/utils.js

@@ -0,0 +1,108 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { getFabricModelKey } from "./../decorators.js";
+import { FabricModelKeys } from "./../constants.js";
+import { getAllPropertyDecoratorsRecursive, SerializationError, } from "@decaf-ts/db-decorators";
+/**
+ * @description Checks whether a model or its class has private data metadata
+ * @summary Uses reflection metadata to determine if the given Decaf model includes Fabric private data annotations at instance or constructor level
+ * @template M extends Model
+ * @param {M} model - The model instance to inspect for private data metadata
+ * @return {boolean} True if private data metadata is present; otherwise false
+ * @function hasPrivateData
+ * @memberOf module:for-fabric.shared
+ */
+export function hasPrivateData(model) {
+    const metadata = getClassPrivateDataMetadata(model);
+    if (!metadata)
+        return false;
+    return true;
+}
+/**
+ * @description Retrieves the Fabric private data metadata for a model
+ * @summary Looks up the metadata key on the instance first and then on the constructor to support both instance and static decorator placement
+ * @template M extends Model
+ * @param {M} model - The model whose Fabric private data metadata should be retrieved
+ * @return {Record<string, any>} The metadata object if present, otherwise undefined-like value
+ * @function getClassPrivateDataMetadata
+ * @memberOf module:for-fabric.shared
+ */
+export function getClassPrivateDataMetadata(model) {
+    let metadata = Reflect.getMetadata(getFabricModelKey(FabricModelKeys.PRIVATE), model);
+    metadata =
+        metadata ||
+            Reflect.getMetadata(getFabricModelKey(FabricModelKeys.PRIVATE), model.constructor);
+    return metadata;
+}
+/**
+ * @description Determines if a model should be fully treated as private
+ * @summary Reads the metadata flag isPrivate from the model's Fabric private data metadata and returns its boolean value
+ * @template M extends Model
+ * @param {M} model - The model instance to check
+ * @return {boolean} True when model is marked as private; otherwise false
+ * @function isModelPrivate
+ * @memberOf module:for-fabric.shared
+ */
+export function isModelPrivate(model) {
+    const metadata = getClassPrivateDataMetadata(model);
+    if (!metadata || metadata.isPrivate === undefined)
+        return false;
+    return metadata.isPrivate;
+}
+/**
+ * @description Splits a model into public and Fabric private data collections
+ * @summary Iterates over property decorators to collect attributes destined for private data collections while keeping public fields, returning a structure containing the rebuilt public model and a map of collection-name to private attributes
+ * @template M extends Model
+ * @param {M} model - The model instance to transform into public and private parts
+ * @return {{ model: M, private: Record<string, Record<string, any>> }} An object with the rebuilt public model and optional private collection maps
+ * @function modelToPrivate
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant Utils as modelToPrivate
+ *   participant Meta as Metadata
+ *   Caller->>Utils: modelToPrivate(model)
+ *   Utils->>Meta: getAllPropertyDecoratorsRecursive(model, PRIVATE)
+ *   Utils->>Meta: isModelPrivate(model)
+ *   alt model is private or has private props
+ *     Utils->>Utils: group properties by collection
+ *   else
+ *     Utils->>Utils: keep property in public model
+ *   end
+ *   Utils->>Meta: getClassPrivateDataMetadata(model)
+ *   Utils->>Utils: Model.build(public, anchor)
+ *   Utils-->>Caller: { model, private }
+ * @memberOf module:for-fabric.shared
+ */
+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);
+    const result = Object.entries(decs).reduce((accum, [k, val]) => {
+        const privateData = val.find((el) => el.key === "");
+        if (privateData || isPrivate) {
+            const collections = isPrivate
+                ? modelCollections.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 = Model.build(result.model, model.constructor.name);
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/shared/model/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Model } from \"@decaf-ts/decorator-validation\";\nimport { getFabricModelKey } from \"../decorators\";\nimport { FabricModelKeys } from \"../constants\";\nimport {\n  getAllPropertyDecoratorsRecursive,\n  SerializationError,\n} from \"@decaf-ts/db-decorators\";\n\n/**\n * @description Checks whether a model or its class has private data metadata\n * @summary Uses reflection metadata to determine if the given Decaf model includes Fabric private data annotations at instance or constructor level\n * @template M extends Model\n * @param {M} model - The model instance to inspect for private data metadata\n * @return {boolean} True if private data metadata is present; otherwise false\n * @function hasPrivateData\n * @memberOf module:for-fabric.shared\n */\nexport function hasPrivateData<M extends Model>(model: M) {\n  const metadata = getClassPrivateDataMetadata(model);\n  if (!metadata) return false;\n  return true;\n}\n\n/**\n * @description Retrieves the Fabric private data metadata for a model\n * @summary Looks up the metadata key on the instance first and then on the constructor to support both instance and static decorator placement\n * @template M extends Model\n * @param {M} model - The model whose Fabric private data metadata should be retrieved\n * @return {Record<string, any>} The metadata object if present, otherwise undefined-like value\n * @function getClassPrivateDataMetadata\n * @memberOf module:for-fabric.shared\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\n/**\n * @description Determines if a model should be fully treated as private\n * @summary Reads the metadata flag isPrivate from the model's Fabric private data metadata and returns its boolean value\n * @template M extends Model\n * @param {M} model - The model instance to check\n * @return {boolean} True when model is marked as private; otherwise false\n * @function isModelPrivate\n * @memberOf module:for-fabric.shared\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\n/**\n * @description Splits a model into public and Fabric private data collections\n * @summary Iterates over property decorators to collect attributes destined for private data collections while keeping public fields, returning a structure containing the rebuilt public model and a map of collection-name to private attributes\n * @template M extends Model\n * @param {M} model - The model instance to transform into public and private parts\n * @return {{ model: M, private: Record<string, Record<string, any>> }} An object with the rebuilt public model and optional private collection maps\n * @function modelToPrivate\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant Utils as modelToPrivate\n *   participant Meta as Metadata\n *   Caller->>Utils: modelToPrivate(model)\n *   Utils->>Meta: getAllPropertyDecoratorsRecursive(model, PRIVATE)\n *   Utils->>Meta: isModelPrivate(model)\n *   alt model is private or has private props\n *     Utils->>Utils: group properties by collection\n *   else\n *     Utils->>Utils: keep property in public model\n *   end\n *   Utils->>Meta: getClassPrivateDataMetadata(model)\n *   Utils->>Utils: Model.build(public, anchor)\n *   Utils-->>Caller: { model, private }\n * @memberOf module:for-fabric.shared\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  const 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 || isPrivate) {\n        const collections = isPrivate\n          ? modelCollections.collections\n          : privateData.props.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      } 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  result.model = Model.build(result.model, model.constructor.name);\n  return result as { model: M; private?: Record<string, Record<string, any>> };\n}\n"]}

package/lib/esm/shared/types.d.ts

@@ -0,0 +1,79 @@
+import { RepositoryFlags } from "@decaf-ts/db-decorators";
+import { TLSOptions } from "fabric-ca-client";
+/**
+ * @description Configuration for connecting to a Hyperledger Fabric peer
+ * @summary Contains all the necessary parameters to establish a connection to a Fabric peer and interact with chaincode
+ * @typedef {Object} PeerConfig
+ * @property {string} cryptoPath - Path to the crypto materials
+ * @property {string} keyCertOrDirectoryPath - Key file contents or Path to the directory containing private keys
+ * @property {string} certCertOrDirectoryPath - Cert file contents or Path to the directory containing certificates
+ * @property {string} tlsCert - Path to the TLS certificate
+ * @property {string} peerEndpoint - Endpoint URL for the peer
+ * @property {string} peerHostAlias - Host alias for the peer
+ * @property {string} caEndpoint - Endpoint URL for the certificate authority
+ * @property {string} caTlsCertificate - TLS certificate for the certificate authority
+ * @property {string} caCert - Certificate for the certificate authority
+ * @property {string} caKey - Key for the certificate authority
+ * @property {string} chaincodeName - Name of the chaincode to interact with
+ * @property {string} [contractName] - Optional name of the specific contract within the chaincode
+ * @property {string} [ca] - Optional certificate authority name
+ * @property {string} mspId - Membership Service Provider ID
+ * @property {string} channel - Channel name
+ * @memberOf module:for-fabric.shared
+ */
+export type PeerConfig = {
+    cryptoPath: string;
+    keyCertOrDirectoryPath: string;
+    certCertOrDirectoryPath: string;
+    tlsCert: string | Buffer;
+    peerEndpoint: string;
+    peerHostAlias: string;
+    caEndpoint?: string;
+    caTlsCertificate?: string;
+    caCert?: string;
+    caKey?: string;
+    chaincodeName: string;
+    contractName?: string;
+    ca?: string;
+    mspId: string;
+    channel: string;
+};
+/**
+ * @description Flags for Fabric operations
+ * @summary Combines repository flags with peer configuration overrides
+ * @interface FabricFlags
+ * @extends {RepositoryFlags}
+ * @memberOf module:for-fabric.shared
+ */
+export type FabricFlags = RepositoryFlags;
+/**
+ * @description Configuration for connecting to a Hyperledger Fabric peer
+ * @summary Contains all the necessary parameters to establish a connection to a Fabric peer and interact with chaincode
+ * @typedef {Object} CAConfig
+ * @property {string} url - Path to the crypto materials
+ * @property {TLSOptions} tls - Path to the directory containing private keys
+ * @property {string} caName - Path to the directory containing certificates
+ * @property {string} tlsCertPath - Path to the TLS certificate
+ * @property {string} caCert - Endpoint URL for the peer
+ * @property {string} caKey - Host alias for the peer
+ * @memberOf module:for-fabric.shared
+ */
+export type CAConfig = {
+    url: string;
+    tls?: TLSOptions;
+    caName: string;
+    caCert: string;
+    caKey: string;
+};
+/**
+ * @description User credentials for CA enrollment or access
+ * @summary Optional username/password pair used when enrolling with a Fabric CA or authenticating in client utilities
+ * @interface Credentials
+ * @property {string} [userName] - Optional username
+ * @property {string} [password] - Optional password
+ * @memberOf module:for-fabric.shared
+ */
+export interface Credentials {
+    userName?: string;
+    password?: string;
+}

package/lib/esm/shared/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2hhcmVkL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXBvc2l0b3J5RmxhZ3MgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcbmltcG9ydCB7IFRMU09wdGlvbnMgfSBmcm9tIFwiZmFicmljLWNhLWNsaWVudFwiO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDb25maWd1cmF0aW9uIGZvciBjb25uZWN0aW5nIHRvIGEgSHlwZXJsZWRnZXIgRmFicmljIHBlZXJcbiAqIEBzdW1tYXJ5IENvbnRhaW5zIGFsbCB0aGUgbmVjZXNzYXJ5IHBhcmFtZXRlcnMgdG8gZXN0YWJsaXNoIGEgY29ubmVjdGlvbiB0byBhIEZhYnJpYyBwZWVyIGFuZCBpbnRlcmFjdCB3aXRoIGNoYWluY29kZVxuICogQHR5cGVkZWYge09iamVjdH0gUGVlckNvbmZpZ1xuICogQHByb3BlcnR5IHtzdHJpbmd9IGNyeXB0b1BhdGggLSBQYXRoIHRvIHRoZSBjcnlwdG8gbWF0ZXJpYWxzXG4gKiBAcHJvcGVydHkge3N0cmluZ30ga2V5Q2VydE9yRGlyZWN0b3J5UGF0aCAtIEtleSBmaWxlIGNvbnRlbnRzIG9yIFBhdGggdG8gdGhlIGRpcmVjdG9yeSBjb250YWluaW5nIHByaXZhdGUga2V5c1xuICogQHByb3BlcnR5IHtzdHJpbmd9IGNlcnRDZXJ0T3JEaXJlY3RvcnlQYXRoIC0gQ2VydCBmaWxlIGNvbnRlbnRzIG9yIFBhdGggdG8gdGhlIGRpcmVjdG9yeSBjb250YWluaW5nIGNlcnRpZmljYXRlc1xuICogQHByb3BlcnR5IHtzdHJpbmd9IHRsc0NlcnQgLSBQYXRoIHRvIHRoZSBUTFMgY2VydGlmaWNhdGVcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBwZWVyRW5kcG9pbnQgLSBFbmRwb2ludCBVUkwgZm9yIHRoZSBwZWVyXG4gKiBAcHJvcGVydHkge3N0cmluZ30gcGVlckhvc3RBbGlhcyAtIEhvc3QgYWxpYXMgZm9yIHRoZSBwZWVyXG4gKiBAcHJvcGVydHkge3N0cmluZ30gY2FFbmRwb2ludCAtIEVuZHBvaW50IFVSTCBmb3IgdGhlIGNlcnRpZmljYXRlIGF1dGhvcml0eVxuICogQHByb3BlcnR5IHtzdHJpbmd9IGNhVGxzQ2VydGlmaWNhdGUgLSBUTFMgY2VydGlmaWNhdGUgZm9yIHRoZSBjZXJ0aWZpY2F0ZSBhdXRob3JpdHlcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSBjYUNlcnQgLSBDZXJ0aWZpY2F0ZSBmb3IgdGhlIGNlcnRpZmljYXRlIGF1dGhvcml0eVxuICogQHByb3BlcnR5IHtzdHJpbmd9IGNhS2V5IC0gS2V5IGZvciB0aGUgY2VydGlmaWNhdGUgYXV0aG9yaXR5XG4gKiBAcHJvcGVydHkge3N0cmluZ30gY2hhaW5jb2RlTmFtZSAtIE5hbWUgb2YgdGhlIGNoYWluY29kZSB0byBpbnRlcmFjdCB3aXRoXG4gKiBAcHJvcGVydHkge3N0cmluZ30gW2NvbnRyYWN0TmFtZV0gLSBPcHRpb25hbCBuYW1lIG9mIHRoZSBzcGVjaWZpYyBjb250cmFjdCB3aXRoaW4gdGhlIGNoYWluY29kZVxuICogQHByb3BlcnR5IHtzdHJpbmd9IFtjYV0gLSBPcHRpb25hbCBjZXJ0aWZpY2F0ZSBhdXRob3JpdHkgbmFtZVxuICogQHByb3BlcnR5IHtzdHJpbmd9IG1zcElkIC0gTWVtYmVyc2hpcCBTZXJ2aWNlIFByb3ZpZGVyIElEXG4gKiBAcHJvcGVydHkge3N0cmluZ30gY2hhbm5lbCAtIENoYW5uZWwgbmFtZVxuICogQG1lbWJlck9mIG1vZHVsZTpmb3ItZmFicmljLnNoYXJlZFxuICovXG5leHBvcnQgdHlwZSBQZWVyQ29uZmlnID0ge1xuICBjcnlwdG9QYXRoOiBzdHJpbmc7XG4gIGtleUNlcnRPckRpcmVjdG9yeVBhdGg6IHN0cmluZztcbiAgY2VydENlcnRPckRpcmVjdG9yeVBhdGg6IHN0cmluZztcbiAgdGxzQ2VydDogc3RyaW5nIHwgQnVmZmVyO1xuICBwZWVyRW5kcG9pbnQ6IHN0cmluZztcbiAgcGVlckhvc3RBbGlhczogc3RyaW5nO1xuICBjYUVuZHBvaW50Pzogc3RyaW5nO1xuICBjYVRsc0NlcnRpZmljYXRlPzogc3RyaW5nO1xuICBjYUNlcnQ/OiBzdHJpbmc7XG4gIGNhS2V5Pzogc3RyaW5nO1xuICBjaGFpbmNvZGVOYW1lOiBzdHJpbmc7XG4gIGNvbnRyYWN0TmFtZT86IHN0cmluZztcbiAgY2E/OiBzdHJpbmc7XG4gIG1zcElkOiBzdHJpbmc7XG4gIGNoYW5uZWw6IHN0cmluZztcbn07XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEZsYWdzIGZvciBGYWJyaWMgb3BlcmF0aW9uc1xuICogQHN1bW1hcnkgQ29tYmluZXMgcmVwb3NpdG9yeSBmbGFncyB3aXRoIHBlZXIgY29uZmlndXJhdGlvbiBvdmVycmlkZXNcbiAqIEBpbnRlcmZhY2UgRmFicmljRmxhZ3NcbiAqIEBleHRlbmRzIHtSZXBvc2l0b3J5RmxhZ3N9XG4gKiBAbWVtYmVyT2YgbW9kdWxlOmZvci1mYWJyaWMuc2hhcmVkXG4gKi9cbmV4cG9ydCB0eXBlIEZhYnJpY0ZsYWdzID0gUmVwb3NpdG9yeUZsYWdzO1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBDb25maWd1cmF0aW9uIGZvciBjb25uZWN0aW5nIHRvIGEgSHlwZXJsZWRnZXIgRmFicmljIHBlZXJcbiAqIEBzdW1tYXJ5IENvbnRhaW5zIGFsbCB0aGUgbmVjZXNzYXJ5IHBhcmFtZXRlcnMgdG8gZXN0YWJsaXNoIGEgY29ubmVjdGlvbiB0byBhIEZhYnJpYyBwZWVyIGFuZCBpbnRlcmFjdCB3aXRoIGNoYWluY29kZVxuICogQHR5cGVkZWYge09iamVjdH0gQ0FDb25maWdcbiAqIEBwcm9wZXJ0eSB7c3RyaW5nfSB1cmwgLSBQYXRoIHRvIHRoZSBjcnlwdG8gbWF0ZXJpYWxzXG4gKiBAcHJvcGVydHkge1RMU09wdGlvbnN9IHRscyAtIFBhdGggdG8gdGhlIGRpcmVjdG9yeSBjb250YWluaW5nIHByaXZhdGUga2V5c1xuICogQHByb3BlcnR5IHtzdHJpbmd9IGNhTmFtZSAtIFBhdGggdG8gdGhlIGRpcmVjdG9yeSBjb250YWluaW5nIGNlcnRpZmljYXRlc1xuICogQHByb3BlcnR5IHtzdHJpbmd9IHRsc0NlcnRQYXRoIC0gUGF0aCB0byB0aGUgVExTIGNlcnRpZmljYXRlXG4gKiBAcHJvcGVydHkge3N0cmluZ30gY2FDZXJ0IC0gRW5kcG9pbnQgVVJMIGZvciB0aGUgcGVlclxuICogQHByb3BlcnR5IHtzdHJpbmd9IGNhS2V5IC0gSG9zdCBhbGlhcyBmb3IgdGhlIHBlZXJcbiAqIEBtZW1iZXJPZiBtb2R1bGU6Zm9yLWZhYnJpYy5zaGFyZWRcbiAqL1xuZXhwb3J0IHR5cGUgQ0FDb25maWcgPSB7XG4gIHVybDogc3RyaW5nO1xuICB0bHM/OiBUTFNPcHRpb25zO1xuICBjYU5hbWU6IHN0cmluZztcbiAgY2FDZXJ0OiBzdHJpbmc7XG4gIGNhS2V5OiBzdHJpbmc7XG59O1xuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBVc2VyIGNyZWRlbnRpYWxzIGZvciBDQSBlbnJvbGxtZW50IG9yIGFjY2Vzc1xuICogQHN1bW1hcnkgT3B0aW9uYWwgdXNlcm5hbWUvcGFzc3dvcmQgcGFpciB1c2VkIHdoZW4gZW5yb2xsaW5nIHdpdGggYSBGYWJyaWMgQ0Egb3IgYXV0aGVudGljYXRpbmcgaW4gY2xpZW50IHV0aWxpdGllc1xuICogQGludGVyZmFjZSBDcmVkZW50aWFsc1xuICogQHByb3BlcnR5IHtzdHJpbmd9IFt1c2VyTmFtZV0gLSBPcHRpb25hbCB1c2VybmFtZVxuICogQHByb3BlcnR5IHtzdHJpbmd9IFtwYXNzd29yZF0gLSBPcHRpb25hbCBwYXNzd29yZFxuICogQG1lbWJlck9mIG1vZHVsZTpmb3ItZmFicmljLnNoYXJlZFxuICovXG5leHBvcnQgaW50ZXJmYWNlIENyZWRlbnRpYWxzIHtcbiAgdXNlck5hbWU/OiBzdHJpbmc7XG4gIHBhc3N3b3JkPzogc3RyaW5nO1xufVxuIl19

package/lib/esm/shared/utils.d.ts

@@ -0,0 +1,55 @@
+import { Identity, Signer } 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 declare class CoreUtils {
+    private static logger;
+    private 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
+     */
+    private static contentOfLoadFile;
+    /**
+     * @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 readFile(contentOrPath: string | Buffer): Promise<Buffer<ArrayBufferLike>>;
+    /**
+     * @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 getCAUser(userName: string, privateKey: string, certificate: string, mspId: string): Promise<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 getIdentity(mspId: string, certDirectoryPath: string): Promise<Identity>;
+    static getFirstDirFileName(dirPath: string): Promise<string>;
+    static getFirstDirFileNameContent(dirPath: string): Promise<string>;
+    static getFileContent(filePath: string): Promise<string>;
+    static getSigner(keyDirectoryPath: string): Promise<Signer>;
+    private static extractPrivateKey;
+}