token-injectable-docker-builder 1.13.4 → 2.0.0

package/lib/provider.js

@@ -0,0 +1,212 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenInjectableDockerBuilderProvider = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const custom_resources_1 = require("aws-cdk-lib/custom-resources");
+const constructs_1 = require("constructs");
+const constants_1 = require("./constants");
+const REPLICATION_TOTAL_TIMEOUT = aws_cdk_lib_1.Duration.hours(1);
+const REPLICATION_CR_ID = 'ReplicationConfig';
+const REPLICATION_FN_ID = 'ReplicationConfigHandler';
+// ECR registry replication caps (per registry / per AWS account):
+// https://docs.aws.amazon.com/AmazonECR/latest/userguide/replication.html
+const MAX_UNIQUE_DESTINATIONS = 25;
+const MAX_RULES = 10;
+/**
+ * Shared provider for `TokenInjectableDockerBuilder` instances.
+ *
+ * Creates the onEvent and isComplete Lambda functions once per stack.
+ * Each builder instance registers its CodeBuild project ARN so the
+ * shared Lambdas have permission to start builds and read logs.
+ */
+class TokenInjectableDockerBuilderProvider extends constructs_1.Construct {
+    /**
+     * Get or create the singleton provider for this stack.
+     * All `TokenInjectableDockerBuilder` instances in the same stack
+     * share a single pair of Lambda functions.
+     */
+    static getOrCreate(scope, props) {
+        const stack = aws_cdk_lib_1.Stack.of(scope);
+        const existing = stack.node.tryFindChild(constants_1.PROVIDER_SINGLETON_ID);
+        if (existing)
+            return existing;
+        return new TokenInjectableDockerBuilderProvider(stack, constants_1.PROVIDER_SINGLETON_ID, props);
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.replicationSpecs = [];
+        this.onEventHandlerFunction = new aws_lambda_1.Function(this, 'OnEventHandler', {
+            runtime: constants_1.LAMBDA_RUNTIME,
+            code: aws_lambda_1.Code.fromAsset(path.resolve(__dirname, '../onEvent')),
+            handler: 'onEvent.handler',
+            timeout: constants_1.LAMBDA_TIMEOUT,
+        });
+        this.onEventHandlerFunction.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: [
+                'logs:CreateLogGroup',
+                'logs:PutRetentionPolicy',
+                'logs:DeleteLogGroup',
+            ],
+            resources: [`arn:aws:logs:*:*:log-group:${constants_1.BUILD_LOG_GROUP_PREFIX}*`],
+        }));
+        this.isCompleteHandlerFunction = new aws_lambda_1.Function(this, 'IsCompleteHandler', {
+            runtime: constants_1.LAMBDA_RUNTIME,
+            code: aws_lambda_1.Code.fromAsset(path.resolve(__dirname, '../isComplete')),
+            handler: 'isComplete.handler',
+            timeout: constants_1.LAMBDA_TIMEOUT,
+        });
+        this.isCompleteHandlerFunction.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: [
+                'codebuild:BatchGetBuilds',
+                'codebuild:ListBuildsForProject',
+                'logs:GetLogEvents',
+                'logs:DescribeLogStreams',
+                'logs:DescribeLogGroups',
+            ],
+            resources: ['*'],
+        }));
+        const provider = new custom_resources_1.Provider(this, 'Provider', {
+            onEventHandler: this.onEventHandlerFunction,
+            isCompleteHandler: this.isCompleteHandlerFunction,
+            queryInterval: props?.queryInterval ?? constants_1.DEFAULT_QUERY_INTERVAL,
+            // ECR cross-region replication can take up to 30 min in rare cases.
+            // The default 30 min totalTimeout is too tight when a builder uses
+            // replicaRegions and isComplete is waiting for replicas to land.
+            totalTimeout: REPLICATION_TOTAL_TIMEOUT,
+        });
+        this.serviceToken = provider.serviceToken;
+    }
+    /**
+     * Grant the shared Lambdas permission to start builds for a specific
+     * CodeBuild project and pull/push to its ECR repository.
+     */
+    registerProject(project, ecrRepo, encryptionKey) {
+        this.onEventHandlerFunction.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: ['codebuild:StartBuild'],
+            resources: [project.projectArn],
+        }));
+        ecrRepo.grantPullPush(this.onEventHandlerFunction);
+        ecrRepo.grantPullPush(this.isCompleteHandlerFunction);
+        if (encryptionKey) {
+            encryptionKey.grantEncryptDecrypt(this.onEventHandlerFunction);
+            encryptionKey.grantEncryptDecrypt(this.isCompleteHandlerFunction);
+        }
+    }
+    /**
+     * Register a builder's replica regions with the singleton's replication-config
+     * custom resource. Multiple builders contribute specs; the CR merges them into
+     * a single registry-wide configuration on every deploy.
+     *
+     * Also grants the `isComplete` Lambda permission to BatchGetImage on each
+     * replica region's repo so it can poll for replication availability.
+     */
+    registerReplication(repoName, replicaRegions) {
+        if (replicaRegions.length === 0)
+            return;
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        const destinations = replicaRegions.map((r) => ({ region: r, registryId: stack.account }));
+        this.replicationSpecs.push({ repositoryName: repoName, destinations });
+        this.assertReplicationCapsWithinLimits();
+        // Grant isComplete BatchGetImage on every replica repo ARN so it can
+        // poll for the replicated image to appear.
+        this.isCompleteHandlerFunction.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: ['ecr:BatchGetImage', 'ecr:DescribeImages'],
+            resources: replicaRegions.map((r) => `arn:aws:ecr:${r}:${stack.account}:repository/${repoName}`),
+        }));
+        this.ensureReplicationCr();
+        // Refresh the CR's ManagedSpecs every time a builder registers. Custom
+        // resource update detection diffs ResourceProperties — a new value here
+        // triggers a CR update, which re-runs the merge in the replication Lambda.
+        if (this.replicationCr) {
+            const properties = this.replicationCr.node.defaultChild;
+            // CDK doesn't expose a public API to mutate CustomResource properties
+            // after creation. Instead we use addPropertyOverride to write the
+            // serialized state of all registered specs to date.
+            properties.addPropertyOverride('ManagedSpecs', JSON.stringify(this.replicationSpecs));
+        }
+    }
+    ensureReplicationCr() {
+        if (this.replicationCr)
+            return;
+        this.replicationFn = new aws_lambda_1.Function(this, REPLICATION_FN_ID, {
+            runtime: constants_1.LAMBDA_RUNTIME,
+            code: aws_lambda_1.Code.fromAsset(path.resolve(__dirname, '../ecrReplication')),
+            handler: 'ecrReplication.handler',
+            timeout: constants_1.LAMBDA_TIMEOUT,
+        });
+        this.replicationFn.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: [
+                'ecr:DescribeRegistry',
+                'ecr:PutReplicationConfiguration',
+            ],
+            resources: ['*'],
+        }));
+        // First-ever PutReplicationConfiguration in an account creates a
+        // service-linked role; idempotent if it already exists.
+        this.replicationFn.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: ['iam:CreateServiceLinkedRole'],
+            resources: ['*'],
+            conditions: {
+                StringEquals: {
+                    'iam:AWSServiceName': 'replication.ecr.amazonaws.com',
+                },
+            },
+        }));
+        const replicationProvider = new custom_resources_1.Provider(this, 'ReplicationProvider', {
+            onEventHandler: this.replicationFn,
+        });
+        this.replicationCr = new aws_cdk_lib_1.CustomResource(this, REPLICATION_CR_ID, {
+            serviceToken: replicationProvider.serviceToken,
+            resourceType: 'Custom::TidbReplicationConfig',
+            properties: {
+                ManagedSpecs: JSON.stringify(this.replicationSpecs),
+            },
+        });
+    }
+    /**
+     * Enforce ECR registry replication caps at synth time so users get a clear
+     * error before deploy. Caps are per-registry (per AWS account), not
+     * per-stack — but this construct can only see specs registered through
+     * its own singletons. Cross-stack/cross-app rules outside this construct
+     * are invisible here; the replication CR will still surface those at
+     * deploy time via the ECR API's own error.
+     */
+    assertReplicationCapsWithinLimits() {
+        const uniqueDestinations = new Set();
+        const uniqueDestinationSets = new Set();
+        for (const spec of this.replicationSpecs) {
+            for (const dest of spec.destinations) {
+                uniqueDestinations.add(`${dest.region}:${dest.registryId}`);
+            }
+            const setKey = spec.destinations
+                .map((d) => `${d.region}:${d.registryId}`)
+                .sort()
+                .join('|');
+            uniqueDestinationSets.add(setKey);
+        }
+        if (uniqueDestinations.size > MAX_UNIQUE_DESTINATIONS) {
+            throw new Error(`ECR registry replication supports at most ${MAX_UNIQUE_DESTINATIONS} unique ` +
+                'destinations across all rules per AWS account, but this stack would create ' +
+                `${uniqueDestinations.size}. Reduce the union of replicaRegions across all ` +
+                'TokenInjectableDockerBuilder instances. (Limit is per-registry / per-account, ' +
+                'so other stacks in the same account count too — but only specs registered ' +
+                'through this construct are visible at synth time.)');
+        }
+        if (uniqueDestinationSets.size > MAX_RULES) {
+            throw new Error(`ECR registry replication supports at most ${MAX_RULES} rules per registry. ` +
+                'The construct groups builders by their destination set into one rule each, ' +
+                `but this stack has ${uniqueDestinationSets.size} unique destination sets. ` +
+                'Consolidate builders to share destination sets (i.e. give them the same ' +
+                'replicaRegions) so they share a rule.');
+        }
+    }
+}
+exports.TokenInjectableDockerBuilderProvider = TokenInjectableDockerBuilderProvider;
+_a = JSII_RTTI_SYMBOL_1;
+TokenInjectableDockerBuilderProvider[_a] = { fqn: "token-injectable-docker-builder.TokenInjectableDockerBuilderProvider", version: "2.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.js","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\n\nimport { CustomResource, Duration, Stack } from 'aws-cdk-lib';\nimport { Project } from 'aws-cdk-lib/aws-codebuild';\nimport { Repository } from 'aws-cdk-lib/aws-ecr';\nimport { PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { Key } from 'aws-cdk-lib/aws-kms';\nimport { Code, Function } from 'aws-cdk-lib/aws-lambda';\nimport { Provider } from 'aws-cdk-lib/custom-resources';\nimport { Construct } from 'constructs';\n\nimport {\n  BUILD_LOG_GROUP_PREFIX,\n  DEFAULT_QUERY_INTERVAL,\n  LAMBDA_RUNTIME,\n  LAMBDA_TIMEOUT,\n  PROVIDER_SINGLETON_ID,\n} from './constants';\n\nconst REPLICATION_TOTAL_TIMEOUT = Duration.hours(1);\nconst REPLICATION_CR_ID = 'ReplicationConfig';\nconst REPLICATION_FN_ID = 'ReplicationConfigHandler';\n\n// ECR registry replication caps (per registry / per AWS account):\n// https://docs.aws.amazon.com/AmazonECR/latest/userguide/replication.html\nconst MAX_UNIQUE_DESTINATIONS = 25;\nconst MAX_RULES = 10;\n\n/**\n * Options for creating a `TokenInjectableDockerBuilderProvider`.\n */\nexport interface TokenInjectableDockerBuilderProviderProps {\n  /**\n   * How often the provider polls for build completion.\n   *\n   * @default Duration.seconds(30)\n   */\n  readonly queryInterval?: Duration;\n}\n\n/**\n * Shared provider for `TokenInjectableDockerBuilder` instances.\n *\n * Creates the onEvent and isComplete Lambda functions once per stack.\n * Each builder instance registers its CodeBuild project ARN so the\n * shared Lambdas have permission to start builds and read logs.\n */\nexport class TokenInjectableDockerBuilderProvider extends Construct {\n  /**\n   * Get or create the singleton provider for this stack.\n   * All `TokenInjectableDockerBuilder` instances in the same stack\n   * share a single pair of Lambda functions.\n   */\n  public static getOrCreate(\n    scope: Construct,\n    props?: TokenInjectableDockerBuilderProviderProps,\n  ): TokenInjectableDockerBuilderProvider {\n    const stack = Stack.of(scope);\n    const existing = stack.node.tryFindChild(PROVIDER_SINGLETON_ID) as\n      | TokenInjectableDockerBuilderProvider\n      | undefined;\n    if (existing) return existing;\n    return new TokenInjectableDockerBuilderProvider(stack, PROVIDER_SINGLETON_ID, props);\n  }\n\n  /** The service token used by CustomResource instances. */\n  public readonly serviceToken: string;\n\n  private readonly onEventHandlerFunction: Function;\n  private readonly isCompleteHandlerFunction: Function;\n\n  // Replication-config CR is created lazily on first registerReplication call.\n  private replicationFn?: Function;\n  private replicationCr?: CustomResource;\n  private readonly replicationSpecs: Array<{ repositoryName: string; destinations: Array<{ region: string; registryId: string }> }> = [];\n\n  private constructor(\n    scope: Construct,\n    id: string,\n    props?: TokenInjectableDockerBuilderProviderProps,\n  ) {\n    super(scope, id);\n\n    this.onEventHandlerFunction = new Function(this, 'OnEventHandler', {\n      runtime: LAMBDA_RUNTIME,\n      code: Code.fromAsset(path.resolve(__dirname, '../onEvent')),\n      handler: 'onEvent.handler',\n      timeout: LAMBDA_TIMEOUT,\n    });\n    this.onEventHandlerFunction.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\n          'logs:CreateLogGroup',\n          'logs:PutRetentionPolicy',\n          'logs:DeleteLogGroup',\n        ],\n        resources: [`arn:aws:logs:*:*:log-group:${BUILD_LOG_GROUP_PREFIX}*`],\n      }),\n    );\n\n    this.isCompleteHandlerFunction = new Function(this, 'IsCompleteHandler', {\n      runtime: LAMBDA_RUNTIME,\n      code: Code.fromAsset(path.resolve(__dirname, '../isComplete')),\n      handler: 'isComplete.handler',\n      timeout: LAMBDA_TIMEOUT,\n    });\n    this.isCompleteHandlerFunction.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\n          'codebuild:BatchGetBuilds',\n          'codebuild:ListBuildsForProject',\n          'logs:GetLogEvents',\n          'logs:DescribeLogStreams',\n          'logs:DescribeLogGroups',\n        ],\n        resources: ['*'],\n      }),\n    );\n\n    const provider = new Provider(this, 'Provider', {\n      onEventHandler: this.onEventHandlerFunction,\n      isCompleteHandler: this.isCompleteHandlerFunction,\n      queryInterval: props?.queryInterval ?? DEFAULT_QUERY_INTERVAL,\n      // ECR cross-region replication can take up to 30 min in rare cases.\n      // The default 30 min totalTimeout is too tight when a builder uses\n      // replicaRegions and isComplete is waiting for replicas to land.\n      totalTimeout: REPLICATION_TOTAL_TIMEOUT,\n    });\n\n    this.serviceToken = provider.serviceToken;\n  }\n\n  /**\n   * Grant the shared Lambdas permission to start builds for a specific\n   * CodeBuild project and pull/push to its ECR repository.\n   */\n  public registerProject(project: Project, ecrRepo: Repository, encryptionKey?: Key): void {\n    this.onEventHandlerFunction.addToRolePolicy(\n      new PolicyStatement({\n        actions: ['codebuild:StartBuild'],\n        resources: [project.projectArn],\n      }),\n    );\n    ecrRepo.grantPullPush(this.onEventHandlerFunction);\n    ecrRepo.grantPullPush(this.isCompleteHandlerFunction);\n\n    if (encryptionKey) {\n      encryptionKey.grantEncryptDecrypt(this.onEventHandlerFunction);\n      encryptionKey.grantEncryptDecrypt(this.isCompleteHandlerFunction);\n    }\n  }\n\n  /**\n   * Register a builder's replica regions with the singleton's replication-config\n   * custom resource. Multiple builders contribute specs; the CR merges them into\n   * a single registry-wide configuration on every deploy.\n   *\n   * Also grants the `isComplete` Lambda permission to BatchGetImage on each\n   * replica region's repo so it can poll for replication availability.\n   */\n  public registerReplication(repoName: string, replicaRegions: string[]): void {\n    if (replicaRegions.length === 0) return;\n    const stack = Stack.of(this);\n    const destinations = replicaRegions.map((r) => ({ region: r, registryId: stack.account }));\n    this.replicationSpecs.push({ repositoryName: repoName, destinations });\n\n    this.assertReplicationCapsWithinLimits();\n\n    // Grant isComplete BatchGetImage on every replica repo ARN so it can\n    // poll for the replicated image to appear.\n    this.isCompleteHandlerFunction.addToRolePolicy(\n      new PolicyStatement({\n        actions: ['ecr:BatchGetImage', 'ecr:DescribeImages'],\n        resources: replicaRegions.map(\n          (r) => `arn:aws:ecr:${r}:${stack.account}:repository/${repoName}`,\n        ),\n      }),\n    );\n\n    this.ensureReplicationCr();\n\n    // Refresh the CR's ManagedSpecs every time a builder registers. Custom\n    // resource update detection diffs ResourceProperties — a new value here\n    // triggers a CR update, which re-runs the merge in the replication Lambda.\n    if (this.replicationCr) {\n      const properties = (this.replicationCr.node.defaultChild as any);\n      // CDK doesn't expose a public API to mutate CustomResource properties\n      // after creation. Instead we use addPropertyOverride to write the\n      // serialized state of all registered specs to date.\n      properties.addPropertyOverride(\n        'ManagedSpecs',\n        JSON.stringify(this.replicationSpecs),\n      );\n    }\n  }\n\n  private ensureReplicationCr(): void {\n    if (this.replicationCr) return;\n\n    this.replicationFn = new Function(this, REPLICATION_FN_ID, {\n      runtime: LAMBDA_RUNTIME,\n      code: Code.fromAsset(path.resolve(__dirname, '../ecrReplication')),\n      handler: 'ecrReplication.handler',\n      timeout: LAMBDA_TIMEOUT,\n    });\n    this.replicationFn.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\n          'ecr:DescribeRegistry',\n          'ecr:PutReplicationConfiguration',\n        ],\n        resources: ['*'],\n      }),\n    );\n    // First-ever PutReplicationConfiguration in an account creates a\n    // service-linked role; idempotent if it already exists.\n    this.replicationFn.addToRolePolicy(\n      new PolicyStatement({\n        actions: ['iam:CreateServiceLinkedRole'],\n        resources: ['*'],\n        conditions: {\n          StringEquals: {\n            'iam:AWSServiceName': 'replication.ecr.amazonaws.com',\n          },\n        },\n      }),\n    );\n\n    const replicationProvider = new Provider(this, 'ReplicationProvider', {\n      onEventHandler: this.replicationFn,\n    });\n\n    this.replicationCr = new CustomResource(this, REPLICATION_CR_ID, {\n      serviceToken: replicationProvider.serviceToken,\n      resourceType: 'Custom::TidbReplicationConfig',\n      properties: {\n        ManagedSpecs: JSON.stringify(this.replicationSpecs),\n      },\n    });\n  }\n\n  /**\n   * Enforce ECR registry replication caps at synth time so users get a clear\n   * error before deploy. Caps are per-registry (per AWS account), not\n   * per-stack — but this construct can only see specs registered through\n   * its own singletons. Cross-stack/cross-app rules outside this construct\n   * are invisible here; the replication CR will still surface those at\n   * deploy time via the ECR API's own error.\n   */\n  private assertReplicationCapsWithinLimits(): void {\n    const uniqueDestinations = new Set<string>();\n    const uniqueDestinationSets = new Set<string>();\n    for (const spec of this.replicationSpecs) {\n      for (const dest of spec.destinations) {\n        uniqueDestinations.add(`${dest.region}:${dest.registryId}`);\n      }\n      const setKey = spec.destinations\n        .map((d) => `${d.region}:${d.registryId}`)\n        .sort()\n        .join('|');\n      uniqueDestinationSets.add(setKey);\n    }\n\n    if (uniqueDestinations.size > MAX_UNIQUE_DESTINATIONS) {\n      throw new Error(\n        `ECR registry replication supports at most ${MAX_UNIQUE_DESTINATIONS} unique ` +\n        'destinations across all rules per AWS account, but this stack would create ' +\n        `${uniqueDestinations.size}. Reduce the union of replicaRegions across all ` +\n        'TokenInjectableDockerBuilder instances. (Limit is per-registry / per-account, ' +\n        'so other stacks in the same account count too — but only specs registered ' +\n        'through this construct are visible at synth time.)',\n      );\n    }\n\n    if (uniqueDestinationSets.size > MAX_RULES) {\n      throw new Error(\n        `ECR registry replication supports at most ${MAX_RULES} rules per registry. ` +\n        'The construct groups builders by their destination set into one rule each, ' +\n        `but this stack has ${uniqueDestinationSets.size} unique destination sets. ` +\n        'Consolidate builders to share destination sets (i.e. give them the same ' +\n        'replicaRegions) so they share a rule.',\n      );\n    }\n  }\n}\n"]}

