@glicogh/healthcare-cdk 0.1.87 → 0.1.89

package/.env.example

@@ -13,6 +13,10 @@ EC2_MYSQL_INSTANCE_TYPE=t4g.nano
 EC2_MYSQL_INSTANCE_STORAGE_SIZE=10
 EC2_MYSQL_INSTANCE_STORAGE_TYPE=gp3
 
+EC2_CLICKHOUSE_INSTANCE_TYPE=t4g.nano
+EC2_CLICKHOUSE_INSTANCE_STORAGE_SIZE=50
+EC2_CLICKHOUSE_INSTANCE_STORAGE_TYPE=gp3
+
 EC2_API_GATEWAY_INSTANCE_TYPE=t4g.nano
 EC2_API_GATEWAY_INSTANCE_STORAGE_SIZE=
 EC2_API_GATEWAY_INSTANCE_STORAGE_TYPE=gp3

package/README.md

@@ -77,6 +77,7 @@ The output looks like this
 MicroserviceNetwork
 MicroserviceRedis
 MicroserviceMySQL
+MicroserviceClickHouse
 ```
 
 ## Running the CDK
@@ -89,13 +90,69 @@ The following stack are meant to be deployed once and shared across the microser
 - MicroserviceInfraAuth
 - MicroserviceRedis
 - MicroserviceMySQL
+- MicroserviceClickHouse
+- MicroserviceMigration
 
-The only required option for these stack is `env`. For example, to deploy `MicroserviceNetwork` in the UAT environment, you would run the command
+The only required option for these stacks is `env`. To deploy a single shared stack, pass its `service` value:
+
+| Stack                  | `service`    |
+| ---------------------- | ------------ |
+| MicroserviceNetwork    | `network`    |
+| MicroserviceInfraAuth  | `infra-auth` |
+| MicroserviceRedis      | `redis`      |
+| MicroserviceMySQL      | `mysql`      |
+| MicroserviceClickHouse | `clickhouse` |
+| MicroserviceMigration  | `migration`  |
+
+For example, to deploy `MicroserviceNetwork` in the UAT environment, you would run the command
+
+```
+cdk --profile glicogh-uat --context env=uat --context service=network deploy
+```
+
+Only the selected stack is synthesized, so unrelated stacks (and their code assets, such as the migration Lambdas) are not bundled. Omitting `service` synthesizes and deploys all shared stacks. Alternatively, when deploying by stack name (`cdk --context env=uat deploy MicroserviceNetwork`), pass `--exclusively` to `synth`/`deploy`/`diff` to skip bundling unrelated stacks.
+
+### Migration orchestrator (MicroserviceMigration)
+
+`MicroserviceMigration` bundles the migration producer/consumer Lambdas (from the sibling `migration/lambdas` directory), the `migration-queue.fifo` queue, a `migration-verifier` Lambda, an S3 artifacts bucket, a one-shot ECS Fargate scripts runner, and the `migration-orchestrator` Step Function (`cdk/constructs/migration-state-machine.ts`). Invoking the state machine runs the migration runbook end-to-end:
+
+- **Scripts (runbook Steps 1–4)** run as one-shot ECS Fargate tasks from the migration repo's `Dockerfile` (entrypoint dispatches `restore` / `migrations` / `diseases` / `claim-batches` / `reset`). The restore task syncs the legacy dump from S3 first; no 15-minute Lambda cap.
+- **Migratables (Steps 5–16)** loop the producer Lambda until the response reports `endReached: true`, then wait for the SQS queue to drain (`ApproximateNumberOfMessages` + `NotVisible` = 0) before the next dependency step. Tier 0 (users, providers, insured, tpa, plans) runs as a `Parallel`.
+- **Every resource gets a retry pass** (`fromStart: true, skipMigrated: true`) after the first pass + drain, recovering records dropped by transient service failures.
+- **Verification** invokes the verifier Lambda, which writes `runs/<execution-name>/summary.json` (migrated counts, source counts, API totals) to the artifacts bucket.
+
+**Prerequisites**: deploy the shared stacks (the migration stack alone with `cdk --profile glicogh-uat --context env=uat --context service=migration deploy`); upload the legacy dump to the artifacts bucket (`glicogh-healthcare-migration-<env>-<account>`):
 
 ```
