@cdklabs/cdk-hyperledger-fabric-network 0.0.20

package/lib/node.d.ts

@@ -0,0 +1,88 @@
+import * as customresources from 'aws-cdk-lib/custom-resources';
+import * as constructs from 'constructs';
+import * as network from './network';
+/**
+ * Supported instance types for Managed Blockchain nodes
+ */
+export declare enum InstanceType {
+    BURSTABLE3_SMALL = "bc.t3.small",
+    BURSTABLE3_MEDIUM = "bc.t3.medium",
+    BURSTABLE3_LARGE = "bc.t3.large",
+    BURSTABLE3_XLARGE = "bc.t3.xlarge",
+    STANDARD5_LARGE = "bc.m5.large",
+    STANDARD5_XLARGE = "bc.m5.xlarge",
+    STANDARD5_XLARGE2 = "bc.m5.2xlarge",
+    STANDARD5_XLARGE4 = "bc.m5.4xlarge",
+    COMPUTE5_LARGE = "bc.c5.large",
+    COMPUTE5_XLARGE = "bc.c5.xlarge",
+    COMPUTE5_XLARGE2 = "bc.c5.2xlarge",
+    COMPUTE5_XLARGE4 = "bc.c5.4xlarge"
+}
+/**
+ * Valid instance types for starter networks
+ */
+export declare const STARTER_INSTANCE_TYPES: InstanceType[];
+/**
+ * Construct properties for `HyperledgerFabricNode`
+ */
+export interface HyperledgerFabricNodeProps {
+    /**
+     * The Availability Zone in which the node will be created
+     * @default - The first AZ in the region
+     */
+    readonly availabilityZone?: string;
+    /**
+     * The Amazon Managed Blockchain instance type for the node
+     * @default - BURSTABLE3_SMALL
+     */
+    readonly instanceType?: InstanceType;
+    /**
+     * The configuration to enable or disable chaincode logging
+     * @default - true
+     */
+    readonly enableChaincodeLogging?: boolean;
+    /**
+     * The configuration to enable or disable node logging
+     * @default - true
+     */
+    readonly enableNodeLogging?: boolean;
+}
+/**
+ * Creates a Hyperledger Fabric node on an Amazon Managed Blockchain network
+ */
+export declare class HyperledgerFabricNode extends constructs.Construct {
+    static constructNodes(scope: network.HyperledgerFabricNetwork, nodeProps?: Array<HyperledgerFabricNodeProps>): HyperledgerFabricNode[];
+    /**
+     * Managed Blockchain network identifier
+     */
+    readonly networkId: string;
+    /**
+     * Managed Blockchain member identifier
+     */
+    readonly memberId: string;
+    /**
+     * Managed Blockchain node identifier generated on construction
+     */
+    readonly nodeId: string;
+    /**
+     * The Availability Zone in which the node exists
+     */
+    readonly availabilityZone: string;
+    /**
+     * The Amazon Managed Blockchain instance type for the node
+     */
+    readonly instanceType: InstanceType;
+    /**
+     * The configuration to enable or disable chaincode logging
+     */
+    readonly enableChaincodeLogging: boolean;
+    /**
+     * The configuration to enable or disable node logging
+     */
+    readonly enableNodeLogging: boolean;
+    endpoint: string;
+    eventEndpoint: string;
+    constructor(scope: network.HyperledgerFabricNetwork, id: string, props?: HyperledgerFabricNodeProps);
+    configureLogging(sdkCallPolicy: customresources.AwsCustomResourcePolicy): void;
+    fetchData(dataSdkCallPolicy: customresources.AwsCustomResourcePolicy): void;
+}

package/lib/node.js