package/package.json

@@ -29,10 +29,12 @@
     "upgrade": "npx projen upgrade",
     "watch": "npx projen watch",
     "projen": "npx projen",
-    "local-deploy": "npx cdk deploy --app \"npx ts-node src/integ.default.ts\"",
-    "local-deploy-no-rollback": "npx cdk deploy --no-rollback --app \"npx ts-node src/integ.default.ts\"",
-    "local-destroy": "npx cdk destroy --app \"npx ts-node src/integ.default.ts\"",
-    "local-synth": "npx cdk synth --app \"npx ts-node src/integ.default.ts\""
+    "local-deploy": "npx cdk deploy --all --app \"npx ts-node test/integ.default.ts\"",
+    "local-deploy-no-rollback": "npx cdk deploy --all --no-rollback --app \"npx ts-node test/integ.default.ts\"",
+    "local-destroy": "npx cdk destroy --all --app \"npx ts-node test/integ.default.ts\"",
+    "local-synth": "npx cdk synth --app \"npx ts-node test/integ.default.ts\"",
+    "integ": "npx integ-runner --update-on-failed --directory test",
+    "integ-migration": "npx cdk deploy TidbMigrationStack --app \"npx ts-node test/migration/before-v1.ts\" --require-approval=never && npx cdk deploy TidbMigrationStack --app \"npx ts-node test/migration/after-v2.ts\" --require-approval=never && npx cdk destroy TidbMigrationStack --app \"npx ts-node test/migration/after-v2.ts\" --force"
   },
   "author": {
     "name": "AlexTech314",
@@ -40,6 +42,8 @@
     "organization": false
   },
   "devDependencies": {
+    "@aws-cdk/integ-runner": "^2.197.0",
+    "@aws-cdk/integ-tests-alpha": "2.238.0-alpha.0",
     "@stylistic/eslint-plugin": "^2",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.19.15",
@@ -59,6 +63,7 @@
     "jsii-pacmak": "^1.127.0",
     "jsii-rosetta": "~5.9.27",
     "projen": "^0.99.25",
+    "token-injectable-docker-builder-v1": "npm:token-injectable-docker-builder@^1.13.0",
     "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
@@ -98,7 +103,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.13.4",
+  "version": "2.0.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [