@glicogh/healthcare-cdk 0.1.88 → 0.1.90

package/.env.example

@@ -5,6 +5,8 @@ COMPANY_NAME=glico
 AWS_REGION=eu-west-2
 AWS_ACCOUNT_ID=825765383017
 
+# Optional local overrides go in .env.local (gitignored), e.g. MIGRATION_REPO_PATH=/path/to/migration
+
 EC2_REDIS_INSTANCE_TYPE=t4g.nano
 EC2_REDIS_INSTANCE_STORAGE_SIZE=
 EC2_REDIS_INSTANCE_STORAGE_TYPE=gp3

package/README.md

@@ -91,13 +91,87 @@ 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:
+
+The stack also provisions the `legacy-s3-backups` EventBridge bus (`cdk/constructs/legacy-s3-backups-bus.ts`) for legacy S3 backup events forwarded from the main account (`169555392631`, see `legacyS3BackupsMainAccountId`). The bus allows `events:PutEvents` from that account, has CloudWatch logging enabled at TRACE/FULL detail delivered through vended logs to `/aws/vendedlogs/events/event-bus/legacy-s3-backups`, and a rule that logs every event payload to the `legacy-s3-backups` log group. The bus ARN is exported as the `legacy-s3-backups-arn` output.
+
+The bus also auto-starts the migration orchestrator from source archives landing in `s3://glicogh-pether-backup` (`legacyBackupBucketName`, read cross-account by the ECS scripts task role). Triggers are declared once in CDK as `MIGRATION_TRIGGERS` (`{ name, prefix, options, once }`) and passed to the `migration-runner` Lambda; the `legacy-s3-backups-migration-runner` rule forwards every event on the bus to it, and the runner applies the trigger policy itself. Today: `daily_backups/*.tar.gz` starts a delta run (`restoreMode: 'delta', affected: true, precomputeMode: 'incremental'`), and the first `weekly_backups/*.tar.gz` ever starts a fresh full run (`resetTracking: true, precomputeMode: 'full'`, `once: true`) — later weekly events are skipped until the SSM marker `/<env>/microservices/migration/triggers/weekly` is deleted. Every trigger also skips while an orchestrator execution is already RUNNING, and derives the execution name from the object key for dedupe.
+
+Daily runs are **deltas**: the payload adds `restoreMode: 'delta', affected: true`, so `s1-restore-delta` inserts the changed rows into the persistent legacy tables (no DROP/CREATE, duplicate key updates the row) and skips `s2-migrations`; `s4b-resolve-affected` then maps the changed rows (`migration_affected_source`) to resource ids (`migration_affected`, including claim `batch_key`s via `claim_batches.sibling_claim_ids`), and each resource step runs a targeted pass with `skipMigrated: false` so the target APIs receive updates, followed by `migration-clear-affected` for that resource. Weekly runs keep the full restore → schema → `skipMigrated` top-up path. Daily precompute is incremental (`precomputeMode: 'incremental'`): `s3-disease-lookups` and `s4-claim-batches` update only the batches/disease mappings touched by `migration_affected_source`, instead of truncating and rescanning; weekly/full runs use `precomputeMode: 'full'`. The restore ECS task downloads the archive, extracts it (top-level CSV folder or flat), and runs `restore-legacy-backup`.
+
+- **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. The precompute steps (`diseases`, `claim-batches`) always run when a restore runs; without one they only run when selected via `runPrecompute`. Their mode comes from `precomputeMode` (`incremental` updates only the delta's changed rows; `full` truncates and rebuilds).
+- **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>`):
+
+```
+aws s3 sync data/legacy-backup s3://glicogh-healthcare-migration-uat-825765383017/backups/<runId>/
+```
+
+**Start an execution** (all input fields are optional; defaults shown):
+
+```json
+{
+  "backupS3Uri": "s3://glicogh-healthcare-migration-uat-825765383017/backups/<runId>/",
+  "resetTracking": false,
+  "restore": true,
+  "runPrecompute": [],
+  "skipMigrated": true,
+  "refresh": false,
+  "ignoreProgress": false,
+  "fromStep": ""
+}
+```
+
+- `backupS3Uri` is required only when the restore step runs (omit it with `restore: false` or a `fromStep` past restore).
+- `resetTracking: true` truncates `migrated`/`disease_lookup`/`claim_batches` and clears the Redis cursors before restoring; it cannot be combined with `restore: false`.
+- `restore: false` runs against the existing legacy DB (skips the reset/restore steps).
+- `runPrecompute` selects which precompute steps (`"diseases"`, `"claim-batches"`) run when `restore` is false; `true` means all, `[]`/`false` means none (default `[]`). A restore always runs both precomputes. `precomputeMode` (`"full"` default, or `"incremental"`) selects their mode independently of `restoreMode`.
+- `skipMigrated: true` (default) publishes only records without a `migrated` row — a completed step ends immediately and advances its cursor; `skipMigrated: false` publishes from the cursor onward (existing records are PUT-updated).
+- `refresh: true` (requires `skipMigrated: false`) republishes every record from the start, so migrated records are PUT-updated; combine with `fromStep` to scope it to one step.
+- `ignoreProgress: true` clears the recorded progress marker and re-evaluates the start point (`resetTracking`/`restore`).
+- `fromStep` jumps to a step and records the step before it as the progress baseline.
 
 ```
-cdk --profile glicogh-uat --context env=uat deploy MicroserviceNetwork
+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**: the state machine records the last completed step in the SSM parameter `/<env>/microservices/migration/orchestrator/progress` (imported by name, not managed by CloudFormation; holds the last completed step id, or `none` when cleared). Stop the execution and re-invoke with the same input — it resumes at the step after the recorded one (skipped precompute steps are recorded too, so a resume continues past them). `ignoreProgress: true` clears the marker and re-evaluates the start point; `fromStep` jumps explicitly and writes the preceding step as the baseline. Every step is idempotent and cursor-backed; with the default `skipMigrated: true` a fully-migrated step returns immediately (`endReached`, cursor advanced). Guards fail the execution instead of looping forever: 2,000 producer invocations per pass, 4,000 drain checks (30-second 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. `resetTracking: 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/legacy-s3-backups-bus.d.ts

@@ -0,0 +1,23 @@
+import * as events from 'aws-cdk-lib/aws-events';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as logs from 'aws-cdk-lib/aws-logs';
+import { Construct } from 'constructs';
+export interface LegacyS3BackupsBusProps {
+    readonly busName: string;
+    readonly allowedAccountIds: string[];
+}
+export interface MigrationTrigger {
+    readonly name: string;
+    readonly prefix: string;
+    readonly options: Record<string, unknown>;
+    readonly once?: boolean;
+}
+export declare class LegacyS3BackupsBus extends Construct {
+    readonly bus: events.EventBus;
+    readonly ruleLogGroup: logs.LogGroup;
+    readonly vendedLogGroup: logs.LogGroup;
+    private readonly busName;
+    constructor(scope: Construct, id: string, props: LegacyS3BackupsBusProps);
+    addMigrationRunner(target: lambda.IFunction): void;
+    private configureVendedLogDelivery;
+}

package/dist/constructs/legacy-s3-backups-bus.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyS3BackupsBus = void 0;
+const cdk = require("aws-cdk-lib");
+const events = require("aws-cdk-lib/aws-events");
+const eventsTargets = require("aws-cdk-lib/aws-events-targets");
+const iam = require("aws-cdk-lib/aws-iam");
+const logs = require("aws-cdk-lib/aws-logs");
+const constructs_1 = require("constructs");
+class LegacyS3BackupsBus extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.busName = props.busName;
+        this.ruleLogGroup = new logs.LogGroup(this, 'RuleLogGroup', {
+            logGroupName: props.busName,
+            retention: logs.RetentionDays.THREE_MONTHS,
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+        });
+        this.vendedLogGroup = new logs.LogGroup(this, 'VendedLogGroup', {
+            logGroupName: `/aws/vendedlogs/events/event-bus/${props.busName}`,
+            retention: logs.RetentionDays.THREE_MONTHS,
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+        });
+        this.bus = new events.EventBus(this, 'EventBus', {
+            eventBusName: props.busName,
+            logConfig: {
+                level: events.Level.TRACE,
+                includeDetail: events.IncludeDetail.FULL,
+            },
+        });
+        this.bus.addToResourcePolicy(new iam.PolicyStatement({
+            sid: 'AllowMainAccountPutEvents',
+            effect: iam.Effect.ALLOW,
+            principals: props.allowedAccountIds.map((accountId) => new iam.AccountPrincipal(accountId)),
+            actions: ['events:PutEvents'],
+            resources: [this.bus.eventBusArn],
+        }));
+        new events.Rule(this, 'LogAllEventsRule', {
+            ruleName: `${props.busName}-log-all-events`,
+            description: `Logs every event published to the ${props.busName} event bus to the ${props.busName} CloudWatch log group`,
+            eventBus: this.bus,
+            eventPattern: { source: events.Match.exists() },
+            targets: [new eventsTargets.CloudWatchLogGroup(this.ruleLogGroup)],
+        });
+        this.configureVendedLogDelivery(props.busName);
+    }
+    // Catch-all: the bus policy already restricts senders to the allowed
+    // accounts, and the migration runner applies the MIGRATION_TRIGGERS policy
+    // (bucket, archive suffix, size, prefix, once) to every forwarded event.
+    addMigrationRunner(target) {
+        new events.Rule(this, 'MigrationRunnerRule', {
+            ruleName: `${this.busName}-migration-runner`,
+            description: 'Starts the migration orchestrator from source-archive events forwarded to the bus',
+            eventBus: this.bus,
+            eventPattern: { source: events.Match.exists() },
+            targets: [new eventsTargets.LambdaFunction(target)],
+        });
+    }
+    configureVendedLogDelivery(busName) {
+        const stack = cdk.Stack.of(this);
+        const { account, region, partition } = stack;
+        const deliveryPolicy = new logs.CfnResourcePolicy(this, 'LogDeliveryResourcePolicy', {
+            policyName: `${busName}-log-delivery`,
+            policyDocument: stack.toJsonString({
+                Version: '2012-10-17',
+                Statement: [
+                    {
+                        Sid: 'AWSLogDeliveryWrite',
+                        Effect: 'Allow',
+                        Principal: { Service: 'delivery.logs.amazonaws.com' },
+                        Action: ['logs:CreateLogStream', 'logs:PutLogEvents'],
+                        Resource: `${this.vendedLogGroup.logGroupArn}:log-stream:*`,
+                        Condition: {
+                            StringEquals: { 'aws:SourceAccount': account },
+                            ArnLike: { 'aws:SourceArn': `arn:${partition}:logs:${region}:${account}:delivery-source:*` },
+                        },
+                    },
+                ],
+            }),
+        });
+        const destination = new logs.CfnDeliveryDestination(this, 'LogDeliveryDestination', {
+            name: `${busName}-logs`,
+            destinationResourceArn: this.vendedLogGroup.logGroupArn,
+        });
+        const logTypes = [
+            { logType: 'INFO_LOGS', id: 'Info', suffix: 'info' },
+            { logType: 'ERROR_LOGS', id: 'Error', suffix: 'error' },
+            { logType: 'TRACE_LOGS', id: 'Trace', suffix: 'trace' },
+        ];
+        let previousDelivery;
+        for (const { logType, id, suffix } of logTypes) {
+            const source = new logs.CfnDeliverySource(this, `DeliverySource${id}`, {
+                name: `${busName}-${suffix}`,
+                logType,
+                resourceArn: this.bus.eventBusArn,
+            });
+            const delivery = new logs.CfnDelivery(this, `Delivery${id}`, {
+                deliverySourceName: source.name,
+                deliveryDestinationArn: destination.attrArn,
+            });
+            delivery.addDependency(deliveryPolicy);
+            delivery.addDependency(source);
+            if (previousDelivery) {
+                delivery.addDependency(previousDelivery);
+            }
+            previousDelivery = delivery;
+        }
+    }
+}
+exports.LegacyS3BackupsBus = LegacyS3BackupsBus;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"legacy-s3-backups-bus.js","sourceRoot":"","sources":["../../constructs/legacy-s3-backups-bus.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as events from 'aws-cdk-lib/aws-events';\nimport * as eventsTargets from 'aws-cdk-lib/aws-events-targets';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\n\nexport interface LegacyS3BackupsBusProps {\n  readonly busName: string;\n  readonly allowedAccountIds: string[];\n}\n\n// One migration trigger: a source-archive prefix plus the orchestrator input\n// options it maps to. The migration runner applies this list to every event\n// the bus forwards.\nexport interface MigrationTrigger {\n  readonly name: string;\n  readonly prefix: string;\n  readonly options: Record<string, unknown>;\n  readonly once?: boolean;\n}\n\nexport class LegacyS3BackupsBus extends Construct {\n  public readonly bus: events.EventBus;\n  public readonly ruleLogGroup: logs.LogGroup;\n  public readonly vendedLogGroup: logs.LogGroup;\n\n  private readonly busName: string;\n\n  constructor(scope: Construct, id: string, props: LegacyS3BackupsBusProps) {\n    super(scope, id);\n\n    this.busName = props.busName;\n\n    this.ruleLogGroup = new logs.LogGroup(this, 'RuleLogGroup', {\n      logGroupName: props.busName,\n      retention: logs.RetentionDays.THREE_MONTHS,\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n    });\n\n    this.vendedLogGroup = new logs.LogGroup(this, 'VendedLogGroup', {\n      logGroupName: `/aws/vendedlogs/events/event-bus/${props.busName}`,\n      retention: logs.RetentionDays.THREE_MONTHS,\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n    });\n\n    this.bus = new events.EventBus(this, 'EventBus', {\n      eventBusName: props.busName,\n      logConfig: {\n        level: events.Level.TRACE,\n        includeDetail: events.IncludeDetail.FULL,\n      },\n    });\n\n    this.bus.addToResourcePolicy(\n      new iam.PolicyStatement({\n        sid: 'AllowMainAccountPutEvents',\n        effect: iam.Effect.ALLOW,\n        principals: props.allowedAccountIds.map((accountId) => new iam.AccountPrincipal(accountId)),\n        actions: ['events:PutEvents'],\n        resources: [this.bus.eventBusArn],\n      })\n    );\n\n    new events.Rule(this, 'LogAllEventsRule', {\n      ruleName: `${props.busName}-log-all-events`,\n      description: `Logs every event published to the ${props.busName} event bus to the ${props.busName} CloudWatch log group`,\n      eventBus: this.bus,\n      eventPattern: { source: events.Match.exists() },\n      targets: [new eventsTargets.CloudWatchLogGroup(this.ruleLogGroup)],\n    });\n\n    this.configureVendedLogDelivery(props.busName);\n  }\n\n  // Catch-all: the bus policy already restricts senders to the allowed\n  // accounts, and the migration runner applies the MIGRATION_TRIGGERS policy\n  // (bucket, archive suffix, size, prefix, once) to every forwarded event.\n  public addMigrationRunner(target: lambda.IFunction): void {\n    new events.Rule(this, 'MigrationRunnerRule', {\n      ruleName: `${this.busName}-migration-runner`,\n      description: 'Starts the migration orchestrator from source-archive events forwarded to the bus',\n      eventBus: this.bus,\n      eventPattern: { source: events.Match.exists() },\n      targets: [new eventsTargets.LambdaFunction(target)],\n    });\n  }\n\n  private configureVendedLogDelivery(busName: string): void {\n    const stack = cdk.Stack.of(this);\n    const { account, region, partition } = stack;\n\n    const deliveryPolicy = new logs.CfnResourcePolicy(this, 'LogDeliveryResourcePolicy', {\n      policyName: `${busName}-log-delivery`,\n      policyDocument: stack.toJsonString({\n        Version: '2012-10-17',\n        Statement: [\n          {\n            Sid: 'AWSLogDeliveryWrite',\n            Effect: 'Allow',\n            Principal: { Service: 'delivery.logs.amazonaws.com' },\n            Action: ['logs:CreateLogStream', 'logs:PutLogEvents'],\n            Resource: `${this.vendedLogGroup.logGroupArn}:log-stream:*`,\n            Condition: {\n              StringEquals: { 'aws:SourceAccount': account },\n              ArnLike: { 'aws:SourceArn': `arn:${partition}:logs:${region}:${account}:delivery-source:*` },\n            },\n          },\n        ],\n      }),\n    });\n\n    const destination = new logs.CfnDeliveryDestination(this, 'LogDeliveryDestination', {\n      name: `${busName}-logs`,\n      destinationResourceArn: this.vendedLogGroup.logGroupArn,\n    });\n\n    const logTypes = [\n      { logType: 'INFO_LOGS', id: 'Info', suffix: 'info' },\n      { logType: 'ERROR_LOGS', id: 'Error', suffix: 'error' },\n      { logType: 'TRACE_LOGS', id: 'Trace', suffix: 'trace' },\n    ];\n\n    let previousDelivery: logs.CfnDelivery | undefined;\n\n    for (const { logType, id, suffix } of logTypes) {\n      const source = new logs.CfnDeliverySource(this, `DeliverySource${id}`, {\n        name: `${busName}-${suffix}`,\n        logType,\n        resourceArn: this.bus.eventBusArn,\n      });\n\n      const delivery = new logs.CfnDelivery(this, `Delivery${id}`, {\n        deliverySourceName: source.name,\n        deliveryDestinationArn: destination.attrArn,\n      });\n\n      delivery.addDependency(deliveryPolicy);\n      delivery.addDependency(source);\n      if (previousDelivery) {\n        delivery.addDependency(previousDelivery);\n      }\n      previousDelivery = delivery;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,20 @@
+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;
+    migrationRepoPath?: string;
+    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,59 @@
+"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 ecrAssets = require("aws-cdk-lib/aws-ecr-assets");
+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',
+            // The task definition runs X86_64 Fargate; pin the image platform so a
+            // build from an arm64 host (e.g. a Mac) does not produce a mismatched
+            // image (exec format error on the entrypoint).
+            image: ecs.ContainerImage.fromAsset(props.migrationRepoPath ?? path.resolve('../../migration'), {
+                file: 'Dockerfile',
+                platform: ecrAssets.Platform.LINUX_AMD64,
+            }),
+            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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlncmF0aW9uLXNjcmlwdHMtcnVubmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vY29uc3RydWN0cy9taWdyYXRpb24tc2NyaXB0cy1ydW5uZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQW1DO0FBQ25DLDJDQUEyQztBQUMzQyx3REFBd0Q7QUFDeEQsMkNBQTJDO0FBQzNDLDZDQUE2QztBQUU3Qyw2QkFBNkI7QUFDN0IsMkNBQXVDO0FBQ3ZDLGlEQUErQztBQVkvQyw4RUFBOEU7QUFDOUUsNkVBQTZFO0FBQzdFLG9EQUFvRDtBQUNwRCxNQUFhLHNCQUF1QixTQUFRLHNCQUFTO0lBTW5ELFlBQVksS0FBZ0IsRUFBRSxFQUFVLEVBQUUsS0FBa0M7UUFDMUUsS0FBSyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsQ0FBQztRQUVqQixJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksR0FBRyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsU0FBUyxFQUFFO1lBQzlDLEdBQUcsRUFBRSxLQUFLLENBQUMsR0FBRztZQUNkLFdBQVcsRUFBRSxtQkFBbUI7U0FDakMsQ0FBQyxDQUFDO1FBRUgsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLEdBQUcsQ0FBQyxhQUFhLENBQUMsSUFBSSxFQUFFLGVBQWUsRUFBRTtZQUNoRSxHQUFHLEVBQUUsS0FBSyxDQUFDLEdBQUc7WUFDZCxpQkFBaUIsRUFBRSxzQkFBc0I7WUFDekMsV0FBVyxFQUFFLDZCQUE2QjtZQUMxQyxnQkFBZ0IsRUFBRSxJQUFJO1NBQ3ZCLENBQUMsQ0FBQztRQUVILElBQUksQ0FBQyxjQUFjLEdBQUcsSUFBSSxHQUFHLENBQUMscUJBQXFCLENBQUMsSUFBSSxFQUFFLGdCQUFnQixFQUFFO1lBQzFFLE1BQU0sRUFBRSxtQkFBbUI7WUFDM0IsR0FBRyxFQUFFLEtBQUssQ0FBQyxHQUFHLElBQUksSUFBSTtZQUN0QixjQUFjLEVBQUUsS0FBSyxDQUFDLGNBQWMsSUFBSSxJQUFJO1lBQzVDLG1CQUFtQixFQUFFLEtBQUssQ0FBQyxtQkFBbUIsSUFBSSxFQUFFO1lBQ3BELGVBQWUsRUFBRTtnQkFDZixlQUFlLEVBQUUsR0FBRyxDQUFDLGVBQWUsQ0FBQyxNQUFNO2dCQUMzQyxxQkFBcUIsRUFBRSxHQUFHLENBQUMscUJBQXFCLENBQUMsS0FBSzthQUN2RDtTQUNGLENBQUMsQ0FBQztRQUVILE1BQU0sRUFBRSxXQUFXLEVBQUUsT0FBTyxFQUFFLEdBQUcsSUFBQSxzQkFBVSxFQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7UUFFaEUsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsY0FBYyxDQUFDLFlBQVksQ0FBQyxTQUFTLEVBQUU7WUFDM0QsYUFBYSxFQUFFLFNBQVM7WUFDeEIsdUVBQXVFO1lBQ3ZFLHNFQUFzRTtZQUN0RSwrQ0FBK0M7WUFDL0MsS0FBSyxFQUFFLEdBQUcsQ0FBQyxjQUFjLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxpQkFBaUIsSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLGlCQUFpQixDQUFDLEVBQUU7Z0JBQzlGLElBQUksRUFBRSxZQUFZO2dCQUNsQixRQUFRLEVBQUUsU0FBUyxDQUFDLFFBQVEsQ0FBQyxXQUFXO2FBQ3pDLENBQUM7WUFDRixXQUFXO1lBQ1gsT0FBTztZQUNQLE9BQU8sRUFBRSxHQUFHLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQztnQkFDOUIsWUFBWSxFQUFFLG1CQUFtQjtnQkFDakMsWUFBWSxFQUFFLElBQUksQ0FBQyxhQUFhLENBQUMsU0FBUzthQUMzQyxDQUFDO1NBQ0gsQ0FBQyxDQUFDO1FBRUgsS0FBSyxDQUFDLGVBQWUsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxRQUFRLEVBQUUsR0FBRyxLQUFLLENBQUMsWUFBWSxJQUFJLFNBQVMsSUFBSSxDQUFDLENBQUM7SUFDeEcsQ0FBQztDQUNGO0FBckRELHdEQXFEQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGNkayBmcm9tICdhd3MtY2RrLWxpYic7XG5pbXBvcnQgKiBhcyBlYzIgZnJvbSAnYXdzLWNkay1saWIvYXdzLWVjMic7XG5pbXBvcnQgKiBhcyBlY3JBc3NldHMgZnJvbSAnYXdzLWNkay1saWIvYXdzLWVjci1hc3NldHMnO1xuaW1wb3J0ICogYXMgZWNzIGZyb20gJ2F3cy1jZGstbGliL2F3cy1lY3MnO1xuaW1wb3J0ICogYXMgbG9ncyBmcm9tICdhd3MtY2RrLWxpYi9hd3MtbG9ncyc7XG5pbXBvcnQgKiBhcyBzMyBmcm9tICdhd3MtY2RrLWxpYi9hd3MtczMnO1xuaW1wb3J0ICogYXMgcGF0aCBmcm9tICdwYXRoJztcbmltcG9ydCB7IENvbnN0cnVjdCB9IGZyb20gJ2NvbnN0cnVjdHMnO1xuaW1wb3J0IHsgZ2V0RWNzRW52cyB9IGZyb20gJy4uL3V0aWwvbWlncmF0aW9uJztcblxuZXhwb3J0IGludGVyZmFjZSBNaWdyYXRpb25TY3JpcHRzUnVubmVyUHJvcHMge1xuICB2cGM6IGVjMi5JVnBjO1xuICBhcnRpZmFjdHNCdWNrZXQ6IHMzLklCdWNrZXQ7XG4gIG1pZ3JhdGlvblJlcG9QYXRoPzogc3RyaW5nO1xuICBiYWNrdXBQcmVmaXg/OiBzdHJpbmc7XG4gIGNwdT86IG51bWJlcjtcbiAgbWVtb3J5TGltaXRNaUI/OiBudW1iZXI7XG4gIGVwaGVtZXJhbFN0b3JhZ2VHaUI/OiBudW1iZXI7XG59XG5cbi8vIE9uZS1zaG90IEZhcmdhdGUgdGFza3MgdGhhdCBydW4gdGhlIG1pZ3JhdGlvbiBzY3JpcHRzIChyZXN0b3JlLCBtaWdyYXRpb25zLFxuLy8gcHJlY29tcHV0ZS1kaXNlYXNlcywgcHJlY29tcHV0ZS1jbGFpbS1iYXRjaGVzLCByZXNldCkgdW5jaGFuZ2VkLiBUaGUgc3RhdGVcbi8vIG1hY2hpbmUgb3ZlcnJpZGVzIHRoZSBjb250YWluZXIgY29tbWFuZCBwZXIgc3RlcC5cbmV4cG9ydCBjbGFzcyBNaWdyYXRpb25TY3JpcHRzUnVubmVyIGV4dGVuZHMgQ29uc3RydWN0IHtcbiAgcHVibGljIHJlYWRvbmx5IGNsdXN0ZXI6IGVjcy5DbHVzdGVyO1xuICBwdWJsaWMgcmVhZG9ubHkgc2VjdXJpdHlHcm91cDogZWMyLlNlY3VyaXR5R3JvdXA7XG4gIHB1YmxpYyByZWFkb25seSB0YXNrRGVmaW5pdGlvbjogZWNzLkZhcmdhdGVUYXNrRGVmaW5pdGlvbjtcbiAgcHVibGljIHJlYWRvbmx5IGNvbnRhaW5lcjogZWNzLkNvbnRhaW5lckRlZmluaXRpb247XG5cbiAgY29uc3RydWN0b3Ioc2NvcGU6IENvbnN0cnVjdCwgaWQ6IHN0cmluZywgcHJvcHM6IE1pZ3JhdGlvblNjcmlwdHNSdW5uZXJQcm9wcykge1xuICAgIHN1cGVyKHNjb3BlLCBpZCk7XG5cbiAgICB0aGlzLmNsdXN0ZXIgPSBuZXcgZWNzLkNsdXN0ZXIodGhpcywgJ0NsdXN0ZXInLCB7XG4gICAgICB2cGM6IHByb3BzLnZwYyxcbiAgICAgIGNsdXN0ZXJOYW1lOiAnbWlncmF0aW9uLXNjcmlwdHMnLFxuICAgIH0pO1xuXG4gICAgdGhpcy5zZWN1cml0eUdyb3VwID0gbmV3IGVjMi5TZWN1cml0eUdyb3VwKHRoaXMsICdTZWN1cml0eUdyb3VwJywge1xuICAgICAgdnBjOiBwcm9wcy52cGMsXG4gICAgICBzZWN1cml0eUdyb3VwTmFtZTogJ01pZ3JhdGlvbi1TY3JpcHRzLVNHJyxcbiAgICAgIGRlc2NyaXB0aW9uOiAnTWlncmF0aW9uIHNjcmlwdHMgRUNTIHRhc2tzJyxcbiAgICAgIGFsbG93QWxsT3V0Ym91bmQ6IHRydWUsXG4gICAgfSk7XG5cbiAgICB0aGlzLnRhc2tEZWZpbml0aW9uID0gbmV3IGVjcy5GYXJnYXRlVGFza0RlZmluaXRpb24odGhpcywgJ1Rhc2tEZWZpbml0aW9uJywge1xuICAgICAgZmFtaWx5OiAnbWlncmF0aW9uLXNjcmlwdHMnLFxuICAgICAgY3B1OiBwcm9wcy5jcHUgPz8gNDA5NixcbiAgICAgIG1lbW9yeUxpbWl0TWlCOiBwcm9wcy5tZW1vcnlMaW1pdE1pQiA/PyA4MTkyLFxuICAgICAgZXBoZW1lcmFsU3RvcmFnZUdpQjogcHJvcHMuZXBoZW1lcmFsU3RvcmFnZUdpQiA/PyAyMSxcbiAgICAgIHJ1bnRpbWVQbGF0Zm9ybToge1xuICAgICAgICBjcHVBcmNoaXRlY3R1cmU6IGVjcy5DcHVBcmNoaXRlY3R1cmUuWDg2XzY0LFxuICAgICAgICBvcGVyYXRpbmdTeXN0ZW1GYW1pbHk6IGVjcy5PcGVyYXRpbmdTeXN0ZW1GYW1pbHkuTElOVVgsXG4gICAgICB9LFxuICAgIH0pO1xuXG4gICAgY29uc3QgeyBlbnZpcm9ubWVudCwgc2VjcmV0cyB9ID0gZ2V0RWNzRW52cyhjZGsuU3RhY2sub2YodGhpcykpO1xuXG4gICAgdGhpcy5jb250YWluZXIgPSB0aGlzLnRhc2tEZWZpbml0aW9uLmFkZENvbnRhaW5lcignc2NyaXB0cycsIHtcbiAgICAgIGNvbnRhaW5lck5hbWU6ICdzY3JpcHRzJyxcbiAgICAgIC8vIFRoZSB0YXNrIGRlZmluaXRpb24gcnVucyBYODZfNjQgRmFyZ2F0ZTsgcGluIHRoZSBpbWFnZSBwbGF0Zm9ybSBzbyBhXG4gICAgICAvLyBidWlsZCBmcm9tIGFuIGFybTY0IGhvc3QgKGUuZy4gYSBNYWMpIGRvZXMgbm90IHByb2R1Y2UgYSBtaXNtYXRjaGVkXG4gICAgICAvLyBpbWFnZSAoZXhlYyBmb3JtYXQgZXJyb3Igb24gdGhlIGVudHJ5cG9pbnQpLlxuICAgICAgaW1hZ2U6IGVjcy5Db250YWluZXJJbWFnZS5mcm9tQXNzZXQocHJvcHMubWlncmF0aW9uUmVwb1BhdGggPz8gcGF0aC5yZXNvbHZlKCcuLi8uLi9taWdyYXRpb24nKSwge1xuICAgICAgICBmaWxlOiAnRG9ja2VyZmlsZScsXG4gICAgICAgIHBsYXRmb3JtOiBlY3JBc3NldHMuUGxhdGZvcm0uTElOVVhfQU1ENjQsXG4gICAgICB9KSxcbiAgICAgIGVudmlyb25tZW50LFxuICAgICAgc2VjcmV0cyxcbiAgICAgIGxvZ2dpbmc6IGVjcy5Mb2dEcml2ZXJzLmF3c0xvZ3Moe1xuICAgICAgICBzdHJlYW1QcmVmaXg6ICdtaWdyYXRpb24tc2NyaXB0cycsXG4gICAgICAgIGxvZ1JldGVudGlvbjogbG9ncy5SZXRlbnRpb25EYXlzLk9ORV9NT05USCxcbiAgICAgIH0pLFxuICAgIH0pO1xuXG4gICAgcHJvcHMuYXJ0aWZhY3RzQnVja2V0LmdyYW50UmVhZCh0aGlzLnRhc2tEZWZpbml0aW9uLnRhc2tSb2xlLCBgJHtwcm9wcy5iYWNrdXBQcmVmaXggPz8gJ2JhY2t1cHMnfS8qYCk7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,48 @@
+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;
+    clearAffected: lambda.IFunction;
+    queue: sqs.IQueue;
+    cluster: ecs.ICluster;
+    taskDefinition: ecs.TaskDefinition;
+    container: ecs.ContainerDefinition;
+    securityGroup: ec2.ISecurityGroup;
+    artifactsBucket: s3.IBucket;
+    progressParameterName: string;
+    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 clearAffected;
+    private readonly queue;
+    private readonly cluster;
+    private readonly taskDefinition;
+    private readonly container;
+    private readonly securityGroup;
+    private readonly artifactsBucket;
+    private readonly progressParameterName;
+    private readonly progressParameterArn;
+    private readonly maxInvocations;
+    private readonly drainMaxChecks;
+    private readonly loopWaitSeconds;
+    private readonly drainWaitSeconds;
+    constructor(scope: Construct, id: string, props: MigrationStateMachineProps);
+    private previousStep;
+    private precomputeEnabled;
+    private markStep;
+    private producerPass;
+    private resourceStep;
+    private ecsStep;
+}