@glicogh/healthcare-cdk 0.1.88 → 0.1.89

package/README.md

@@ -91,13 +91,68 @@ The following stack are meant to be deployed once and shared across the microser
 - 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' | 'clickhouse' | '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,6 +13,7 @@ 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',
@@ -21,4 +22,4 @@ exports.OtherCDKServiceEnum = {
     migration: 'migration',
 };
 exports.OtherCDKServiceList = Object.values(exports.OtherCDKServiceEnum);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vQHR5cGVzL2NvbW1vbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFxQmEsUUFBQSxnQkFBZ0IsR0FBdUM7SUFDbEUsT0FBTyxFQUFFLFNBQVM7SUFDbEIsSUFBSSxFQUFFLE1BQU07SUFDWixNQUFNLEVBQUUsUUFBUTtJQUNoQixZQUFZLEVBQUUsY0FBYztJQUM1QixTQUFTLEVBQUUsV0FBVztJQUN0QixNQUFNLEVBQUUsUUFBUTtDQUNqQixDQUFDO0FBRVcsUUFBQSxnQkFBZ0IsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDLHdCQUFnQixDQUFDLENBQUM7QUFFbkQsUUFBQSx1QkFBdUIsR0FBRyx3QkFBZ0IsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsS0FBSyxjQUFjLENBQUMsQ0FBQztBQUUvRSxRQUFBLG1CQUFtQixHQUE2QztJQUMzRSxPQUFPLEVBQUUsU0FBUztJQUNsQixZQUFZLEVBQUUsWUFBWTtJQUMxQixhQUFhLEVBQUUsYUFBYTtJQUM1QixLQUFLLEVBQUUsT0FBTztJQUNkLEtBQUssRUFBRSxPQUFPO0lBQ2QsVUFBVSxFQUFFLFlBQVk7SUFDeEIsTUFBTSxFQUFFLFFBQVE7SUFDaEIsU0FBUyxFQUFFLFdBQVc7Q0FDdkIsQ0FBQztBQUVXLFFBQUEsbUJBQW1CLEdBQUcsTUFBTSxDQUFDLE1BQU0sQ0FBQywyQkFBbUIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgRW52TmFtZSA9ICd1YXQnIHwgJ3Byb2QnO1xuZXhwb3J0IHR5cGUgUmVwb0JyYW5jaCA9ICdtYXN0ZXInIHwgJ3JlbGVhc2UnO1xuZXhwb3J0IHR5cGUgQnVpbGRDb25maWcgPSB7XG4gIGFwcE5hbWU6IHN0cmluZztcbiAgYXBwVmVyc2lvbjogc3RyaW5nO1xuICBidWlsZElkOiBzdHJpbmc7XG4gIGZvcm1hdHRlZEJ1aWxkSWQ6IHN0cmluZztcbiAgZW52TmFtZTogRW52TmFtZTtcbiAgZW52UGF0aDogc3RyaW5nO1xuICBzZXJ2aWNlTmFtZTogTWljcm9zZXJ2aWNlIHwgT3RoZXJDREtTZXJ2aWNlO1xuICBicmFuY2g/OiBzdHJpbmc7XG4gIGNvbXBhbnlOYW1lOiBzdHJpbmc7XG4gIGF3czoge1xuICAgIGFjY291bnQ6IHN0cmluZztcbiAgICByZWdpb246IHN0cmluZztcbiAgfTtcbn07XG5leHBvcnQgdHlwZSBNaWNyb3NlcnZpY2UgPSAnYWNjb3VudCcgfCAncGxhbicgfCAncG9saWN5JyB8ICdjbGFpbXMnIHwgJ25vdGlmaWNhdGlvbicgfCAncmVwb3J0aW5nJztcblxuZXhwb3J0IHR5cGUgT3RoZXJDREtTZXJ2aWNlID0gJ25ldHdvcmsnIHwgJ2luZnJhLWF1dGgnIHwgJ2FwaS1nYXRld2F5JyB8ICdyZWRpcycgfCAnbXlzcWwnIHwgJ2NsaWNraG91c2UnIHwgJ3BvcnRhbCcgfCAnbWlncmF0aW9uJztcblxuZXhwb3J0IGNvbnN0IE1pY3Jvc2VydmljZUVudW06IFJlY29yZDxNaWNyb3NlcnZpY2UsIE1pY3Jvc2VydmljZT4gPSB7XG4gIGFjY291bnQ6ICdhY2NvdW50JyxcbiAgcGxhbjogJ3BsYW4nLFxuICBwb2xpY3k6ICdwb2xpY3knLFxuICBub3RpZmljYXRpb246ICdub3RpZmljYXRpb24nLFxuICByZXBvcnRpbmc6ICdyZXBvcnRpbmcnLFxuICBjbGFpbXM6ICdjbGFpbXMnLFxufTtcblxuZXhwb3J0IGNvbnN0IE1pY3Jvc2VydmljZUxpc3QgPSBPYmplY3QudmFsdWVzKE1pY3Jvc2VydmljZUVudW0pO1xuXG5leHBvcnQgY29uc3QgTGFyYXZlbEJhc2VkU2VydmljZUxpc3QgPSBNaWNyb3NlcnZpY2VMaXN0LmZpbHRlcigoaSkgPT4gaSAhPT0gJ25vdGlmaWNhdGlvbicpO1xuXG5leHBvcnQgY29uc3QgT3RoZXJDREtTZXJ2aWNlRW51bTogUmVjb3JkPE90aGVyQ0RLU2VydmljZSwgT3RoZXJDREtTZXJ2aWNlPiA9IHtcbiAgbmV0d29yazogJ25ldHdvcmsnLFxuICAnaW5mcmEtYXV0aCc6ICdpbmZyYS1hdXRoJyxcbiAgJ2FwaS1nYXRld2F5JzogJ2FwaS1nYXRld2F5JyxcbiAgcmVkaXM6ICdyZWRpcycsXG4gIG15c3FsOiAnbXlzcWwnLFxuICBjbGlja2hvdXNlOiAnY2xpY2tob3VzZScsXG4gIHBvcnRhbDogJ3BvcnRhbCcsXG4gIG1pZ3JhdGlvbjogJ21pZ3JhdGlvbicsXG59O1xuXG5leHBvcnQgY29uc3QgT3RoZXJDREtTZXJ2aWNlTGlzdCA9IE9iamVjdC52YWx1ZXMoT3RoZXJDREtTZXJ2aWNlRW51bSk7XG5cbmV4cG9ydCB0eXBlIFJlcG9VcmxzID0geyBba2V5IGluIEJ1aWxkQ29uZmlnWydzZXJ2aWNlTmFtZSddXT86IHN0cmluZyB9O1xuZXhwb3J0IHR5cGUgUmVwb0JyYW5jaGVzID0geyBba2V5IGluIEVudk5hbWVdOiBSZXBvQnJhbmNoIH07XG4iXX0=

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,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

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-migration.js