@@ -0,0 +1,161 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperledgerFabricNode = exports.STARTER_INSTANCE_TYPES = exports.InstanceType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: MIT-0
+const cdk = require("aws-cdk-lib");
+const managedblockchain = require("aws-cdk-lib/aws-managedblockchain");
+const customresources = require("aws-cdk-lib/custom-resources");
+const constructs = require("constructs");
+const network = require("./network");
+const utilities = require("./utilities");
+/**
+ * Supported instance types for Managed Blockchain nodes
+ */
+var InstanceType;
+(function (InstanceType) {
+    InstanceType["BURSTABLE3_SMALL"] = "bc.t3.small";
+    InstanceType["BURSTABLE3_MEDIUM"] = "bc.t3.medium";
+    InstanceType["BURSTABLE3_LARGE"] = "bc.t3.large";
+    InstanceType["BURSTABLE3_XLARGE"] = "bc.t3.xlarge";
+    InstanceType["STANDARD5_LARGE"] = "bc.m5.large";
+    InstanceType["STANDARD5_XLARGE"] = "bc.m5.xlarge";
+    InstanceType["STANDARD5_XLARGE2"] = "bc.m5.2xlarge";
+    InstanceType["STANDARD5_XLARGE4"] = "bc.m5.4xlarge";
+    InstanceType["COMPUTE5_LARGE"] = "bc.c5.large";
+    InstanceType["COMPUTE5_XLARGE"] = "bc.c5.xlarge";
+    InstanceType["COMPUTE5_XLARGE2"] = "bc.c5.2xlarge";
+    InstanceType["COMPUTE5_XLARGE4"] = "bc.c5.4xlarge";
+})(InstanceType = exports.InstanceType || (exports.InstanceType = {}));
+/**
+ * Valid instance types for starter networks
+ */
+exports.STARTER_INSTANCE_TYPES = [
+    InstanceType.BURSTABLE3_SMALL,
+    InstanceType.BURSTABLE3_MEDIUM,
+];
+/**
+ * Creates a Hyperledger Fabric node on an Amazon Managed Blockchain network
+ */
+class HyperledgerFabricNode extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        // These cannot be readonly since they have to be set after construction
+        // due the race condition documented in https://github.com/aws/aws-cdk/issues/18237.
+        this.endpoint = '';
+        this.eventEndpoint = '';
+        // Collect metadata on the stack
+        const region = cdk.Stack.of(this).region;
+        // Populate instance variables from input properties, using defaults if values not provided
+        if (typeof props === 'undefined')
+            props = {};
+        this.availabilityZone = props.availabilityZone ?? `${region}a`;
+        this.instanceType = props.instanceType ?? InstanceType.BURSTABLE3_SMALL;
+        this.enableChaincodeLogging = props.enableChaincodeLogging ?? true;
+        this.enableNodeLogging = props.enableNodeLogging ?? true;
+        this.networkId = scope.networkId;
+        this.memberId = scope.memberId;
+        // Ensure the parameters captured above are valid, so we don't
+        // need to wait until deployment time to discover an error
+        utilities.validateRegion(region);
+        utilities.validateAvailabilityZone(region, this.availabilityZone);
+        if (scope.networkEdition === network.NetworkEdition.STARTER && !exports.STARTER_INSTANCE_TYPES.includes(this.instanceType)) {
+            const starterInstanceTypeList = exports.STARTER_INSTANCE_TYPES.join(', ');
+            throw new Error(`Instance type in a starter network must be one of the following: ${starterInstanceTypeList}.`);
+        }
+        // Build out the Cloudformation construct for the network/member
+        const node = new managedblockchain.CfnNode(this, 'Node', {
+            networkId: this.networkId,
+            memberId: this.memberId,
+            nodeConfiguration: {
+                availabilityZone: this.availabilityZone,
+                instanceType: this.instanceType,
+            },
+        });
+        // Capture data included in the Cloudformation output in instance variables
+        this.nodeId = node.getAtt('NodeId').toString();
+    }
+    /*
+     * Build out a list of HyperledgerFabricNode constructs given a list of input property
+     * objects; additionally checks to ensure node count is supported given the network type
+     */
+    static constructNodes(scope, nodeProps) {
+        // If no node configurations are provided, create one; the empty object
+        // will be populated with defaults when passed to the node constructor
+        if (typeof nodeProps === 'undefined')
+            nodeProps = [{}];
+        const starter = scope.networkEdition === network.NetworkEdition.STARTER;
+        if (starter && nodeProps.length > 2) {
+            throw new Error('A starter network can have at most 2 nodes per member.');
+        }
+        if (!starter && nodeProps.length > 3) {
+            throw new Error('A standard network can have at most 3 nodes per member.');
+        }
+        // Construct the node list, using an index value in the identifier
+        return Array.from(nodeProps.entries()).map(e => new HyperledgerFabricNode(scope, `Node${e[0]}`, e[1]));
+    }
+    /*
+     * Configure logging for the node via SDK call; this function
+     * should be merged back into the constructor once the race condition is solved
+     */
+    configureLogging(sdkCallPolicy) {
+        // This call doesn't really need all the permissions its using in the
+        // provided policy, but since the policy must be constructed all at once
+        // this is the only way to do it effectively
+        const logPublishingConfiguration = {
+            Fabric: {
+                ChaincodeLogs: {
+                    Cloudwatch: { Enabled: this.enableChaincodeLogging },
+                },
+                PeerLogs: {
+                    Cloudwatch: { Enabled: this.enableNodeLogging },
+                },
+            },
+        };
+        const configureNodeLogSdkCall = {
+            service: 'ManagedBlockchain',
+            action: 'updateNode',
+            parameters: {
+                NetworkId: this.networkId,
+                MemberId: this.memberId,
+                NodeId: this.nodeId,
+                LogPublishingConfiguration: logPublishingConfiguration,
+            },
+            physicalResourceId: customresources.PhysicalResourceId.of('Id'),
+        };
+        new customresources.AwsCustomResource(this, 'ConfigureNodeLogResource', {
+            policy: sdkCallPolicy,
+            onCreate: configureNodeLogSdkCall,
+            onUpdate: configureNodeLogSdkCall,
+        });
+    }
+    /*
+     * Populate the output properties that must be fetched via SDK call; this function
+     * should be merged back into the constructor once the race condition is solved
+     */
+    fetchData(dataSdkCallPolicy) {
+        // This call doesn't really need all the permissions its using in the
+        // provided policy, but since the policy must be constructed all at once
+        // this is the only way to do it effectively
+        const nodeDataSdkCall = {
+            service: 'ManagedBlockchain',
+            action: 'getNode',
+            parameters: { NetworkId: this.networkId, MemberId: this.memberId, NodeId: this.nodeId },
+            physicalResourceId: customresources.PhysicalResourceId.of('Id'),
+        };
+        const nodeData = new customresources.AwsCustomResource(this, 'NodeDataResource', {
+            policy: dataSdkCallPolicy,
+            onCreate: nodeDataSdkCall,
+            onUpdate: nodeDataSdkCall,
+        });
+        // Grab items out of the above return values and stick them in output properties
+        this.endpoint = nodeData.getResponseField('Node.FrameworkAttributes.Fabric.PeerEndpoint');
+        this.eventEndpoint = nodeData.getResponseField('Node.FrameworkAttributes.Fabric.PeerEventEndpoint');
+    }
+}
+exports.HyperledgerFabricNode = HyperledgerFabricNode;
+_a = JSII_RTTI_SYMBOL_1;
+HyperledgerFabricNode[_a] = { fqn: "@cdklabs/cdk-hyperledger-fabric-network.HyperledgerFabricNode", version: "0.0.20" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node.js","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: MIT-0\n\n\nimport * as cdk from 'aws-cdk-lib';\nimport * as managedblockchain from 'aws-cdk-lib/aws-managedblockchain';\nimport * as customresources from 'aws-cdk-lib/custom-resources';\nimport * as constructs from 'constructs';\n\nimport * as network from './network';\nimport * as utilities from './utilities';\n\n\n/**\n * Supported instance types for Managed Blockchain nodes\n */\nexport enum InstanceType {\n  BURSTABLE3_SMALL = 'bc.t3.small',\n  BURSTABLE3_MEDIUM = 'bc.t3.medium',\n  BURSTABLE3_LARGE = 'bc.t3.large',\n  BURSTABLE3_XLARGE = 'bc.t3.xlarge',\n  STANDARD5_LARGE = 'bc.m5.large',\n  STANDARD5_XLARGE = 'bc.m5.xlarge',\n  STANDARD5_XLARGE2 = 'bc.m5.2xlarge',\n  STANDARD5_XLARGE4 = 'bc.m5.4xlarge',\n  COMPUTE5_LARGE = 'bc.c5.large',\n  COMPUTE5_XLARGE = 'bc.c5.xlarge',\n  COMPUTE5_XLARGE2 = 'bc.c5.2xlarge',\n  COMPUTE5_XLARGE4 = 'bc.c5.4xlarge',\n}\n\n\n/**\n * Valid instance types for starter networks\n */\nexport const STARTER_INSTANCE_TYPES = [\n  InstanceType.BURSTABLE3_SMALL,\n  InstanceType.BURSTABLE3_MEDIUM,\n];\n\n\n/**\n * Construct properties for `HyperledgerFabricNode`\n */\nexport interface HyperledgerFabricNodeProps {\n\n  /**\n   * The Availability Zone in which the node will be created\n   * @default - The first AZ in the region\n   */\n  readonly availabilityZone?: string;\n\n  /**\n   * The Amazon Managed Blockchain instance type for the node\n   * @default - BURSTABLE3_SMALL\n   */\n  readonly instanceType?: InstanceType;\n\n  /**\n   * The configuration to enable or disable chaincode logging\n   * @default - true\n   */\n  readonly enableChaincodeLogging?: boolean;\n\n  /**\n   * The configuration to enable or disable node logging\n   * @default - true\n   */\n  readonly enableNodeLogging?: boolean;\n\n}\n\n\n/**\n * Creates a Hyperledger Fabric node on an Amazon Managed Blockchain network\n */\nexport class HyperledgerFabricNode extends constructs.Construct {\n\n  /*\n   * Build out a list of HyperledgerFabricNode constructs given a list of input property\n   * objects; additionally checks to ensure node count is supported given the network type\n   */\n  public static constructNodes(scope: network.HyperledgerFabricNetwork, nodeProps?: Array<HyperledgerFabricNodeProps>) {\n    // If no node configurations are provided, create one; the empty object\n    // will be populated with defaults when passed to the node constructor\n    if (typeof nodeProps === 'undefined') nodeProps = [{}];\n    const starter = scope.networkEdition === network.NetworkEdition.STARTER;\n    if (starter && nodeProps.length > 2) {\n      throw new Error('A starter network can have at most 2 nodes per member.');\n    }\n    if (!starter && nodeProps.length > 3) {\n      throw new Error('A standard network can have at most 3 nodes per member.');\n    }\n    // Construct the node list, using an index value in the identifier\n    return Array.from(nodeProps.entries()).map(e => new HyperledgerFabricNode(scope, `Node${e[0]}`, e[1]));\n  }\n\n  /**\n   * Managed Blockchain network identifier\n   */\n  public readonly networkId: string;\n\n  /**\n   * Managed Blockchain member identifier\n   */\n  public readonly memberId: string;\n\n  /**\n   * Managed Blockchain node identifier generated on construction\n   */\n  public readonly nodeId: string;\n\n  /**\n   * The Availability Zone in which the node exists\n   */\n  public readonly availabilityZone: string;\n\n  /**\n   * The Amazon Managed Blockchain instance type for the node\n   */\n  public readonly instanceType: InstanceType;\n\n  /**\n   * The configuration to enable or disable chaincode logging\n   */\n  public readonly enableChaincodeLogging: boolean;\n\n  /**\n   * The configuration to enable or disable node logging\n   */\n  public readonly enableNodeLogging: boolean;\n\n  // These cannot be readonly since they have to be set after construction\n  // due the race condition documented in https://github.com/aws/aws-cdk/issues/18237.\n  public endpoint: string = '';\n  public eventEndpoint: string = '';\n\n  constructor(scope: network.HyperledgerFabricNetwork, id: string, props?: HyperledgerFabricNodeProps) {\n\n    super(scope, id);\n\n    // Collect metadata on the stack\n    const region = cdk.Stack.of(this).region;\n\n    // Populate instance variables from input properties, using defaults if values not provided\n    if (typeof props === 'undefined') props = {};\n    this.availabilityZone = props.availabilityZone ?? `${region}a`;\n    this.instanceType = props.instanceType ?? InstanceType.BURSTABLE3_SMALL;\n    this.enableChaincodeLogging = props.enableChaincodeLogging ?? true;\n    this.enableNodeLogging = props.enableNodeLogging ?? true;\n    this.networkId = scope.networkId;\n    this.memberId = scope.memberId;\n\n    // Ensure the parameters captured above are valid, so we don't\n    // need to wait until deployment time to discover an error\n    utilities.validateRegion(region);\n    utilities.validateAvailabilityZone(region, this.availabilityZone);\n    if (scope.networkEdition === network.NetworkEdition.STARTER && !STARTER_INSTANCE_TYPES.includes(this.instanceType)) {\n      const starterInstanceTypeList = STARTER_INSTANCE_TYPES.join(', ');\n      throw new Error(`Instance type in a starter network must be one of the following: ${starterInstanceTypeList}.`);\n    }\n\n    // Build out the Cloudformation construct for the network/member\n    const node = new managedblockchain.CfnNode(this, 'Node', {\n      networkId: this.networkId,\n      memberId: this.memberId,\n      nodeConfiguration: {\n        availabilityZone: this.availabilityZone,\n        instanceType: this.instanceType,\n      },\n    });\n\n    // Capture data included in the Cloudformation output in instance variables\n    this.nodeId = node.getAtt('NodeId').toString();\n\n  }\n\n  /*\n   * Configure logging for the node via SDK call; this function\n   * should be merged back into the constructor once the race condition is solved\n   */\n  public configureLogging(sdkCallPolicy: customresources.AwsCustomResourcePolicy) {\n\n    // This call doesn't really need all the permissions its using in the\n    // provided policy, but since the policy must be constructed all at once\n    // this is the only way to do it effectively\n    const logPublishingConfiguration = {\n      Fabric: {\n        ChaincodeLogs: {\n          Cloudwatch: { Enabled: this.enableChaincodeLogging },\n        },\n        PeerLogs: {\n          Cloudwatch: { Enabled: this.enableNodeLogging },\n        },\n      },\n    };\n    const configureNodeLogSdkCall = {\n      service: 'ManagedBlockchain',\n      action: 'updateNode',\n      parameters: {\n        NetworkId: this.networkId,\n        MemberId: this.memberId,\n        NodeId: this.nodeId,\n        LogPublishingConfiguration: logPublishingConfiguration,\n      },\n      physicalResourceId: customresources.PhysicalResourceId.of('Id'),\n    };\n    new customresources.AwsCustomResource(this, 'ConfigureNodeLogResource', {\n      policy: sdkCallPolicy,\n      onCreate: configureNodeLogSdkCall,\n      onUpdate: configureNodeLogSdkCall,\n    });\n  }\n\n  /*\n   * Populate the output properties that must be fetched via SDK call; this function\n   * should be merged back into the constructor once the race condition is solved\n   */\n  public fetchData(dataSdkCallPolicy: customresources.AwsCustomResourcePolicy) {\n\n    // This call doesn't really need all the permissions its using in the\n    // provided policy, but since the policy must be constructed all at once\n    // this is the only way to do it effectively\n    const nodeDataSdkCall = {\n      service: 'ManagedBlockchain',\n      action: 'getNode',\n      parameters: { NetworkId: this.networkId, MemberId: this.memberId, NodeId: this.nodeId },\n      physicalResourceId: customresources.PhysicalResourceId.of('Id'),\n    };\n    const nodeData = new customresources.AwsCustomResource(this, 'NodeDataResource', {\n      policy: dataSdkCallPolicy,\n      onCreate: nodeDataSdkCall,\n      onUpdate: nodeDataSdkCall,\n    });\n\n    // Grab items out of the above return values and stick them in output properties\n    this.endpoint = nodeData.getResponseField('Node.FrameworkAttributes.Fabric.PeerEndpoint');\n    this.eventEndpoint = nodeData.getResponseField('Node.FrameworkAttributes.Fabric.PeerEventEndpoint');\n\n  }\n\n}\n"]}

package/lib/user.d.ts

@@ -0,0 +1,40 @@
+import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
+import * as constructs from 'constructs';
+import * as network from './network';
+/**
+ * Construct properties for `HyperledgerFabricUser`
+ */
+export interface HyperledgerFabricUserProps {
+    /**
+     * User's affiliation to the member.
+     * Should be hierarchical with member name as root(`MemberName.Dept1`).
+     */
+    readonly affilitation: string;
+    /**
+     * User ID to register with CA
+     */
+    readonly userId: string;
+}
+/**
+ * Creates custom resources to register and enroll users identities
+ * with the CA using the fabric-ca-client SDK
+ */
+export declare class HyperledgerFabricUser extends constructs.Construct {
+    /**
+     * User ID registered with CA
+     */
+    readonly userId: string;
+    /**
+     * User's affiliation to the member
+     */
+    readonly affiliation: string;
+    /**
+     * Secret for user signed certificate
+     */
+    readonly userSignedCertSecret: secretsmanager.Secret;
+    /**
+     * Secret for user private key
+     */
+    readonly userPrivateKeySecret: secretsmanager.Secret;
+    constructor(scope: network.HyperledgerFabricNetwork, id: string, props: HyperledgerFabricUserProps);
+}

package/lib/user.js

@@ -0,0 +1,56 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperledgerFabricUser = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: MIT-0
+const cdk = require("aws-cdk-lib");
+const iam = require("aws-cdk-lib/aws-iam");
+const secretsmanager = require("aws-cdk-lib/aws-secretsmanager");
+const constructs = require("constructs");
+const identity = require("./identity");
+/**
+ * Creates custom resources to register and enroll users identities
+ * with the CA using the fabric-ca-client SDK
+ */
+class HyperledgerFabricUser extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        // Populate instance variables from input properties
+        this.userId = props.userId;
+        this.affiliation = props.affilitation;
+        // Get the custom resources from Identity Resources class
+        const customResourceRole = identity.HyperledgerFabricIdentity.customRole;
+        const registerProvider = identity.HyperledgerFabricIdentity.userProvider;
+        // Ensure the user affiliation includes the member name
+        if (!this.affiliation.startsWith(scope.memberName))
+            throw new Error('User affiliation is invalid. Affiliation should start with Member name');
+        // The user credentials will be stored in these secrets
+        const userPasswordSecret = new secretsmanager.Secret(this, `${this.userId}-Password`);
+        this.userPrivateKeySecret = new secretsmanager.Secret(this, `${this.userId}-PrivateKey`);
+        this.userSignedCertSecret = new secretsmanager.Secret(this, `${this.userId}-SignedCert`);
+        // Add secrets arn to the custom role
+        customResourceRole.addToPolicy(new iam.PolicyStatement({
+            actions: ['secretsmanager:PutSecretValue'],
+            resources: [
+                userPasswordSecret.secretArn,
+                this.userPrivateKeySecret.secretArn,
+                this.userSignedCertSecret.secretArn,
+            ],
+        }));
+        const userProp = {
+            userId: this.userId,
+            affiliation: this.affiliation,
+            passwordArn: userPasswordSecret.secretArn,
+            privateKeyArn: this.userPrivateKeySecret.secretArn,
+            signedCertArn: this.userSignedCertSecret.secretArn,
+        };
+        // Custom resource to enroll the admin identity using fabric client SDK
+        new cdk.CustomResource(this, `${this.userId}Resource`, { serviceToken: registerProvider.serviceToken, properties: userProp });
+    }
+}
+exports.HyperledgerFabricUser = HyperledgerFabricUser;
+_a = JSII_RTTI_SYMBOL_1;
+HyperledgerFabricUser[_a] = { fqn: "@cdklabs/cdk-hyperledger-fabric-network.HyperledgerFabricUser", version: "0.0.20" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utilities.d.ts

@@ -0,0 +1,12 @@
+export declare const SUPPORTED_REGIONS: string[];
+export declare const SUPPORTED_AVAILABILITY_ZONES: Record<string, Array<string>>;
+export declare const STARTING_PORT = 30001;
+export declare const ENDING_PORT = 30004;
+export declare function getTlsBucket(region: string): {
+    bucketName: string;
+    key: string;
+};
+export declare function validateRegion(region: string): void;
+export declare function validateAvailabilityZone(region: string, availabilityZone?: string): void;
+export declare function validateInteger(value: number, min: number, max: number): boolean;
+export declare function validateString(value: string, min: number, max: number, regexp?: RegExp | undefined): boolean;

package/lib/utilities.js

@@ -0,0 +1,116 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: MIT-0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateString = exports.validateInteger = exports.validateAvailabilityZone = exports.validateRegion = exports.getTlsBucket = exports.ENDING_PORT = exports.STARTING_PORT = exports.SUPPORTED_AVAILABILITY_ZONES = exports.SUPPORTED_REGIONS = void 0;
+/*
+ * Regions where Managed Blockchain is supported, for details see
+ * https://aws.amazon.com/managed-blockchain/pricing/hyperledger/
+ */
+exports.SUPPORTED_REGIONS = [
+    'ap-northeast-1',
+    'ap-northeast-2',
+    'ap-southeast-1',
+    'eu-west-1',
+    'eu-west-2',
+    'us-east-1',
+];
+/*
+ * Map of supported regions to their availability zones
+ */
+exports.SUPPORTED_AVAILABILITY_ZONES = {
+    'ap-northeast-1': [
+        'ap-northeast-1a',
+        'ap-northeast-1b',
+        'ap-northeast-1c',
+    ],
+    'ap-northeast-2': [
+        'ap-northeast-2a',
+        'ap-northeast-2b',
+        'ap-northeast-2c',
+        'ap-northeast-2d',
+    ],
+    'ap-southeast-1': [
+        'ap-southeast-1a',
+        'ap-southeast-1b',
+        'ap-southeast-1c',
+    ],
+    'eu-west-1': [
+        'eu-west-1a',
+        'eu-west-1b',
+        'eu-west-1c',
+    ],
+    'eu-west-2': [
+        'eu-west-2a',
+        'eu-west-2b',
+        'eu-west-2c',
+    ],
+    'us-east-1': [
+        'us-east-1a',
+        'us-east-1b',
+        'us-east-1c',
+        'us-east-1d',
+        'us-east-1e',
+        'us-east-1f',
+    ],
+};
+/*
+ * Starting port of the Network port range
+ */
+exports.STARTING_PORT = 30001;
+/*
+ * Ending port of the Network port range
+ */
+exports.ENDING_PORT = 30004;
+/*
+ * Returns the S3 Bucket and key that contains the TLS cert file
+ */
+function getTlsBucket(region) {
+    return { bucketName: `${region}.managedblockchain`, key: 'etc/managedblockchain-tls-chain.pem' };
+}
+exports.getTlsBucket = getTlsBucket;
+/*
+ * Throw an error if provided region is not in the supported list
+ */
+function validateRegion(region) {
+    if (!exports.SUPPORTED_REGIONS.includes(region)) {
+        const regionList = exports.SUPPORTED_REGIONS.join(', ');
+        throw new Error(`Managed Blockchain is only available in the following regions: ${regionList}.`);
+    }
+}
+exports.validateRegion = validateRegion;
+/*
+ * Throw an error if provided availability is not in the supported list
+ */
+function validateAvailabilityZone(region, availabilityZone) {
+    const availabililtyZonesForRegion = exports.SUPPORTED_AVAILABILITY_ZONES[region];
+    if (typeof availabilityZone === 'undefined' || !availabililtyZonesForRegion.includes(availabilityZone)) {
+        const availabilityZoneList = availabililtyZonesForRegion.join(', ');
+        throw new Error(`Managed Blockchain in ${region} is only available in the following availability zones: ${availabilityZoneList}.`);
+    }
+}
+exports.validateAvailabilityZone = validateAvailabilityZone;
+/*
+ * Throw an error if provided number is not an integer, or not with the given range (inclusive)
+ */
+function validateInteger(value, min, max) {
+    if (!Number.isInteger(value))
+        return false;
+    if (value < min || value > max)
+        return false;
+    return true;
+}
+exports.validateInteger = validateInteger;
+/*
+ * Throw an error if provided string has length with a given range (inclusive),
+ * and optionally matches a provided regular expression pattern
+ */
+function validateString(value, min, max, regexp) {
+    if (value.length < min || value.length > max)
+        return false;
+    if (typeof regexp !== 'undefined' && !value.match(regexp))
+        return false;
+    return true;
+}
+exports.validateString = validateString;
+//# sourceMappingURL=data:application/json;base64,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