-cdk --profile glicogh-uat --context env=uat deploy MicroserviceNetwork
+aws s3 sync data/legacy-backup s3://glicogh-healthcare-migration-uat-825765383017/backups/<runId>/
 ```
 
+**Start an execution** (all input fields are required; `fromStep` uses the step ids below, `""` = full run):
+
+```json
+{
+  "backupS3Uri": "s3://glicogh-healthcare-migration-uat-825765383017/backups/<runId>/",
+  "fresh": false,
+  "skipPhotos": false,
+  "fromStep": ""
+}
+```
+
+```
+aws stepfunctions start-execution \
+  --state-machine-arn <state-machine-arn> \
+  --name <runId> \
+  --input file://input.json
+```
+
+Step ids for `fromStep`: `fresh-reset`, `restore`, `migrations`, `diseases`, `claim-batches`, `product-sources`, `product-categories`, `products`, `categories`, `coverage-groups`, `tier0`, `product-pricing`, `policies`, `benefits`, `plans-rewire`, `beneficiaries-principals`, `beneficiaries-dependants`, `beneficiary-photos`, `claims`.
+
+**Pause/resume**: every step is idempotent and cursor-backed — stop the execution and re-invoke later (optionally with `fromStep`). Completed resources no-op on the first producer invocation (`endReached` immediately). Guards fail the execution instead of looping forever: 2,000 producer invocations per pass, 600 drain checks (5-minute interval). Execution timeout 7 days.
+
+**Monitoring**: Step Functions execution history; state-machine logs at `/aws/vendedlogs/states/migration-orchestrator`; ECS task logs under `/aws/ecs/migration-scripts`; the verifier summary in S3.
+
+**Notes**: the consumer's reserved concurrency is set to `max(50, MIGRATION_QUEUE_SHARDS)` so claims FIFO shards run in parallel. `fresh: true` truncates `migrated`/`disease_lookup`/`claim_batches` and clears the `glico_healthcare_migration:*` Redis cursors before restoring; the restore task re-imports all tables per run (container-local tracking). Secure envs (`DB_PASSWORD`, `MIGRATION_API_KEY`) are injected into the ECS task from SSM.
+
 ### Pipeline-based stack
 
 The following stack on the other hand, are meant to deploy a new set of resources on each CDK deployment. These can also be thought of as the stack that have a GIT repository.

package/dist/@types/common.d.ts

@@ -16,7 +16,7 @@ export type BuildConfig = {
     };
 };
 export type Microservice = 'account' | 'plan' | 'policy' | 'claims' | 'notification' | 'reporting';
-export type OtherCDKService = 'network' | 'api-gateway' | 'redis' | 'mysql' | 'portal' | 'migration';
+export type OtherCDKService = 'network' | 'infra-auth' | 'api-gateway' | 'redis' | 'mysql' | 'clickhouse' | 'portal' | 'migration';
 export declare const MicroserviceEnum: Record<Microservice, Microservice>;
 export declare const MicroserviceList: Microservice[];
 export declare const LaravelBasedServiceList: ("account" | "plan" | "policy" | "claims" | "reporting")[];

package/dist/@types/common.js

@@ -13,11 +13,13 @@ exports.MicroserviceList = Object.values(exports.MicroserviceEnum);
 exports.LaravelBasedServiceList = exports.MicroserviceList.filter((i) => i !== 'notification');
 exports.OtherCDKServiceEnum = {
     network: 'network',
+    'infra-auth': 'infra-auth',
     'api-gateway': 'api-gateway',
     redis: 'redis',
     mysql: 'mysql',
+    clickhouse: 'clickhouse',
     portal: 'portal',
     migration: 'migration',
 };
 exports.OtherCDKServiceList = Object.values(exports.OtherCDKServiceEnum);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/constructs/migration-scripts-runner.d.ts

@@ -0,0 +1,19 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import { Construct } from 'constructs';
+export interface MigrationScriptsRunnerProps {
+    vpc: ec2.IVpc;
+    artifactsBucket: s3.IBucket;
+    backupPrefix?: string;
+    cpu?: number;
+    memoryLimitMiB?: number;
+    ephemeralStorageGiB?: number;
+}
+export declare class MigrationScriptsRunner extends Construct {
+    readonly cluster: ecs.Cluster;
+    readonly securityGroup: ec2.SecurityGroup;
+    readonly taskDefinition: ecs.FargateTaskDefinition;
+    readonly container: ecs.ContainerDefinition;
+    constructor(scope: Construct, id: string, props: MigrationScriptsRunnerProps);
+}

package/dist/constructs/migration-scripts-runner.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationScriptsRunner = void 0;
+const cdk = require("aws-cdk-lib");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+const ecs = require("aws-cdk-lib/aws-ecs");
+const logs = require("aws-cdk-lib/aws-logs");
+const path = require("path");
+const constructs_1 = require("constructs");
+const migration_1 = require("../util/migration");
+// One-shot Fargate tasks that run the migration scripts (restore, migrations,
+// precompute-diseases, precompute-claim-batches, reset) unchanged. The state
+// machine overrides the container command per step.
+class MigrationScriptsRunner extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.cluster = new ecs.Cluster(this, 'Cluster', {
+            vpc: props.vpc,
+            clusterName: 'migration-scripts',
+        });
+        this.securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {
+            vpc: props.vpc,
+            securityGroupName: 'Migration-Scripts-SG',
+            description: 'Migration scripts ECS tasks',
+            allowAllOutbound: true,
+        });
+        this.taskDefinition = new ecs.FargateTaskDefinition(this, 'TaskDefinition', {
+            family: 'migration-scripts',
+            cpu: props.cpu ?? 4096,
+            memoryLimitMiB: props.memoryLimitMiB ?? 8192,
+            ephemeralStorageGiB: props.ephemeralStorageGiB ?? 21,
+            runtimePlatform: {
+                cpuArchitecture: ecs.CpuArchitecture.X86_64,
+                operatingSystemFamily: ecs.OperatingSystemFamily.LINUX,
+            },
+        });
+        const { environment, secrets } = (0, migration_1.getEcsEnvs)(cdk.Stack.of(this));
+        this.container = this.taskDefinition.addContainer('scripts', {
+            containerName: 'scripts',
+            image: ecs.ContainerImage.fromAsset(path.resolve('../../migration'), { file: 'Dockerfile' }),
+            environment,
+            secrets,
+            logging: ecs.LogDrivers.awsLogs({
+                streamPrefix: 'migration-scripts',
+                logRetention: logs.RetentionDays.ONE_MONTH,
+            }),
+        });
+        props.artifactsBucket.grantRead(this.taskDefinition.taskRole, `${props.backupPrefix ?? 'backups'}/*`);
+    }
+}
+exports.MigrationScriptsRunner = MigrationScriptsRunner;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlncmF0aW9uLXNjcmlwdHMtcnVubmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vY29uc3RydWN0cy9taWdyYXRpb24tc2NyaXB0cy1ydW5uZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQW1DO0FBQ25DLDJDQUEyQztBQUMzQywyQ0FBMkM7QUFDM0MsNkNBQTZDO0FBRTdDLDZCQUE2QjtBQUM3QiwyQ0FBdUM7QUFDdkMsaURBQStDO0FBVy9DLDhFQUE4RTtBQUM5RSw2RUFBNkU7QUFDN0Usb0RBQW9EO0FBQ3BELE1BQWEsc0JBQXVCLFNBQVEsc0JBQVM7SUFNbkQsWUFBWSxLQUFnQixFQUFFLEVBQVUsRUFBRSxLQUFrQztRQUMxRSxLQUFLLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRWpCLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxHQUFHLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxTQUFTLEVBQUU7WUFDOUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxHQUFHO1lBQ2QsV0FBVyxFQUFFLG1CQUFtQjtTQUNqQyxDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsYUFBYSxHQUFHLElBQUksR0FBRyxDQUFDLGFBQWEsQ0FBQyxJQUFJLEVBQUUsZUFBZSxFQUFFO1lBQ2hFLEdBQUcsRUFBRSxLQUFLLENBQUMsR0FBRztZQUNkLGlCQUFpQixFQUFFLHNCQUFzQjtZQUN6QyxXQUFXLEVBQUUsNkJBQTZCO1lBQzFDLGdCQUFnQixFQUFFLElBQUk7U0FDdkIsQ0FBQyxDQUFDO1FBRUgsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLEdBQUcsQ0FBQyxxQkFBcUIsQ0FBQyxJQUFJLEVBQUUsZ0JBQWdCLEVBQUU7WUFDMUUsTUFBTSxFQUFFLG1CQUFtQjtZQUMzQixHQUFHLEVBQUUsS0FBSyxDQUFDLEdBQUcsSUFBSSxJQUFJO1lBQ3RCLGNBQWMsRUFBRSxLQUFLLENBQUMsY0FBYyxJQUFJLElBQUk7WUFDNUMsbUJBQW1CLEVBQUUsS0FBSyxDQUFDLG1CQUFtQixJQUFJLEVBQUU7WUFDcEQsZUFBZSxFQUFFO2dCQUNmLGVBQWUsRUFBRSxHQUFHLENBQUMsZUFBZSxDQUFDLE1BQU07Z0JBQzNDLHFCQUFxQixFQUFFLEdBQUcsQ0FBQyxxQkFBcUIsQ0FBQyxLQUFLO2FBQ3ZEO1NBQ0YsQ0FBQyxDQUFDO1FBRUgsTUFBTSxFQUFFLFdBQVcsRUFBRSxPQUFPLEVBQUUsR0FBRyxJQUFBLHNCQUFVLEVBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUVoRSxJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxjQUFjLENBQUMsWUFBWSxDQUFDLFNBQVMsRUFBRTtZQUMzRCxhQUFhLEVBQUUsU0FBUztZQUN4QixLQUFLLEVBQUUsR0FBRyxDQUFDLGNBQWMsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBQyxFQUFFLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSxDQUFDO1lBQzVGLFdBQVc7WUFDWCxPQUFPO1lBQ1AsT0FBTyxFQUFFLEdBQUcsQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDO2dCQUM5QixZQUFZLEVBQUUsbUJBQW1CO2dCQUNqQyxZQUFZLEVBQUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxTQUFTO2FBQzNDLENBQUM7U0FDSCxDQUFDLENBQUM7UUFFSCxLQUFLLENBQUMsZUFBZSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLFFBQVEsRUFBRSxHQUFHLEtBQUssQ0FBQyxZQUFZLElBQUksU0FBUyxJQUFJLENBQUMsQ0FBQztJQUN4RyxDQUFDO0NBQ0Y7QUEvQ0Qsd0RBK0NDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgY2RrIGZyb20gJ2F3cy1jZGstbGliJztcbmltcG9ydCAqIGFzIGVjMiBmcm9tICdhd3MtY2RrLWxpYi9hd3MtZWMyJztcbmltcG9ydCAqIGFzIGVjcyBmcm9tICdhd3MtY2RrLWxpYi9hd3MtZWNzJztcbmltcG9ydCAqIGFzIGxvZ3MgZnJvbSAnYXdzLWNkay1saWIvYXdzLWxvZ3MnO1xuaW1wb3J0ICogYXMgczMgZnJvbSAnYXdzLWNkay1saWIvYXdzLXMzJztcbmltcG9ydCAqIGFzIHBhdGggZnJvbSAncGF0aCc7XG5pbXBvcnQgeyBDb25zdHJ1Y3QgfSBmcm9tICdjb25zdHJ1Y3RzJztcbmltcG9ydCB7IGdldEVjc0VudnMgfSBmcm9tICcuLi91dGlsL21pZ3JhdGlvbic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTWlncmF0aW9uU2NyaXB0c1J1bm5lclByb3BzIHtcbiAgdnBjOiBlYzIuSVZwYztcbiAgYXJ0aWZhY3RzQnVja2V0OiBzMy5JQnVja2V0O1xuICBiYWNrdXBQcmVmaXg/OiBzdHJpbmc7XG4gIGNwdT86IG51bWJlcjtcbiAgbWVtb3J5TGltaXRNaUI/OiBudW1iZXI7XG4gIGVwaGVtZXJhbFN0b3JhZ2VHaUI/OiBudW1iZXI7XG59XG5cbi8vIE9uZS1zaG90IEZhcmdhdGUgdGFza3MgdGhhdCBydW4gdGhlIG1pZ3JhdGlvbiBzY3JpcHRzIChyZXN0b3JlLCBtaWdyYXRpb25zLFxuLy8gcHJlY29tcHV0ZS1kaXNlYXNlcywgcHJlY29tcHV0ZS1jbGFpbS1iYXRjaGVzLCByZXNldCkgdW5jaGFuZ2VkLiBUaGUgc3RhdGVcbi8vIG1hY2hpbmUgb3ZlcnJpZGVzIHRoZSBjb250YWluZXIgY29tbWFuZCBwZXIgc3RlcC5cbmV4cG9ydCBjbGFzcyBNaWdyYXRpb25TY3JpcHRzUnVubmVyIGV4dGVuZHMgQ29uc3RydWN0IHtcbiAgcHVibGljIHJlYWRvbmx5IGNsdXN0ZXI6IGVjcy5DbHVzdGVyO1xuICBwdWJsaWMgcmVhZG9ubHkgc2VjdXJpdHlHcm91cDogZWMyLlNlY3VyaXR5R3JvdXA7XG4gIHB1YmxpYyByZWFkb25seSB0YXNrRGVmaW5pdGlvbjogZWNzLkZhcmdhdGVUYXNrRGVmaW5pdGlvbjtcbiAgcHVibGljIHJlYWRvbmx5IGNvbnRhaW5lcjogZWNzLkNvbnRhaW5lckRlZmluaXRpb247XG5cbiAgY29uc3RydWN0b3Ioc2NvcGU6IENvbnN0cnVjdCwgaWQ6IHN0cmluZywgcHJvcHM6IE1pZ3JhdGlvblNjcmlwdHNSdW5uZXJQcm9wcykge1xuICAgIHN1cGVyKHNjb3BlLCBpZCk7XG5cbiAgICB0aGlzLmNsdXN0ZXIgPSBuZXcgZWNzLkNsdXN0ZXIodGhpcywgJ0NsdXN0ZXInLCB7XG4gICAgICB2cGM6IHByb3BzLnZwYyxcbiAgICAgIGNsdXN0ZXJOYW1lOiAnbWlncmF0aW9uLXNjcmlwdHMnLFxuICAgIH0pO1xuXG4gICAgdGhpcy5zZWN1cml0eUdyb3VwID0gbmV3IGVjMi5TZWN1cml0eUdyb3VwKHRoaXMsICdTZWN1cml0eUdyb3VwJywge1xuICAgICAgdnBjOiBwcm9wcy52cGMsXG4gICAgICBzZWN1cml0eUdyb3VwTmFtZTogJ01pZ3JhdGlvbi1TY3JpcHRzLVNHJyxcbiAgICAgIGRlc2NyaXB0aW9uOiAnTWlncmF0aW9uIHNjcmlwdHMgRUNTIHRhc2tzJyxcbiAgICAgIGFsbG93QWxsT3V0Ym91bmQ6IHRydWUsXG4gICAgfSk7XG5cbiAgICB0aGlzLnRhc2tEZWZpbml0aW9uID0gbmV3IGVjcy5GYXJnYXRlVGFza0RlZmluaXRpb24odGhpcywgJ1Rhc2tEZWZpbml0aW9uJywge1xuICAgICAgZmFtaWx5OiAnbWlncmF0aW9uLXNjcmlwdHMnLFxuICAgICAgY3B1OiBwcm9wcy5jcHUgPz8gNDA5NixcbiAgICAgIG1lbW9yeUxpbWl0TWlCOiBwcm9wcy5tZW1vcnlMaW1pdE1pQiA/PyA4MTkyLFxuICAgICAgZXBoZW1lcmFsU3RvcmFnZUdpQjogcHJvcHMuZXBoZW1lcmFsU3RvcmFnZUdpQiA/PyAyMSxcbiAgICAgIHJ1bnRpbWVQbGF0Zm9ybToge1xuICAgICAgICBjcHVBcmNoaXRlY3R1cmU6IGVjcy5DcHVBcmNoaXRlY3R1cmUuWDg2XzY0LFxuICAgICAgICBvcGVyYXRpbmdTeXN0ZW1GYW1pbHk6IGVjcy5PcGVyYXRpbmdTeXN0ZW1GYW1pbHkuTElOVVgsXG4gICAgICB9LFxuICAgIH0pO1xuXG4gICAgY29uc3QgeyBlbnZpcm9ubWVudCwgc2VjcmV0cyB9ID0gZ2V0RWNzRW52cyhjZGsuU3RhY2sub2YodGhpcykpO1xuXG4gICAgdGhpcy5jb250YWluZXIgPSB0aGlzLnRhc2tEZWZpbml0aW9uLmFkZENvbnRhaW5lcignc2NyaXB0cycsIHtcbiAgICAgIGNvbnRhaW5lck5hbWU6ICdzY3JpcHRzJyxcbiAgICAgIGltYWdlOiBlY3MuQ29udGFpbmVySW1hZ2UuZnJvbUFzc2V0KHBhdGgucmVzb2x2ZSgnLi4vLi4vbWlncmF0aW9uJyksIHsgZmlsZTogJ0RvY2tlcmZpbGUnIH0pLFxuICAgICAgZW52aXJvbm1lbnQsXG4gICAgICBzZWNyZXRzLFxuICAgICAgbG9nZ2luZzogZWNzLkxvZ0RyaXZlcnMuYXdzTG9ncyh7XG4gICAgICAgIHN0cmVhbVByZWZpeDogJ21pZ3JhdGlvbi1zY3JpcHRzJyxcbiAgICAgICAgbG9nUmV0ZW50aW9uOiBsb2dzLlJldGVudGlvbkRheXMuT05FX01PTlRILFxuICAgICAgfSksXG4gICAgfSk7XG5cbiAgICBwcm9wcy5hcnRpZmFjdHNCdWNrZXQuZ3JhbnRSZWFkKHRoaXMudGFza0RlZmluaXRpb24udGFza1JvbGUsIGAke3Byb3BzLmJhY2t1cFByZWZpeCA/PyAnYmFja3Vwcyd9LypgKTtcbiAgfVxufVxuIl19

package/dist/constructs/migration-state-machine.d.ts

@@ -0,0 +1,40 @@
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as sqs from 'aws-cdk-lib/aws-sqs';
+import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
+import { Construct } from 'constructs';
+export interface MigrationStateMachineProps {
+    producer: lambda.IFunction;
+    verifier: lambda.IFunction;
+    queue: sqs.IQueue;
+    cluster: ecs.ICluster;
+    taskDefinition: ecs.TaskDefinition;
+    container: ecs.ContainerDefinition;
+    securityGroup: ec2.ISecurityGroup;
+    artifactsBucket: s3.IBucket;
+    maxInvocations?: number;
+    drainMaxChecks?: number;
+    loopWaitSeconds?: number;
+    drainWaitSeconds?: number;
+}
+export declare class MigrationStateMachine extends Construct {
+    readonly stateMachine: sfn.StateMachine;
+    private readonly producer;
+    private readonly verifier;
+    private readonly queue;
+    private readonly cluster;
+    private readonly taskDefinition;
+    private readonly container;
+    private readonly securityGroup;
+    private readonly artifactsBucket;
+    private readonly maxInvocations;
+    private readonly drainMaxChecks;
+    private readonly loopWaitSeconds;
+    private readonly drainWaitSeconds;
+    constructor(scope: Construct, id: string, props: MigrationStateMachineProps);
+    private producerPass;
+    private resourceStep;
+    private ecsStep;
+}

package/dist/constructs/migration-state-machine.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationStateMachine = void 0;
+const cdk = require("aws-cdk-lib");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+const ecs = require("aws-cdk-lib/aws-ecs");
+const logs = require("aws-cdk-lib/aws-logs");
+const sfn = require("aws-cdk-lib/aws-stepfunctions");
+const tasks = require("aws-cdk-lib/aws-stepfunctions-tasks");
+const constructs_1 = require("constructs");
+// Runs the runbook end-to-end: scripts as one-shot Fargate tasks, SQS
+// migratables as producer loops (until endReached) followed by a queue drain
+// and a skipMigrated retry pass, then the verifier summary.
+class MigrationStateMachine extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.producer = props.producer;
+        this.verifier = props.verifier;
+        this.queue = props.queue;
+        this.cluster = props.cluster;
+        this.taskDefinition = props.taskDefinition;
+        this.container = props.container;
+        this.securityGroup = props.securityGroup;
+        this.artifactsBucket = props.artifactsBucket;
+        this.maxInvocations = props.maxInvocations ?? 2000;
+        this.drainMaxChecks = props.drainMaxChecks ?? 600;
+        this.loopWaitSeconds = props.loopWaitSeconds ?? 10;
+        this.drainWaitSeconds = props.drainWaitSeconds ?? 300;
+        const entries = {};
+        const verify = new tasks.LambdaInvoke(this, 'Verify', {
+            lambdaFunction: this.verifier,
+            payload: sfn.TaskInput.fromObject({
+                runId: sfn.JsonPath.stringAt('$$.Execution.Name'),
+                bucket: this.artifactsBucket.bucketName,
+                key: sfn.JsonPath.format('runs/{}/summary.json', sfn.JsonPath.stringAt('$$.Execution.Name')),
+            }),
+            payloadResponseOnly: true,
+            resultPath: '$.verification',
+        });
+        const complete = new sfn.Succeed(this, 'Complete');
+        verify.next(complete);
+        let tail = verify;
+        entries['claims'] = this.resourceStep('s16-claims', { resource: 'claims' }, tail);
+        tail = entries['claims'];
+        const photos = this.resourceStep('s15-beneficiary-photos', { resource: 'beneficiary-photos' }, tail);
+        entries['beneficiary-photos'] = photos;
+        const photosChoice = new sfn.Choice(this, 'SkipPhotos').when(sfn.Condition.booleanEquals('$.skipPhotos', true), tail).otherwise(photos);
+        tail = photosChoice;
+        entries['beneficiaries-dependants'] = this.resourceStep('s14b-beneficiaries-dependants', { resource: 'beneficiaries', phase: 'dependants' }, tail);
+        tail = entries['beneficiaries-dependants'];
+        entries['beneficiaries-principals'] = this.resourceStep('s14a-beneficiaries-principals', { resource: 'beneficiaries', phase: 'principals' }, tail);
+        tail = entries['beneficiaries-principals'];
+        entries['plans-rewire'] = this.resourceStep('s13b-plans-rewire', { resource: 'plans' }, tail);
+        tail = entries['plans-rewire'];
+        entries['benefits'] = this.resourceStep('s12-benefits', { resource: 'benefits' }, tail);
+        tail = entries['benefits'];
+        entries['policies'] = this.resourceStep('s11-policies', { resource: 'policies' }, tail);
+        tail = entries['policies'];
+        entries['product-pricing'] = this.resourceStep('s10-product-pricing', { resource: 'product-pricing' }, tail);
+        tail = entries['product-pricing'];
+        const tier0 = new sfn.Parallel(this, 's9-tier0', { resultPath: '$.tier0' });
+        for (const resource of ['users', 'providers', 'insured', 'tpa', 'plans']) {
+            tier0.branch(sfn.Chain.start(this.resourceStep(`s9-${resource}`, { resource })));
+        }
+        tier0.next(tail);
+        entries['tier0'] = tier0;
+        tail = tier0;
+        entries['coverage-groups'] = this.resourceStep('s8-coverage-groups', { resource: 'coverage-groups' }, tail);
+        tail = entries['coverage-groups'];
+        entries['categories'] = this.resourceStep('s7-categories', { resource: 'categories' }, tail);
+        tail = entries['categories'];
+        entries['products'] = this.resourceStep('s6-products', { resource: 'products' }, tail);
+        tail = entries['products'];
+        entries['product-categories'] = this.resourceStep('s5b-product-categories', { resource: 'product-categories' }, tail);
+        tail = entries['product-categories'];
+        entries['product-sources'] = this.resourceStep('s5a-product-sources', { resource: 'product-sources' }, tail);
+        tail = entries['product-sources'];
+        entries['claim-batches'] = this.ecsStep('s4-claim-batches', 'claim-batches', [], cdk.Duration.hours(2), tail);
+        tail = entries['claim-batches'];
+        entries['diseases'] = this.ecsStep('s3-disease-lookups', 'diseases', [], cdk.Duration.hours(1), tail);
+        tail = entries['diseases'];
+        entries['migrations'] = this.ecsStep('s2-migrations', 'migrations', [], cdk.Duration.hours(1), tail);
+        tail = entries['migrations'];
+        const restore = this.ecsStep('s1-restore', 'restore', [{ name: 'BACKUP_S3_URI', value: sfn.JsonPath.stringAt('$.backupS3Uri') }], cdk.Duration.hours(3), tail);
+        entries['restore'] = restore;
+        tail = restore;
+        const reset = this.ecsStep('s0-fresh-reset', 'reset', [], cdk.Duration.minutes(30), restore);
+        entries['fresh-reset'] = reset;
+        const freshChoice = new sfn.Choice(this, 'FreshReset').when(sfn.Condition.booleanEquals('$.fresh', true), reset).otherwise(restore);
+        tail = freshChoice;
+        const fromStep = new sfn.Choice(this, 'FromStep');
+        for (const [stepId, entry] of Object.entries(entries)) {
+            fromStep.when(sfn.Condition.and(sfn.Condition.isPresent('$.fromStep'), sfn.Condition.stringEquals('$.fromStep', stepId)), entry);
+        }
+        fromStep.otherwise(freshChoice);
+        tail = fromStep;
+        const logGroup = new logs.LogGroup(this, 'Logs', {
+            logGroupName: '/aws/vendedlogs/states/migration-orchestrator',
+            retention: logs.RetentionDays.THREE_MONTHS,
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+        });
+        this.stateMachine = new sfn.StateMachine(this, 'StateMachine', {
+            stateMachineName: 'migration-orchestrator',
+            definitionBody: sfn.DefinitionBody.fromChainable(tail),
+            timeout: cdk.Duration.days(7),
+            logs: {
+                destination: logGroup,
+                level: sfn.LogLevel.ALL,
+                includeExecutionData: true,
+            },
+        });
+        this.producer.grantInvoke(this.stateMachine);
+        this.verifier.grantInvoke(this.stateMachine);
+        this.queue.grant(this.stateMachine, 'sqs:GetQueueAttributes');
+        this.taskDefinition.grantRun(this.stateMachine);
+    }
+    // Producer loop (until endReached, guarded by maxInvocations) -> queue drain
+    // (Visible + NotVisible = 0, guarded by drainMaxChecks) -> next.
+    producerPass(id, payload, next) {
+        const failure = new sfn.Fail(this, `${id}-Failed`, {
+            error: 'MigrationStepFailed',
+            cause: `Step ${id} exceeded its iteration/drain guard, or an ECS script task failed.`,
+        });
+        const init = new sfn.Pass(this, `${id}-LoopInit`, {
+            parameters: { count: 0 },
+            resultPath: '$.loop',
+        });
+        const invoke = new tasks.LambdaInvoke(this, `${id}-Invoke`, {
+            lambdaFunction: this.producer,
+            payload: sfn.TaskInput.fromObject(payload),
+            payloadResponseOnly: true,
+            resultPath: '$.producer',
+            taskTimeout: sfn.Timeout.duration(cdk.Duration.minutes(15)),
+        });
+        invoke.addRetry({
+            errors: ['States.TaskFailed', 'Lambda.ServiceException', 'Lambda.AWSLambdaException', 'Lambda.SdkClientException'],
+            maxAttempts: 2,
+            interval: cdk.Duration.seconds(30),
+            backoffRate: 2,
+        });
+        const endReached = new sfn.Choice(this, `${id}-EndReached`);
+        const loopInc = new sfn.Pass(this, `${id}-LoopInc`, {
+            parameters: { count: sfn.JsonPath.mathAdd(sfn.JsonPath.numberAt('$.loop.count'), 1) },
+            resultPath: '$.loop',
+        });
+        const loopGuard = new sfn.Choice(this, `${id}-LoopGuard`).when(sfn.Condition.numberGreaterThan('$.loop.count', this.maxInvocations), failure);
+        const loopWait = new sfn.Wait(this, `${id}-LoopWait`, {
+            time: sfn.WaitTime.duration(cdk.Duration.seconds(this.loopWaitSeconds)),
+        });
+        const drainInit = new sfn.Pass(this, `${id}-DrainInit`, {
+            parameters: { count: 0 },
+            resultPath: '$.drain',
+        });
+        const drainGet = new tasks.CallAwsService(this, `${id}-QueueAttributes`, {
+            service: 'sqs',
+            action: 'getQueueAttributes',
+            parameters: {
+                QueueUrl: this.queue.queueUrl,
+                AttributeNames: ['ApproximateNumberOfMessages', 'ApproximateNumberOfMessagesNotVisible'],
+            },
+            iamResources: [this.queue.queueArn],
+            resultPath: '$.queue',
+        });
+        const drained = new sfn.Choice(this, `${id}-Drained`).when(sfn.Condition.and(sfn.Condition.stringEquals('$.queue.Attributes.ApproximateNumberOfMessages', '0'), sfn.Condition.stringEquals('$.queue.Attributes.ApproximateNumberOfMessagesNotVisible', '0')), next);
+        const drainInc = new sfn.Pass(this, `${id}-DrainInc`, {
+            parameters: { count: sfn.JsonPath.mathAdd(sfn.JsonPath.numberAt('$.drain.count'), 1) },
+            resultPath: '$.drain',
+        });
+        const drainGuard = new sfn.Choice(this, `${id}-DrainGuard`).when(sfn.Condition.numberGreaterThan('$.drain.count', this.drainMaxChecks), failure);
+        const drainWait = new sfn.Wait(this, `${id}-DrainWait`, {
+            time: sfn.WaitTime.duration(cdk.Duration.seconds(this.drainWaitSeconds)),
+        });
+        init.next(invoke);
+        invoke.next(endReached);
+        endReached.when(sfn.Condition.booleanEquals('$.producer.endReached', true), drainInit).otherwise(loopInc);
+        loopInc.next(loopGuard);
+        loopGuard.otherwise(loopWait);
+        loopWait.next(invoke);
+        drainInit.next(drainGet);
+        drainGet.next(drained);
+        drained.otherwise(drainInc);
+        drainInc.next(drainGuard);
+        drainGuard.otherwise(drainWait);
+        drainWait.next(drainGet);
+        return init;
+    }
+    // Main pass, then a skipMigrated retry pass (fromStart) that re-publishes
+    // only records without a migrated row.
+    resourceStep(id, payload, next) {
+        const terminal = next ?? new sfn.Succeed(this, `${id}-Done`);
+        const retry = this.producerPass(`${id}-Retry`, { ...payload, fromStart: true, skipMigrated: true }, terminal);
+        return this.producerPass(id, payload, retry);
+    }
+    ecsStep(id, command, environment, timeout, next) {
+        const run = new tasks.EcsRunTask(this, id, {
+            integrationPattern: sfn.IntegrationPattern.RUN_JOB,
+            cluster: this.cluster,
+            taskDefinition: this.taskDefinition,
+            launchTarget: new tasks.EcsFargateLaunchTarget({ platformVersion: ecs.FargatePlatformVersion.LATEST }),
+            containerOverrides: [
+                {
+                    containerDefinition: this.container,
+                    command: [command],
+                    environment,
+                },
+            ],
+            subnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+            securityGroups: [this.securityGroup],
+            assignPublicIp: false,
+            taskTimeout: sfn.Timeout.duration(timeout),
+        });
+        run.addRetry({
+            errors: ['States.TaskFailed'],
+            maxAttempts: 1,
+            interval: cdk.Duration.minutes(1),
+            backoffRate: 2,
+        });
+        run.next(next);
+        return run;
+    }
+}
+exports.MigrationStateMachine = MigrationStateMachine;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migration-state-machine.js","sourceRoot":"","sources":["../../constructs/migration-state-machine.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as ecs from 'aws-cdk-lib/aws-ecs';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as sqs from 'aws-cdk-lib/aws-sqs';\nimport * as sfn from 'aws-cdk-lib/aws-stepfunctions';\nimport * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';\nimport { Construct } from 'constructs';\n\nexport interface MigrationStateMachineProps {\n  producer: lambda.IFunction;\n  verifier: lambda.IFunction;\n  queue: sqs.IQueue;\n  cluster: ecs.ICluster;\n  taskDefinition: ecs.TaskDefinition;\n  container: ecs.ContainerDefinition;\n  securityGroup: ec2.ISecurityGroup;\n  artifactsBucket: s3.IBucket;\n  maxInvocations?: number;\n  drainMaxChecks?: number;\n  loopWaitSeconds?: number;\n  drainWaitSeconds?: number;\n}\n\ntype ProducerPayload = Record<string, unknown>;\n\n// Runs the runbook end-to-end: scripts as one-shot Fargate tasks, SQS\n// migratables as producer loops (until endReached) followed by a queue drain\n// and a skipMigrated retry pass, then the verifier summary.\nexport class MigrationStateMachine extends Construct {\n  public readonly stateMachine: sfn.StateMachine;\n\n  private readonly producer: lambda.IFunction;\n  private readonly verifier: lambda.IFunction;\n  private readonly queue: sqs.IQueue;\n  private readonly cluster: ecs.ICluster;\n  private readonly taskDefinition: ecs.TaskDefinition;\n  private readonly container: ecs.ContainerDefinition;\n  private readonly securityGroup: ec2.ISecurityGroup;\n  private readonly artifactsBucket: s3.IBucket;\n  private readonly maxInvocations: number;\n  private readonly drainMaxChecks: number;\n  private readonly loopWaitSeconds: number;\n  private readonly drainWaitSeconds: number;\n\n  constructor(scope: Construct, id: string, props: MigrationStateMachineProps) {\n    super(scope, id);\n\n    this.producer = props.producer;\n    this.verifier = props.verifier;\n    this.queue = props.queue;\n    this.cluster = props.cluster;\n    this.taskDefinition = props.taskDefinition;\n    this.container = props.container;\n    this.securityGroup = props.securityGroup;\n    this.artifactsBucket = props.artifactsBucket;\n    this.maxInvocations = props.maxInvocations ?? 2000;\n    this.drainMaxChecks = props.drainMaxChecks ?? 600;\n    this.loopWaitSeconds = props.loopWaitSeconds ?? 10;\n    this.drainWaitSeconds = props.drainWaitSeconds ?? 300;\n\n    const entries: Record<string, sfn.IChainable> = {};\n\n    const verify = new tasks.LambdaInvoke(this, 'Verify', {\n      lambdaFunction: this.verifier,\n      payload: sfn.TaskInput.fromObject({\n        runId: sfn.JsonPath.stringAt('$$.Execution.Name'),\n        bucket: this.artifactsBucket.bucketName,\n        key: sfn.JsonPath.format('runs/{}/summary.json', sfn.JsonPath.stringAt('$$.Execution.Name')),\n      }),\n      payloadResponseOnly: true,\n      resultPath: '$.verification',\n    });\n    const complete = new sfn.Succeed(this, 'Complete');\n    verify.next(complete);\n\n    let tail: sfn.IChainable = verify;\n\n    entries['claims'] = this.resourceStep('s16-claims', { resource: 'claims' }, tail);\n    tail = entries['claims'];\n\n    const photos = this.resourceStep('s15-beneficiary-photos', { resource: 'beneficiary-photos' }, tail);\n    entries['beneficiary-photos'] = photos;\n    const photosChoice = new sfn.Choice(this, 'SkipPhotos').when(sfn.Condition.booleanEquals('$.skipPhotos', true), tail).otherwise(photos);\n    tail = photosChoice;\n\n    entries['beneficiaries-dependants'] = this.resourceStep('s14b-beneficiaries-dependants', { resource: 'beneficiaries', phase: 'dependants' }, tail);\n    tail = entries['beneficiaries-dependants'];\n\n    entries['beneficiaries-principals'] = this.resourceStep('s14a-beneficiaries-principals', { resource: 'beneficiaries', phase: 'principals' }, tail);\n    tail = entries['beneficiaries-principals'];\n\n    entries['plans-rewire'] = this.resourceStep('s13b-plans-rewire', { resource: 'plans' }, tail);\n    tail = entries['plans-rewire'];\n\n    entries['benefits'] = this.resourceStep('s12-benefits', { resource: 'benefits' }, tail);\n    tail = entries['benefits'];\n\n    entries['policies'] = this.resourceStep('s11-policies', { resource: 'policies' }, tail);\n    tail = entries['policies'];\n\n    entries['product-pricing'] = this.resourceStep('s10-product-pricing', { resource: 'product-pricing' }, tail);\n    tail = entries['product-pricing'];\n\n    const tier0 = new sfn.Parallel(this, 's9-tier0', { resultPath: '$.tier0' });\n    for (const resource of ['users', 'providers', 'insured', 'tpa', 'plans']) {\n      tier0.branch(sfn.Chain.start(this.resourceStep(`s9-${resource}`, { resource })));\n    }\n    tier0.next(tail);\n    entries['tier0'] = tier0;\n    tail = tier0;\n\n    entries['coverage-groups'] = this.resourceStep('s8-coverage-groups', { resource: 'coverage-groups' }, tail);\n    tail = entries['coverage-groups'];\n\n    entries['categories'] = this.resourceStep('s7-categories', { resource: 'categories' }, tail);\n    tail = entries['categories'];\n\n    entries['products'] = this.resourceStep('s6-products', { resource: 'products' }, tail);\n    tail = entries['products'];\n\n    entries['product-categories'] = this.resourceStep('s5b-product-categories', { resource: 'product-categories' }, tail);\n    tail = entries['product-categories'];\n\n    entries['product-sources'] = this.resourceStep('s5a-product-sources', { resource: 'product-sources' }, tail);\n    tail = entries['product-sources'];\n\n    entries['claim-batches'] = this.ecsStep('s4-claim-batches', 'claim-batches', [], cdk.Duration.hours(2), tail);\n    tail = entries['claim-batches'];\n\n    entries['diseases'] = this.ecsStep('s3-disease-lookups', 'diseases', [], cdk.Duration.hours(1), tail);\n    tail = entries['diseases'];\n\n    entries['migrations'] = this.ecsStep('s2-migrations', 'migrations', [], cdk.Duration.hours(1), tail);\n    tail = entries['migrations'];\n\n    const restore = this.ecsStep(\n      's1-restore',\n      'restore',\n      [{ name: 'BACKUP_S3_URI', value: sfn.JsonPath.stringAt('$.backupS3Uri') }],\n      cdk.Duration.hours(3),\n      tail\n    );\n    entries['restore'] = restore;\n    tail = restore;\n\n    const reset = this.ecsStep('s0-fresh-reset', 'reset', [], cdk.Duration.minutes(30), restore);\n    entries['fresh-reset'] = reset;\n    const freshChoice = new sfn.Choice(this, 'FreshReset').when(sfn.Condition.booleanEquals('$.fresh', true), reset).otherwise(restore);\n    tail = freshChoice;\n\n    const fromStep = new sfn.Choice(this, 'FromStep');\n    for (const [stepId, entry] of Object.entries(entries)) {\n      fromStep.when(sfn.Condition.and(sfn.Condition.isPresent('$.fromStep'), sfn.Condition.stringEquals('$.fromStep', stepId)), entry);\n    }\n    fromStep.otherwise(freshChoice);\n    tail = fromStep;\n\n    const logGroup = new logs.LogGroup(this, 'Logs', {\n      logGroupName: '/aws/vendedlogs/states/migration-orchestrator',\n      retention: logs.RetentionDays.THREE_MONTHS,\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n    });\n\n    this.stateMachine = new sfn.StateMachine(this, 'StateMachine', {\n      stateMachineName: 'migration-orchestrator',\n      definitionBody: sfn.DefinitionBody.fromChainable(tail),\n      timeout: cdk.Duration.days(7),\n      logs: {\n        destination: logGroup,\n        level: sfn.LogLevel.ALL,\n        includeExecutionData: true,\n      },\n    });\n\n    this.producer.grantInvoke(this.stateMachine);\n    this.verifier.grantInvoke(this.stateMachine);\n    this.queue.grant(this.stateMachine, 'sqs:GetQueueAttributes');\n    this.taskDefinition.grantRun(this.stateMachine);\n  }\n\n  // Producer loop (until endReached, guarded by maxInvocations) -> queue drain\n  // (Visible + NotVisible = 0, guarded by drainMaxChecks) -> next.\n  private producerPass(id: string, payload: ProducerPayload, next: sfn.IChainable): sfn.IChainable {\n    const failure = new sfn.Fail(this, `${id}-Failed`, {\n      error: 'MigrationStepFailed',\n      cause: `Step ${id} exceeded its iteration/drain guard, or an ECS script task failed.`,\n    });\n\n    const init = new sfn.Pass(this, `${id}-LoopInit`, {\n      parameters: { count: 0 },\n      resultPath: '$.loop',\n    });\n\n    const invoke = new tasks.LambdaInvoke(this, `${id}-Invoke`, {\n      lambdaFunction: this.producer,\n      payload: sfn.TaskInput.fromObject(payload),\n      payloadResponseOnly: true,\n      resultPath: '$.producer',\n      taskTimeout: sfn.Timeout.duration(cdk.Duration.minutes(15)),\n    });\n    invoke.addRetry({\n      errors: ['States.TaskFailed', 'Lambda.ServiceException', 'Lambda.AWSLambdaException', 'Lambda.SdkClientException'],\n      maxAttempts: 2,\n      interval: cdk.Duration.seconds(30),\n      backoffRate: 2,\n    });\n\n    const endReached = new sfn.Choice(this, `${id}-EndReached`);\n\n    const loopInc = new sfn.Pass(this, `${id}-LoopInc`, {\n      parameters: { count: sfn.JsonPath.mathAdd(sfn.JsonPath.numberAt('$.loop.count'), 1) },\n      resultPath: '$.loop',\n    });\n    const loopGuard = new sfn.Choice(this, `${id}-LoopGuard`).when(sfn.Condition.numberGreaterThan('$.loop.count', this.maxInvocations), failure);\n    const loopWait = new sfn.Wait(this, `${id}-LoopWait`, {\n      time: sfn.WaitTime.duration(cdk.Duration.seconds(this.loopWaitSeconds)),\n    });\n\n    const drainInit = new sfn.Pass(this, `${id}-DrainInit`, {\n      parameters: { count: 0 },\n      resultPath: '$.drain',\n    });\n    const drainGet = new tasks.CallAwsService(this, `${id}-QueueAttributes`, {\n      service: 'sqs',\n      action: 'getQueueAttributes',\n      parameters: {\n        QueueUrl: this.queue.queueUrl,\n        AttributeNames: ['ApproximateNumberOfMessages', 'ApproximateNumberOfMessagesNotVisible'],\n      },\n      iamResources: [this.queue.queueArn],\n      resultPath: '$.queue',\n    });\n    const drained = new sfn.Choice(this, `${id}-Drained`).when(\n      sfn.Condition.and(\n        sfn.Condition.stringEquals('$.queue.Attributes.ApproximateNumberOfMessages', '0'),\n        sfn.Condition.stringEquals('$.queue.Attributes.ApproximateNumberOfMessagesNotVisible', '0')\n      ),\n      next\n    );\n    const drainInc = new sfn.Pass(this, `${id}-DrainInc`, {\n      parameters: { count: sfn.JsonPath.mathAdd(sfn.JsonPath.numberAt('$.drain.count'), 1) },\n      resultPath: '$.drain',\n    });\n    const drainGuard = new sfn.Choice(this, `${id}-DrainGuard`).when(sfn.Condition.numberGreaterThan('$.drain.count', this.drainMaxChecks), failure);\n    const drainWait = new sfn.Wait(this, `${id}-DrainWait`, {\n      time: sfn.WaitTime.duration(cdk.Duration.seconds(this.drainWaitSeconds)),\n    });\n\n    init.next(invoke);\n    invoke.next(endReached);\n    endReached.when(sfn.Condition.booleanEquals('$.producer.endReached', true), drainInit).otherwise(loopInc);\n    loopInc.next(loopGuard);\n    loopGuard.otherwise(loopWait);\n    loopWait.next(invoke);\n    drainInit.next(drainGet);\n    drainGet.next(drained);\n    drained.otherwise(drainInc);\n    drainInc.next(drainGuard);\n    drainGuard.otherwise(drainWait);\n    drainWait.next(drainGet);\n\n    return init;\n  }\n\n  // Main pass, then a skipMigrated retry pass (fromStart) that re-publishes\n  // only records without a migrated row.\n  private resourceStep(id: string, payload: ProducerPayload, next?: sfn.IChainable): sfn.IChainable {\n    const terminal = next ?? new sfn.Succeed(this, `${id}-Done`);\n    const retry = this.producerPass(`${id}-Retry`, { ...payload, fromStart: true, skipMigrated: true }, terminal);\n    return this.producerPass(id, payload, retry);\n  }\n\n  private ecsStep(id: string, command: string, environment: { name: string; value: string }[], timeout: cdk.Duration, next: sfn.IChainable): sfn.IChainable {\n    const run = new tasks.EcsRunTask(this, id, {\n      integrationPattern: sfn.IntegrationPattern.RUN_JOB,\n      cluster: this.cluster,\n      taskDefinition: this.taskDefinition,\n      launchTarget: new tasks.EcsFargateLaunchTarget({ platformVersion: ecs.FargatePlatformVersion.LATEST }),\n      containerOverrides: [\n        {\n          containerDefinition: this.container,\n          command: [command],\n          environment,\n        },\n      ],\n      subnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },\n      securityGroups: [this.securityGroup],\n      assignPublicIp: false,\n      taskTimeout: sfn.Timeout.duration(timeout),\n    });\n    run.addRetry({\n      errors: ['States.TaskFailed'],\n      maxAttempts: 1,\n      interval: cdk.Duration.minutes(1),\n      backoffRate: 2,\n    });\n    run.next(next);\n    return run;\n  }\n}\n"]}

package/dist/lib/microservice-clickhouse.d.ts

@@ -0,0 +1,5 @@
+import * as cdk from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+export declare class MicroserviceClickHouse extends cdk.Stack {
+    constructor(scope: Construct, id: string, props?: cdk.StackProps);
+}

package/dist/lib/microservice-clickhouse.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicroserviceClickHouse = void 0;
+const cdk = require("aws-cdk-lib");
+const constants_1 = require("../util/constants");
+const initBuildConfig_1 = require("../util/initBuildConfig");
+const getInstanceType_1 = require("../util/getInstanceType");
+const getEc2UserData_1 = require("../util/getEc2UserData");
+const getInstanceStorage_1 = require("../util/getInstanceStorage");
+class MicroserviceClickHouse extends cdk.Stack {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        if (!initBuildConfig_1.buildConfig) {
+            throw new Error('BuildConfig not set');
+        }
+        const vpc = cdk.aws_ec2.Vpc.fromLookup(this, 'VPCLookup', {
+            vpcName: (0, constants_1.getEnvConstant)('vpcId'),
+        });
+        const secGroup = cdk.aws_ec2.SecurityGroup.fromLookupByName(this, 'SecGroupLookup', (0, constants_1.getEnvConstant)('clickhouseSecurityGroupId'), vpc);
+        const instance = new cdk.aws_ec2.Instance(this, `ec2-clickhouse-${initBuildConfig_1.buildConfig.envName}`, {
+            vpc,
+            securityGroup: secGroup,
+            instanceType: new cdk.aws_ec2.InstanceType((0, getInstanceType_1.getInstanceType)('clickhouse')),
+            machineImage: cdk.aws_ec2.MachineImage.genericLinux({
+                [initBuildConfig_1.buildConfig.aws.region]: (0, constants_1.getConstant)('defaultImageAmi'),
+            }),
+            vpcSubnets: { subnetType: cdk.aws_ec2.SubnetType.PRIVATE_WITH_EGRESS },
+            associatePublicIpAddress: false,
+            userData: cdk.aws_ec2.UserData.custom((0, getEc2UserData_1.getEc2UserData)('clickhouse')),
+            role: cdk.aws_iam.Role.fromRoleName(this, 'BaseRoleLookup', (0, constants_1.getConstant)('baseRoleName')),
+            blockDevices: (0, getInstanceStorage_1.getInstanceStorage)('clickhouse'),
+        });
+        new cdk.CfnOutput(this, 'internal-domain', {
+            value: instance.instancePrivateDnsName,
+        });
+        new cdk.CfnOutput(this, 'internal-ip', {
+            value: instance.instancePrivateIp,
+        });
+    }
+}
+exports.MicroserviceClickHouse = MicroserviceClickHouse;
+//# sourceMappingURL=data:application/json;base64,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