@@ -5,6 +5,8 @@ const cdk = require("aws-cdk-lib");
 const constants_1 = require("../util/constants");
 const initBuildConfig_1 = require("../util/initBuildConfig");
 const migration_1 = require("../util/migration");
+const migration_scripts_runner_1 = require("../constructs/migration-scripts-runner");
+const migration_state_machine_1 = require("../constructs/migration-state-machine");
 const path = require("path");
 const fs = require("fs");
 class MicroserviceMigration extends cdk.Stack {
@@ -69,6 +71,11 @@ class MicroserviceMigration extends cdk.Stack {
             if (lambdaProps.environment) {
                 lambdaProps.environment['MIGRATION_QUEUE_URL'] = migrationQueue.queueUrl;
             }
+            // The claims producer shards FIFO message groups by MIGRATION_QUEUE_SHARDS;
+            // the consumer's reserved concurrency must cover every shard group.
+            const shardsParam = cdk.aws_ssm.StringParameter.valueFromLookup(this, `/${initBuildConfig_1.buildConfig.envName}/microservices/migration/env/MIGRATION_QUEUE_SHARDS`);
+            const shards = Number(shardsParam);
+            const consumerConcurrency = Number.isFinite(shards) && shards > 0 ? Math.max(50, shards) : 64;
             const producerLambda = new cdk.aws_lambda_nodejs.NodejsFunction(this, 'migrationProducerLambda', {
                 ...lambdaProps,
                 functionName: 'migration-producer',
@@ -80,16 +87,45 @@ class MicroserviceMigration extends cdk.Stack {
                 functionName: 'migration-consumer',
                 entry: path.join(lambdasRootDir, 'consumer', 'index.ts'),
                 role: lambdaRole,
-                reservedConcurrentExecutions: 50,
+                reservedConcurrentExecutions: consumerConcurrency,
             });
             consumerLambda.addEventSource(new cdk.aws_lambda_event_sources.SqsEventSource(migrationQueue, {
-                maxConcurrency: 50,
+                maxConcurrency: consumerConcurrency,
                 reportBatchItemFailures: true,
             }));
             migrationQueue.grantSendMessages(producerLambda);
             migrationQueue.grantConsumeMessages(consumerLambda);
+            const artifactsBucket = new cdk.aws_s3.Bucket(this, 'migrationArtifactsBucket', {
+                bucketName: `glicogh-healthcare-migration-${initBuildConfig_1.buildConfig.envName}-${initBuildConfig_1.buildConfig.aws.account}`,
+                blockPublicAccess: cdk.aws_s3.BlockPublicAccess.BLOCK_ALL,
+                encryption: cdk.aws_s3.BucketEncryption.S3_MANAGED,
+                enforceSSL: true,
+                removalPolicy: cdk.RemovalPolicy.RETAIN,
+                lifecycleRules: [{ id: 'expire-backups', prefix: 'backups/', expiration: cdk.Duration.days(30) }],
+            });
+            const verifierLambda = new cdk.aws_lambda_nodejs.NodejsFunction(this, 'migrationVerifierLambda', {
+                ...lambdaProps,
+                functionName: 'migration-verifier',
+                entry: path.join(lambdasRootDir, 'verifier', 'index.ts'),
+                role: lambdaRole,
+            });
+            artifactsBucket.grantPut(verifierLambda);
+            const scriptsRunner = new migration_scripts_runner_1.MigrationScriptsRunner(this, 'migrationScriptsRunner', {
+                vpc,
+                artifactsBucket,
+            });
+            new migration_state_machine_1.MigrationStateMachine(this, 'migrationStateMachine', {
+                producer: producerLambda,
+                verifier: verifierLambda,
+                queue: migrationQueue,
+                cluster: scriptsRunner.cluster,
+                taskDefinition: scriptsRunner.taskDefinition,
+                container: scriptsRunner.container,
+                securityGroup: scriptsRunner.securityGroup,
+                artifactsBucket,
+            });
         }
     }
 }
 exports.MicroserviceMigration = MicroserviceMigration;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"microservice-migration.js","sourceRoot":"","sources":["../../lib/microservice-migration.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { getEnvConstant } from '../util/constants';\nimport { buildConfig } from '../util/initBuildConfig';\nimport { getLambdaEnvs } from '../util/migration';\nimport * as path from 'path';\nimport * as fs from 'fs';\n\nexport class MicroserviceMigration extends cdk.Stack {\n  constructor(scope: Construct, id: string, props?: cdk.StackProps) {\n    super(scope, id, props);\n\n    if (!buildConfig) {\n      throw new Error('BuildConfig not set');\n    }\n\n    const vpc = cdk.aws_ec2.Vpc.fromLookup(this, 'VPCLookup', {\n      vpcName: getEnvConstant('vpcId'),\n    });\n\n    const paramsAndSecrets = cdk.aws_lambda.ParamsAndSecretsLayerVersion.fromVersion(cdk.aws_lambda.ParamsAndSecretsVersions.V1_0_103, {\n      maxConnections: 20,\n      secretsManagerTimeout: cdk.Duration.seconds(300),\n    });\n\n    const lambdaRole = new cdk.aws_iam.Role(this, 'MigrationLambdaRole', {\n      roleName: 'MigrationLambda',\n      assumedBy: new cdk.aws_iam.ServicePrincipal('lambda.amazonaws.com'),\n      managedPolicies: [\n        cdk.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),\n        cdk.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaVPCAccessExecutionRole'),\n      ],\n      inlinePolicies: {\n        migrationLambdas: new cdk.aws_iam.PolicyDocument({\n          statements: [\n            new cdk.aws_iam.PolicyStatement({\n              sid: 'AllowLambdaToReadSSMParameters',\n              resources: [`arn:aws:ssm:${buildConfig.aws.region}:${buildConfig.aws.account}:parameter/${buildConfig.envName}/microservices/*`],\n              actions: ['ssm:GetParameter*'],\n              effect: cdk.aws_iam.Effect.ALLOW,\n            }),\n          ],\n        }),\n      },\n    });\n\n    const lambdasRootDir = path.join(path.resolve('../../migration'), 'lambdas');\n    if (fs.existsSync(lambdasRootDir)) {\n      const lambdaProps: cdk.aws_lambda_nodejs.NodejsFunctionProps = {\n        runtime: cdk.aws_lambda.Runtime.NODEJS_22_X,\n        architecture: cdk.aws_lambda.Architecture.X86_64,\n        handler: 'handler',\n        depsLockFilePath: path.join(lambdasRootDir, 'package-lock.json'),\n        projectRoot: lambdasRootDir,\n        bundling: {\n          tsconfig: path.join(lambdasRootDir, 'tsconfig.json'),\n          externalModules: ['better-sqlite3', 'pg', 'mysql', 'sqlite3', 'tedious', 'oracledb', 'pg-query-stream'],\n        },\n        environment: getLambdaEnvs(this),\n        vpc,\n        vpcSubnets: { subnetType: cdk.aws_ec2.SubnetType.PRIVATE_WITH_EGRESS },\n        paramsAndSecrets,\n        timeout: cdk.Duration.minutes(15),\n      };\n\n      const migrationQueue = new cdk.aws_sqs.Queue(this, 'migrationQueue', {\n        queueName: 'migration-queue.fifo',\n        fifo: true,\n        fifoThroughputLimit: cdk.aws_sqs.FifoThroughputLimit.PER_MESSAGE_GROUP_ID,\n        deduplicationScope: cdk.aws_sqs.DeduplicationScope.MESSAGE_GROUP,\n        visibilityTimeout: cdk.Duration.minutes(20),\n        receiveMessageWaitTime: cdk.Duration.seconds(10),\n      });\n\n      if (lambdaProps.environment) {\n        lambdaProps.environment['MIGRATION_QUEUE_URL'] = migrationQueue.queueUrl;\n      }\n\n      const producerLambda = new cdk.aws_lambda_nodejs.NodejsFunction(this, 'migrationProducerLambda', {\n        ...lambdaProps,\n        functionName: 'migration-producer',\n        entry: path.join(lambdasRootDir, 'producer', 'index.ts'),\n        role: lambdaRole,\n      });\n\n      const consumerLambda = new cdk.aws_lambda_nodejs.NodejsFunction(this, 'migrationConsumerLambda', {\n        ...lambdaProps,\n        functionName: 'migration-consumer',\n        entry: path.join(lambdasRootDir, 'consumer', 'index.ts'),\n        role: lambdaRole,\n        reservedConcurrentExecutions: 50,\n      });\n\n      consumerLambda.addEventSource(\n        new cdk.aws_lambda_event_sources.SqsEventSource(migrationQueue, {\n          maxConcurrency: 50,\n          reportBatchItemFailures: true,\n        })\n      );\n\n      migrationQueue.grantSendMessages(producerLambda);\n      migrationQueue.grantConsumeMessages(consumerLambda);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"microservice-migration.js","sourceRoot":"","sources":["../../lib/microservice-migration.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { getEnvConstant } from '../util/constants';\nimport { buildConfig } from '../util/initBuildConfig';\nimport { getLambdaEnvs } from '../util/migration';\nimport { MigrationScriptsRunner } from '../constructs/migration-scripts-runner';\nimport { MigrationStateMachine } from '../constructs/migration-state-machine';\nimport * as path from 'path';\nimport * as fs from 'fs';\n\nexport class MicroserviceMigration extends cdk.Stack {\n  constructor(scope: Construct, id: string, props?: cdk.StackProps) {\n    super(scope, id, props);\n\n    if (!buildConfig) {\n      throw new Error('BuildConfig not set');\n    }\n\n    const vpc = cdk.aws_ec2.Vpc.fromLookup(this, 'VPCLookup', {\n      vpcName: getEnvConstant('vpcId'),\n    });\n\n    const paramsAndSecrets = cdk.aws_lambda.ParamsAndSecretsLayerVersion.fromVersion(cdk.aws_lambda.ParamsAndSecretsVersions.V1_0_103, {\n      maxConnections: 20,\n      secretsManagerTimeout: cdk.Duration.seconds(300),\n    });\n\n    const lambdaRole = new cdk.aws_iam.Role(this, 'MigrationLambdaRole', {\n      roleName: 'MigrationLambda',\n      assumedBy: new cdk.aws_iam.ServicePrincipal('lambda.amazonaws.com'),\n      managedPolicies: [\n        cdk.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaBasicExecutionRole'),\n        cdk.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AWSLambdaVPCAccessExecutionRole'),\n      ],\n      inlinePolicies: {\n        migrationLambdas: new cdk.aws_iam.PolicyDocument({\n          statements: [\n            new cdk.aws_iam.PolicyStatement({\n              sid: 'AllowLambdaToReadSSMParameters',\n              resources: [`arn:aws:ssm:${buildConfig.aws.region}:${buildConfig.aws.account}:parameter/${buildConfig.envName}/microservices/*`],\n              actions: ['ssm:GetParameter*'],\n              effect: cdk.aws_iam.Effect.ALLOW,\n            }),\n          ],\n        }),\n      },\n    });\n\n    const lambdasRootDir = path.join(path.resolve('../../migration'), 'lambdas');\n    if (fs.existsSync(lambdasRootDir)) {\n      const lambdaProps: cdk.aws_lambda_nodejs.NodejsFunctionProps = {\n        runtime: cdk.aws_lambda.Runtime.NODEJS_22_X,\n        architecture: cdk.aws_lambda.Architecture.X86_64,\n        handler: 'handler',\n        depsLockFilePath: path.join(lambdasRootDir, 'package-lock.json'),\n        projectRoot: lambdasRootDir,\n        bundling: {\n          tsconfig: path.join(lambdasRootDir, 'tsconfig.json'),\n          externalModules: ['better-sqlite3', 'pg', 'mysql', 'sqlite3', 'tedious', 'oracledb', 'pg-query-stream'],\n        },\n        environment: getLambdaEnvs(this),\n        vpc,\n        vpcSubnets: { subnetType: cdk.aws_ec2.SubnetType.PRIVATE_WITH_EGRESS },\n        paramsAndSecrets,\n        timeout: cdk.Duration.minutes(15),\n      };\n\n      const migrationQueue = new cdk.aws_sqs.Queue(this, 'migrationQueue', {\n        queueName: 'migration-queue.fifo',\n        fifo: true,\n        fifoThroughputLimit: cdk.aws_sqs.FifoThroughputLimit.PER_MESSAGE_GROUP_ID,\n        deduplicationScope: cdk.aws_sqs.DeduplicationScope.MESSAGE_GROUP,\n        visibilityTimeout: cdk.Duration.minutes(20),\n        receiveMessageWaitTime: cdk.Duration.seconds(10),\n      });\n\n      if (lambdaProps.environment) {\n        lambdaProps.environment['MIGRATION_QUEUE_URL'] = migrationQueue.queueUrl;\n      }\n\n      // The claims producer shards FIFO message groups by MIGRATION_QUEUE_SHARDS;\n      // the consumer's reserved concurrency must cover every shard group.\n      const shardsParam = cdk.aws_ssm.StringParameter.valueFromLookup(this, `/${buildConfig.envName}/microservices/migration/env/MIGRATION_QUEUE_SHARDS`);\n      const shards = Number(shardsParam);\n      const consumerConcurrency = Number.isFinite(shards) && shards > 0 ? Math.max(50, shards) : 64;\n\n      const producerLambda = new cdk.aws_lambda_nodejs.NodejsFunction(this, 'migrationProducerLambda', {\n        ...lambdaProps,\n        functionName: 'migration-producer',\n        entry: path.join(lambdasRootDir, 'producer', 'index.ts'),\n        role: lambdaRole,\n      });\n\n      const consumerLambda = new cdk.aws_lambda_nodejs.NodejsFunction(this, 'migrationConsumerLambda', {\n        ...lambdaProps,\n        functionName: 'migration-consumer',\n        entry: path.join(lambdasRootDir, 'consumer', 'index.ts'),\n        role: lambdaRole,\n        reservedConcurrentExecutions: consumerConcurrency,\n      });\n\n      consumerLambda.addEventSource(\n        new cdk.aws_lambda_event_sources.SqsEventSource(migrationQueue, {\n          maxConcurrency: consumerConcurrency,\n          reportBatchItemFailures: true,\n        })\n      );\n\n      migrationQueue.grantSendMessages(producerLambda);\n      migrationQueue.grantConsumeMessages(consumerLambda);\n\n      const artifactsBucket = new cdk.aws_s3.Bucket(this, 'migrationArtifactsBucket', {\n        bucketName: `glicogh-healthcare-migration-${buildConfig.envName}-${buildConfig.aws.account}`,\n        blockPublicAccess: cdk.aws_s3.BlockPublicAccess.BLOCK_ALL,\n        encryption: cdk.aws_s3.BucketEncryption.S3_MANAGED,\n        enforceSSL: true,\n        removalPolicy: cdk.RemovalPolicy.RETAIN,\n        lifecycleRules: [{ id: 'expire-backups', prefix: 'backups/', expiration: cdk.Duration.days(30) }],\n      });\n\n      const verifierLambda = new cdk.aws_lambda_nodejs.NodejsFunction(this, 'migrationVerifierLambda', {\n        ...lambdaProps,\n        functionName: 'migration-verifier',\n        entry: path.join(lambdasRootDir, 'verifier', 'index.ts'),\n        role: lambdaRole,\n      });\n      artifactsBucket.grantPut(verifierLambda);\n\n      const scriptsRunner = new MigrationScriptsRunner(this, 'migrationScriptsRunner', {\n        vpc,\n        artifactsBucket,\n      });\n\n      new MigrationStateMachine(this, 'migrationStateMachine', {\n        producer: producerLambda,\n        verifier: verifierLambda,\n        queue: migrationQueue,\n        cluster: scriptsRunner.cluster,\n        taskDefinition: scriptsRunner.taskDefinition,\n        container: scriptsRunner.container,\n        securityGroup: scriptsRunner.securityGroup,\n        artifactsBucket,\n      });\n    }\n  }\n}\n"]}

package/dist/util/initCdkStack.js

@@ -16,6 +16,7 @@ const microservice_portal_1 = require("../lib/microservice-portal");
 const microservice_infra_auth_1 = require("../lib/microservice-infra-auth");
 const microservice_migration_1 = require("../lib/microservice-migration");
 const microservice_clickhouse_1 = require("../lib/microservice-clickhouse");
+const common_1 = require("../@types/common");
 function initCdkStack() {
     const app = new cdk.App();
     const buildConfig = (0, initBuildConfig_1.initBuildConfig)(app);
@@ -54,24 +55,38 @@ function initCdkStack() {
         });
     }
     else {
-        new microservice_network_1.MicroserviceNetwork(app, 'MicroserviceNetwork', {
-            env: buildConfig.aws,
-        });
-        new microservice_infra_auth_1.MicroserviceInfraAuth(app, 'MicroserviceInfraAuth', {
-            env: buildConfig.aws,
-        });
-        new microservice_redis_1.MicroserviceRedis(app, `MicroserviceRedis${buildConfig.formattedBuildId ? '-' + buildConfig.formattedBuildId : ''}`, {
-            env: buildConfig.aws,
-        });
-        new microservice_mysql_1.MicroserviceMySql(app, `MicroserviceMySQL${buildConfig.formattedBuildId ? '-' + buildConfig.formattedBuildId : ''}`, {
-            env: buildConfig.aws,
-        });
-        new microservice_clickhouse_1.MicroserviceClickHouse(app, `MicroserviceClickHouse${buildConfig.formattedBuildId ? '-' + buildConfig.formattedBuildId : ''}`, {
-            env: buildConfig.aws,
-        });
-        new microservice_migration_1.MicroserviceMigration(app, 'MicroserviceMigration', {
-            env: buildConfig.aws,
-        });
+        const sharedStacks = {
+            network: () => {
+                new microservice_network_1.MicroserviceNetwork(app, 'MicroserviceNetwork', { env: buildConfig.aws });
+            },
+            'infra-auth': () => {
+                new microservice_infra_auth_1.MicroserviceInfraAuth(app, 'MicroserviceInfraAuth', { env: buildConfig.aws });
+            },
+            redis: () => {
+                new microservice_redis_1.MicroserviceRedis(app, `MicroserviceRedis${buildConfig.formattedBuildId ? '-' + buildConfig.formattedBuildId : ''}`, { env: buildConfig.aws });
+            },
+            mysql: () => {
+                new microservice_mysql_1.MicroserviceMySql(app, `MicroserviceMySQL${buildConfig.formattedBuildId ? '-' + buildConfig.formattedBuildId : ''}`, { env: buildConfig.aws });
+            },
+            clickhouse: () => {
+                new microservice_clickhouse_1.MicroserviceClickHouse(app, `MicroserviceClickHouse${buildConfig.formattedBuildId ? '-' + buildConfig.formattedBuildId : ''}`, {
+                    env: buildConfig.aws,
+                });
+            },
+            migration: () => {
+                new microservice_migration_1.MicroserviceMigration(app, 'MicroserviceMigration', { env: buildConfig.aws });
+            },
+        };
+        const sharedService = common_1.OtherCDKServiceList.find((service) => service === buildConfig.serviceName && service in sharedStacks);
+        if (sharedService) {
+            sharedStacks[sharedService]();
+        }
+        else if (!buildConfig.serviceName) {
+            Object.values(sharedStacks).forEach((createStack) => createStack());
+        }
+        else {
+            throw new Error(`Unknown service '${buildConfig.serviceName}'. Shared stacks: ${Object.keys(sharedStacks).join(', ')}`);
+        }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initCdkStack.js","sourceRoot":"","sources":["../../util/initCdkStack.ts"],"names":[],"mappings":"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","sourcesContent":["import 'source-map-support/register';\nimport * as cdk from 'aws-cdk-lib';\nimport { initBuildConfig } from './initBuildConfig';\nimport { addRepoToTags, applyTags } from './applyTags';\nimport { MicroserviceLaravelBased } from '../lib/microservice-laravel-based';\nimport { MicroserviceNetwork } from '../lib/microservice-network';\nimport { MicroserviceApiGateway } from '../lib/microservice-api-gateway';\nimport { MicroserviceRedis } from '../lib/microservice-redis';\nimport { MicroserviceNotificationService } from '../lib/microservice-notification-service';\nimport { isLaravelBased } from './isLaravelBased';\nimport { MicroserviceMySql } from '../lib/microservice-mysql';\nimport { MicroservicePortal } from '../lib/microservice-portal';\nimport { MicroserviceInfraAuth } from '../lib/microservice-infra-auth';\nimport { MicroserviceMigration } from '../lib/microservice-migration';\nimport { MicroserviceClickHouse } from '../lib/microservice-clickhouse';\nimport { OtherCDKServiceList } from '../@types/common';\n\nexport function initCdkStack() {\n  const app = new cdk.App();\n  const buildConfig = initBuildConfig(app);\n  applyTags(app);\n\n  if (isLaravelBased()) {\n    addRepoToTags(app);\n    new MicroserviceLaravelBased(app, `MicroserviceLaravelBased-${buildConfig.serviceName}-${buildConfig.formattedBuildId}`, {\n      env: buildConfig.aws,\n      /* If you don't specify 'env', this stack will be environment-agnostic.\n       * Account/Region-dependent features and context lookups will not work,\n       * but a single synthesized template can be deployed anywhere. */\n\n      /* Uncomment the next line to specialize this stack for the AWS Account\n       * and Region that are implied by the current CLI configuration. */\n      // env: { account: process.env.CDK_DEFAULT_ACCOUNT, region: process.env.CDK_DEFAULT_REGION },\n\n      /* Uncomment the next line if you know exactly what Account and Region you\n       * want to deploy the stack to. */\n      // env: { account: '123456789012', region: 'us-east-1' },\n\n      /* For more information, see https://docs.aws.amazon.com/cdk/latest/guide/environments.html */\n    });\n  } else if (buildConfig.serviceName === 'notification') {\n    addRepoToTags(app);\n    new MicroserviceNotificationService(app, `MicroserviceNotificationService-${buildConfig.formattedBuildId}`, {\n      env: buildConfig.aws,\n    });\n  } else if (buildConfig.serviceName === 'api-gateway') {\n    new MicroserviceApiGateway(app, `MicroserviceApiGateway${buildConfig.formattedBuildId ? '-' + buildConfig.formattedBuildId : ''}`, {\n      env: buildConfig.aws,\n    });\n  } else if (buildConfig.serviceName === 'portal') {\n    addRepoToTags(app);\n    new MicroservicePortal(app, `MicroservicePortal${buildConfig.formattedBuildId ? '-' + buildConfig.formattedBuildId : ''}`, {\n      env: buildConfig.aws,\n    });\n  } else {\n    const sharedStacks = {\n      network: () => {\n        new MicroserviceNetwork(app, 'MicroserviceNetwork', { env: buildConfig.aws });\n      },\n      'infra-auth': () => {\n        new MicroserviceInfraAuth(app, 'MicroserviceInfraAuth', { env: buildConfig.aws });\n      },\n      redis: () => {\n        new MicroserviceRedis(app, `MicroserviceRedis${buildConfig.formattedBuildId ? '-' + buildConfig.formattedBuildId : ''}`, { env: buildConfig.aws });\n      },\n      mysql: () => {\n        new MicroserviceMySql(app, `MicroserviceMySQL${buildConfig.formattedBuildId ? '-' + buildConfig.formattedBuildId : ''}`, { env: buildConfig.aws });\n      },\n      clickhouse: () => {\n        new MicroserviceClickHouse(app, `MicroserviceClickHouse${buildConfig.formattedBuildId ? '-' + buildConfig.formattedBuildId : ''}`, {\n          env: buildConfig.aws,\n        });\n      },\n      migration: () => {\n        new MicroserviceMigration(app, 'MicroserviceMigration', { env: buildConfig.aws });\n      },\n    };\n\n    const sharedService = OtherCDKServiceList.find(\n      (service): service is keyof typeof sharedStacks => service === buildConfig.serviceName && service in sharedStacks\n    );\n    if (sharedService) {\n      sharedStacks[sharedService]();\n    } else if (!buildConfig.serviceName) {\n      Object.values(sharedStacks).forEach((createStack) => createStack());\n    } else {\n      throw new Error(`Unknown service '${buildConfig.serviceName}'. Shared stacks: ${Object.keys(sharedStacks).join(', ')}`);\n    }\n  }\n}\n"]}

package/dist/util/migration.d.ts

@@ -1,2 +1,6 @@
-import { Stack } from 'aws-cdk-lib';
+import { aws_ecs, Stack } from 'aws-cdk-lib';
 export declare function getLambdaEnvs(scope: Stack): Record<string, string>;
+export declare function getEcsEnvs(scope: Stack): {
+    environment: Record<string, string>;
+    secrets: Record<string, aws_ecs.Secret>;
+};

package/dist/util/migration.js

@@ -1,61 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLambdaEnvs = getLambdaEnvs;
+exports.getEcsEnvs = getEcsEnvs;
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const initBuildConfig_1 = require("./initBuildConfig");
+const SSM_STRING_VARS = [
+    'global:DB_HOST',
+    'global:DB_USERNAME',
+    'global:DB_PORT',
+    'global:REDIS_HOST',
+    'global:REDIS_PORT',
+    'portal:ACCOUNT_SERVICE_URL',
+    'portal:PLAN_SERVICE_URL',
+    'portal:POLICY_SERVICE_URL',
+    'portal:CLAIMS_SERVICE_URL',
+    'migration:MIGRATION_FETCH_SIZE',
+    'migration:DEFAULT_INSURER_ID',
+    'migration:DEFAULT_INSURER_ROLE_ID',
+    'migration:DB_DATABASE',
+    'migration:DB_POOL_MAX',
+    'migration:MIGRATION_PRODUCER_CONCURRENCY',
+    'migration:MIGRATION_CONSUMER_CONCURRENCY',
+    'migration:MIGRATION_QUEUE_SHARDS',
+    'migration:BENEFICIARY_PHOTOS_URL',
+    'migration:TPA_BENEFICIARY_PHOTOS_URL',
+    'migration:EXPIRED_POLICY_GRACE_PERIOD_MONTHS',
+    'migration:CLAIMS_BENEFIT_TYPE_FALLBACK',
+    'migration:HTTP_MAX_SOCKETS',
+    'migration:REQUEST_TIMEOUT_MS',
+    'migration:REQUEST_MAX_RETRIES',
+];
+const SSM_SECURE_VARS = ['global:DB_PASSWORD', 'migration:MIGRATION_API_KEY'];
 function getLambdaEnvs(scope) {
-    const ssmStringVars = [
-        'global:DB_HOST',
-        'global:DB_USERNAME',
-        'global:DB_PORT',
-        'global:REDIS_HOST',
-        'global:REDIS_PORT',
-        'portal:ACCOUNT_SERVICE_URL',
-        'portal:PLAN_SERVICE_URL',
-        'portal:POLICY_SERVICE_URL',
-        'portal:CLAIMS_SERVICE_URL',
-        'migration:MIGRATION_FETCH_SIZE',
-        'migration:DEFAULT_INSURER_ID',
-        'migration:DEFAULT_INSURER_ROLE_ID',
-        'migration:DB_DATABASE',
-        'migration:DB_POOL_MAX',
-        'migration:MIGRATION_PRODUCER_CONCURRENCY',
-        'migration:MIGRATION_CONSUMER_CONCURRENCY',
-        'migration:MIGRATION_QUEUE_SHARDS',
-        'migration:BENEFICIARY_PHOTOS_URL',
-        'migration:TPA_BENEFICIARY_PHOTOS_URL',
-        'migration:EXPIRED_POLICY_GRACE_PERIOD_MONTHS',
-        'migration:CLAIMS_BENEFIT_TYPE_FALLBACK',
-        'migration:CLAIMS_STATUS_HELD',
-        'migration:HTTP_MAX_SOCKETS',
-        'migration:REQUEST_TIMEOUT_MS',
-        'migration:REQUEST_MAX_RETRIES',
-    ];
-    const ssmSecureVars = ['global:DB_PASSWORD', 'migration:MIGRATION_API_KEY'];
     const vars = {
-        ...lookupSsmParameters(scope, ssmStringVars),
-        ...lookupSsmParameters(scope, ssmSecureVars, true),
+        ...lookupSsmParameters(scope, SSM_STRING_VARS),
+        ...lookupSsmParameters(scope, SSM_SECURE_VARS, true),
         ENV: String(initBuildConfig_1.buildConfig?.envName),
     };
     return vars;
 }
-function lookupSsmParameters(scope, keys, secure = false) {
-    const env = initBuildConfig_1.buildConfig?.envName;
-    const variables = [];
-    for (const key of keys) {
-        const namespace = key.substring(0, key.indexOf(':'));
-        const name = key.substring(namespace.length + 1);
-        const path = `/${env}/microservices/${namespace}/env/${name}`;
-        variables.push({ path, name });
+function getEcsEnvs(scope) {
+    const environment = {
+        ...lookupSsmParameters(scope, SSM_STRING_VARS),
+        ENV: String(initBuildConfig_1.buildConfig?.envName),
+    };
+    const secrets = {};
+    for (const key of SSM_SECURE_VARS) {
+        const name = ssmName(key);
+        secrets[name] = aws_cdk_lib_1.aws_ecs.Secret.fromSsmParameter(aws_cdk_lib_1.aws_ssm.StringParameter.fromSecureStringParameterAttributes(scope, `EcsSecret${name}`, {
+            parameterName: ssmPath(key),
+        }));
     }
-    return variables.reduce((acc, item) => {
+    return { environment, secrets };
+}
+function ssmNamespace(key) {
+    return key.substring(0, key.indexOf(':'));
+}
+function ssmName(key) {
+    return key.substring(key.indexOf(':') + 1);
+}
+function ssmPath(key) {
+    const env = initBuildConfig_1.buildConfig?.envName;
+    return `/${env}/microservices/${ssmNamespace(key)}/env/${ssmName(key)}`;
+}
+function lookupSsmParameters(scope, keys, secure = false) {
+    return keys.reduce((acc, key) => {
         if (secure) {
-            acc[item.name] = `ssm://${item.path}`;
+            acc[ssmName(key)] = `ssm://${ssmPath(key)}`;
         }
         else {
-            acc[item.name] = aws_cdk_lib_1.aws_ssm.StringParameter.valueFromLookup(scope, item.path);
+            acc[ssmName(key)] = aws_cdk_lib_1.aws_ssm.StringParameter.valueFromLookup(scope, ssmPath(key));
         }
         return acc;
     }, {});
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glicogh/healthcare-cdk",
-  "version": "0.1.88",
+  "version": "0.1.89",
   "description": "CDK automations",
   "bin": {
     "cdk": "bin/cdk.js"
@@ -17,6 +17,7 @@
     "@types/jest": "^29.5.12",
     "@types/node": "20.14.9",
     "aws-cdk": "^2.155.0",
+    "esbuild": "^0.21.5",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.5",
     "ts-node": "^10.9.2",