@orcabus/platform-cdk-constructs 0.0.103 → 1.0.0

package/deployment-stack-pipeline/pipeline.d.ts

@@ -41,6 +41,35 @@ export interface StackConfigProps {
      */
     readonly prod: Record<string, any>;
 }
+/**
+ * Configuration for pre-deployment drift detection checks.
+ */
+export interface DriftCheckConfig {
+    /**
+     * CDK CLI entrypoint used to run the drift command.
+     * Examples: "pnpm cdk", "pnpm cdk-stateful", "pnpm cdk-stateless".
+     * Must support: "drift <stackId>".
+     */
+    readonly cdkCommand: string;
+    /**
+     * Command to install dependencies before running CDK.
+     * If your app is in a subdirectory, prefix with "cd <dir> &&".
+     * Example: "cd dev && pnpm install --frozen-lockfile --ignore-scripts"
+     *
+     * Default: "pnpm install --frozen-lockfile --ignore-scripts"
+     */
+    readonly installCommand?: string;
+}
+export interface CodeBuildStepProps {
+    /**
+     * the main command for the build step to run
+     */
+    readonly command: string[];
+    /**
+     * Partial buildspec for this CodeBuildStep
+     */
+    readonly partialBuildSpec?: Record<string, any>;
+}
 export interface DeploymentStackPipelineProps {
     /**
      * The GitHub branch name the pipeline will listen to.
@@ -100,6 +129,22 @@ export interface DeploymentStackPipelineProps {
      * @default DEFAULT_SYNTH_STEP_PARTIAL_BUILD_SPEC
      */
     readonly synthBuildSpec?: Record<string, any>;
+    /**
+     * Configuration for the CodeBuild step that runs unit tests for the main application code.
+     * This step will execute in parallel with {@link unitIacTestConfig} as part of the synth stage dependencies.
+     * Both must succeed before the synth step runs.
+     *
+     * ensure your command includes 'cd' to the main app directory, as the build context starts from the root.
+     */
+    readonly unitAppTestConfig: CodeBuildStepProps;
+    /**
+     * Configuration for the CodeBuild step that runs unit tests for Infrastructure-as-Code (IaC) at the repository root.
+     * This step will execute in parallel with {@link unitAppTestConfig} as part of the synth stage dependencies.
+     * Both must succeed before the synth step runs.
+     *
+     * The default command will be from the root of the repo: ["make install", "make test"]
+     */
+    readonly unitIacTestConfig?: CodeBuildStepProps;
     /**
      * The stage environment for the deployment stack
      */
@@ -131,6 +176,11 @@ export interface DeploymentStackPipelineProps {
      * @see https://github.com/aws/aws-cdk/issues/9917
      */
     readonly stripAssemblyAssets?: boolean;
+    /**
+     * Configuration for drift detection checks before deployment.
+     * If specified, the pipeline will check for CloudFormation drift and fail if detected.
+     */
+    readonly driftCheckConfig?: DriftCheckConfig;
 }
 /**
  * A CDK construct that creates a deployment pipeline across environments for the OrcaBus project.
@@ -145,3 +195,32 @@ export declare class DeploymentStackPipeline extends Construct {
     readonly pipeline: Pipeline;
     constructor(scope: Construct, id: string, props: DeploymentStackPipelineProps);
 }
+export interface FailOnDriftBuildStepProps {
+    /**
+     * AWS account and region where the drift check runs.
+     * Used to assume the CDK lookup role and set AWS_DEFAULT_REGION.
+     */
+    readonly accountEnv: Environment;
+    /**
+     * Fully qualified CDK stack ID to check for drift.
+     *
+     * Format: `<rootStack>/<constructId>/<envName>/<stackName>`
+     *
+     * Example: `DevStack/DeploymentPipeline/OrcaBusBeta/TestStack`
+     */
+    readonly stackId: string;
+    /**
+     * CDK CLI entrypoint used to run the drift command.
+     * Examples: "pnpm cdk", "pnpm cdk-stateful", "pnpm cdk-stateless".
+     * Must support: "drift <stackId>".
+     */
+    readonly cdkCommand: string;
+    /**
+     * Command to install dependencies before running CDK.
+     * If your app is in a subdirectory, prefix with "cd <dir> &&".
+     * Example: "cd dev && pnpm install --frozen-lockfile --ignore-scripts"
+     *
+     * Default: "pnpm install --frozen-lockfile --ignore-scripts"
+     */
+    readonly installCommand?: string;
+}

package/deployment-stack-pipeline/pipeline.js

@@ -13,6 +13,7 @@ const aws_chatbot_1 = require("aws-cdk-lib/aws-chatbot");
 const aws_codestarnotifications_1 = require("aws-cdk-lib/aws-codestarnotifications");
 const artifact_bucket_1 = require("./artifact-bucket");
 const aws_codepipeline_actions_1 = require("aws-cdk-lib/aws-codepipeline-actions");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
 /**
  * The default partial build spec for the synth step in the pipeline.
  */
@@ -32,14 +33,14 @@ exports.DEFAULT_SYNTH_STEP_PARTIAL_BUILD_SPEC = {
  * before using this construct.
  */
 class DeploymentStackPipeline extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.deploymentPipeline.DeploymentStackPipeline", version: "0.0.103" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.deploymentPipeline.DeploymentStackPipeline", version: "1.0.0" };
     /**
      * The code pipeline construct that is created.
      */
     pipeline;
     constructor(scope, id, props) {
         super(scope, id);
-        const codeStarArn = aws_ssm_1.StringParameter.valueForStringParameter(this, "/orcabus/codestar_github_arn");
+        const codeStarArn = aws_ssm_1.StringParameter.valueForStringParameter(this, "codestar_github_arn");
         const codeStarSourceActionName = "pipeline-src";
         const sourceFile = pipelines_1.CodePipelineSource.connection(`OrcaBus/${props.githubRepo}`, props.githubBranch, {
             connectionArn: codeStarArn,
@@ -83,21 +84,62 @@ class DeploymentStackPipeline extends constructs_1.Construct {
                 },
             ]);
         }
+        // Add unit test for IaC at the root of the
+        const { command: unitIacTestCommand = ["make install", "make test"], partialBuildSpec: unitIacPartialBuildSpec = undefined, } = props.unitIacTestConfig || {};
+        const unitIacTest = new pipelines_1.CodeBuildStep("UnitIacTest", {
+            commands: unitIacTestCommand,
+            input: sourceFile,
+            buildEnvironment: {
+                privileged: true,
+                computeType: aws_codebuild_1.ComputeType.LARGE,
+                buildImage: aws_codebuild_1.LinuxArmBuildImage.AMAZON_LINUX_2_STANDARD_3_0,
+                environmentVariables: {
+                    NODE_OPTIONS: {
+                        value: "--max-old-space-size=8192",
+                    },
+                },
+            },
+            partialBuildSpec: unitIacPartialBuildSpec
+                ? aws_codebuild_1.BuildSpec.fromObject(unitIacPartialBuildSpec)
+                : undefined,
+        });
+        // Adding unit test for the main app
+        const { command: unitAppTestCommand, partialBuildSpec: unitAppPartialBuildSpec = undefined, } = props.unitAppTestConfig;
+        const unitAppTest = new pipelines_1.CodeBuildStep("UnitAppTest", {
+            commands: unitAppTestCommand,
+            input: sourceFile,
+            buildEnvironment: {
+                privileged: true,
+                computeType: aws_codebuild_1.ComputeType.LARGE,
+                buildImage: aws_codebuild_1.LinuxArmBuildImage.AMAZON_LINUX_2_STANDARD_3_0,
+                environmentVariables: {
+                    NODE_OPTIONS: {
+                        value: "--max-old-space-size=8192",
+                    },
+                },
+            },
+            partialBuildSpec: unitAppPartialBuildSpec
+                ? aws_codebuild_1.BuildSpec.fromObject(unitAppPartialBuildSpec)
+                : undefined,
+        });
         const { synthBuildSpec = exports.DEFAULT_SYNTH_STEP_PARTIAL_BUILD_SPEC } = props;
+        const synthStep = new pipelines_1.CodeBuildStep("CdkSynth", {
+            installCommands: [
+                "node -v",
+                "npm install --global corepack@latest",
+                "corepack --version",
+                "corepack enable",
+            ],
+            commands: props.cdkSynthCmd,
+            input: sourceFile,
+            primaryOutputDirectory: props.cdkOut || "cdk.out",
+            partialBuildSpec: aws_codebuild_1.BuildSpec.fromObject(synthBuildSpec),
+        });
+        synthStep.addStepDependency(unitIacTest);
+        synthStep.addStepDependency(unitAppTest);
         const cdkPipeline = new pipelines_1.CodePipeline(this, "CDKCodePipeline", {
             codePipeline: this.pipeline,
-            synth: new pipelines_1.CodeBuildStep("CdkSynth", {
-                installCommands: [
-                    "node -v",
-                    "npm install --global corepack@latest",
-                    "corepack --version",
-                    "corepack enable",
-                ],
-                commands: props.cdkSynthCmd,
-                input: sourceFile,
-                primaryOutputDirectory: props.cdkOut || "cdk.out",
-                partialBuildSpec: aws_codebuild_1.BuildSpec.fromObject(synthBuildSpec),
-            }),
+            synth: synthStep,
             selfMutation: true,
             codeBuildDefaults: {
                 buildEnvironment: {
@@ -140,8 +182,43 @@ class DeploymentStackPipeline extends constructs_1.Construct {
                 pre: [stripAssetsFromAssembly],
             });
         }
-        cdkPipeline.addStage(new DeploymentStage(this, "OrcaBusBeta", stageEnv.beta, props.stackName, props.stack, props.stackConfig.beta, props.githubRepo, props.githubBranch));
-        cdkPipeline.addStage(new DeploymentStage(this, "OrcaBusGamma", stageEnv.gamma, props.stackName, props.stack, props.stackConfig.gamma, props.githubRepo, props.githubBranch), {
+        // Construct function to get StackId for drift check
+        const rootStackName = aws_cdk_lib_1.Stack.of(this).stackName;
+        const constructId = this.node.id;
+        const getStackId = (envName) => `${rootStackName}/${constructId}/${envName}/${props.stackName}`;
+        // Drift check config
+        const isDriftCheckStep = !!props.driftCheckConfig;
+        const cdkInstallCmd = props.driftCheckConfig?.installCommand ??
+            "pnpm install --frozen-lockfile --ignore-scripts";
+        const cdkRunCmd = props.driftCheckConfig?.cdkCommand ?? ``;
+        const betaEnvName = "OrcaBusBeta";
+        cdkPipeline.addStage(new DeploymentStage(this, betaEnvName, stageEnv.beta, props.stackName, props.stack, props.stackConfig.beta, props.githubRepo, props.githubBranch), {
+            pre: isDriftCheckStep
+                ? [
+                    new FailOnDriftBuildStep("DriftOnFailBetaCheck", {
+                        accountEnv: stageEnv.beta,
+                        stackId: getStackId(betaEnvName),
+                        cdkCommand: cdkRunCmd,
+                        installCommand: cdkInstallCmd,
+                    }),
+                ]
+                : undefined,
+        });
+        /**
+         * GAMMA
+         */
+        const gammaEnvName = "OrcaBusGamma";
+        cdkPipeline.addStage(new DeploymentStage(this, gammaEnvName, stageEnv.gamma, props.stackName, props.stack, props.stackConfig.gamma, props.githubRepo, props.githubBranch), {
+            pre: isDriftCheckStep
+                ? [
+                    new FailOnDriftBuildStep("DriftOnFailGammaCheck", {
+                        accountEnv: stageEnv.gamma,
+                        stackId: getStackId(gammaEnvName),
+                        cdkCommand: cdkRunCmd,
+                        installCommand: cdkInstallCmd,
+                    }),
+                ]
+                : undefined,
             post: [
                 new ManualApprovalActionStep("PromoteToProd", {
                     actionName: "PromoteToProd",
@@ -154,7 +231,22 @@ class DeploymentStackPipeline extends constructs_1.Construct {
                 }),
             ],
         });
-        cdkPipeline.addStage(new DeploymentStage(this, "OrcaBusProd", stageEnv.prod, props.stackName, props.stack, props.stackConfig.prod, props.githubRepo, props.githubBranch));
+        /**
+         * PROD
+         */
+        const prodEnvName = "OrcaBusProd";
+        cdkPipeline.addStage(new DeploymentStage(this, prodEnvName, stageEnv.prod, props.stackName, props.stack, props.stackConfig.prod, props.githubRepo, props.githubBranch), {
+            pre: isDriftCheckStep
+                ? [
+                    new FailOnDriftBuildStep("DriftOnFailProdCheck", {
+                        accountEnv: stageEnv.prod,
+                        stackId: getStackId(prodEnvName),
+                        cdkCommand: cdkRunCmd,
+                        installCommand: cdkInstallCmd,
+                    }),
+                ]
+                : undefined,
+        });
         cdkPipeline.buildPipeline();
         if (stripAssetsFromAssembly) {
             cdkPipeline.pipeline.artifactBucket.grantReadWrite(stripAssetsFromAssembly.project);
@@ -212,4 +304,35 @@ class DeploymentStage extends aws_cdk_lib_1.Stage {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline.js","sourceRoot":"","sources":["pipeline.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { Duration, Environment, Stack, Stage } from \"aws-cdk-lib\";\nimport {\n  BuildSpec,\n  ComputeType,\n  LinuxArmBuildImage,\n} from \"aws-cdk-lib/aws-codebuild\";\nimport { StringParameter } from \"aws-cdk-lib/aws-ssm\";\nimport {\n  CodeBuildStep,\n  CodePipeline,\n  CodePipelineActionFactoryResult,\n  CodePipelineSource,\n  ICodePipelineActionFactory,\n  ManualApprovalStep,\n  ProduceActionOptions,\n  Step,\n} from \"aws-cdk-lib/pipelines\";\nimport {\n  Pipeline,\n  CfnPipeline,\n  PipelineType,\n  PipelineNotificationEvents,\n  IStage,\n} from \"aws-cdk-lib/aws-codepipeline\";\nimport {\n  BETA_ENVIRONMENT,\n  GAMMA_ENVIRONMENT,\n  PROD_ENVIRONMENT,\n} from \"./config\";\nimport { SlackChannelConfiguration } from \"aws-cdk-lib/aws-chatbot\";\nimport { DetailType } from \"aws-cdk-lib/aws-codestarnotifications\";\nimport { CrossDeploymentArtifactBucket } from \"./artifact-bucket\";\nimport {\n  ManualApprovalAction,\n  ManualApprovalActionProps,\n} from \"aws-cdk-lib/aws-codepipeline-actions\";\n\n/**\n * The default partial build spec for the synth step in the pipeline.\n */\nexport const DEFAULT_SYNTH_STEP_PARTIAL_BUILD_SPEC = {\n  phases: {\n    install: {\n      \"runtime-versions\": {\n        nodejs: \"22.x\",\n      },\n    },\n  },\n};\n\nexport interface StageEnvProps {\n  /**\n   * The environment for the beta stage\n   */\n  readonly beta: Environment;\n  /**\n   * The environment for the gamma stage\n   */\n  readonly gamma: Environment;\n  /**\n   * The environment for the prod stage\n   */\n  readonly prod: Environment;\n}\n\nexport interface StackConfigProps {\n  /**\n   * The configuration for the beta (dev) stage\n   */\n  readonly beta: Record<string, any>;\n  /**\n   * The configuration for the gamma (stg) stage\n   */\n  readonly gamma: Record<string, any>;\n  /**\n   * The configuration for the prod stage\n   */\n  readonly prod: Record<string, any>;\n}\n\nexport interface DeploymentStackPipelineProps {\n  /**\n   * The GitHub branch name the pipeline will listen to.\n   * Avoid using branch names that contain special characters such as parentheses.\n   * Allowed special characters are: \"+ - = . _ : / @\".\n   * This restriction is due to AWS resource tagging requirements.\n   */\n  readonly githubBranch: string;\n  /**\n   * The repository name that exist in the 'OrcaBus' github organisation. e.g. `a-micro-service-repo`\n   */\n  readonly githubRepo: string;\n  /**\n   * The stack to which the pipeline will be deploying to its respective account\n   */\n  readonly stack: any;\n  /**\n   * The stack name (in cloudformation) for the stack defined in `stack`. The stack name will prepend with the stage\n   * name e.g. `OrcaBusBeta-<stackName>`, `OrcaBusGamma-<stackName>`, `OrcaBusProd-<stackName>`\n   */\n  readonly stackName: string;\n  /**\n   * The stack configuration/constants that will be passed to the stack props.\n   */\n  readonly stackConfig: StackConfigProps;\n  /**\n   * The pipeline name in the bastion account.\n   */\n  readonly pipelineName: string;\n  /**\n   * The list of patterns of Git repository file paths that, when a commit is pushed, are to be INCLUDED as criteria that starts the pipeline.\n   *\n   * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitfilepathfiltercriteria.html\n   *\n   */\n  readonly includedFilePaths?: string[];\n  /**\n   * The list of patterns of Git repository file paths that, when a commit is pushed, are to be EXCLUDED from starting the pipeline.\n   *\n   * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitfilepathfiltercriteria.html\n   *\n   */\n  readonly excludedFilePaths?: string[];\n  /**\n   * The command to run to synth the cdk stack which also installing the cdk dependencies. e.g. [\"yarn install --immutable\", \"yarn cdk synth\"]\n   */\n  readonly cdkSynthCmd: string[];\n  /**\n   * The location where the cdk output will be stored.\n   *\n   * @default cdk.out\n   */\n  readonly cdkOut?: string;\n  /**\n   * Additional configuration for the CodeBuild step during the CDK synth phase. It will passed as the `partialBuildSpec` to the `CodeBuildStep`.\n   *\n   * @default DEFAULT_SYNTH_STEP_PARTIAL_BUILD_SPEC\n   */\n  readonly synthBuildSpec?: Record<string, any>;\n  /**\n   * The stage environment for the deployment stack\n   */\n  readonly stageEnv?: StageEnvProps;\n  /**\n   * Enable notification to the 'alerts-build' slack channel.\n   * @default True\n   */\n  readonly enableSlackNotification?: boolean;\n  /**\n   * The pipeline notification events that will trigger a Slack channel notification.\n   * Only applies if `enableSlackNotification` is set to true.\n   *\n   * @default [PipelineNotificationEvents.PIPELINE_EXECUTION_FAILED] –\n   *   Only failed pipeline executions will trigger a notification.\n   */\n  readonly notificationEvents?: PipelineNotificationEvents[];\n\n  /**\n   * Whether to reuse the existing artifact bucket for cross-deployment pipelines.\n   * If set to true, it will look up the existing artifact bucket in the TOOLCHAIN account.\n   *\n   * @default True\n   */\n  readonly reuseExistingArtifactBucket?: boolean;\n\n  /**\n   * Remove assets from the CDK assembly pre-deployment to prevent hitting CodePipeline's 256 MB artifact size limit.\n   * Useful when CDK assets (Lambda code, Docker images, etc.) are large.\n   *\n   * @see https://github.com/aws/aws-cdk/issues/9917\n   */\n  readonly stripAssemblyAssets?: boolean;\n}\n\n/**\n * A CDK construct that creates a deployment pipeline across environments for the OrcaBus project.\n *\n * Prerequisite: Ensure that the \"CrossDeploymentArtifactBucket\" stack is deployed in the TOOLCHAIN account\n * before using this construct.\n */\nexport class DeploymentStackPipeline extends Construct {\n  /**\n   * The code pipeline construct that is created.\n   */\n  readonly pipeline: Pipeline;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: DeploymentStackPipelineProps,\n  ) {\n    super(scope, id);\n\n    const codeStarArn = StringParameter.valueForStringParameter(\n      this,\n      \"/orcabus/codestar_github_arn\",\n    );\n    const codeStarSourceActionName = \"pipeline-src\";\n    const sourceFile = CodePipelineSource.connection(\n      `OrcaBus/${props.githubRepo}`,\n      props.githubBranch,\n      {\n        connectionArn: codeStarArn,\n        actionName: codeStarSourceActionName,\n        triggerOnPush: true,\n      },\n    );\n\n    const isReusingExistingArtifactBucket =\n      props.reuseExistingArtifactBucket ?? true;\n    const artifactBucket = isReusingExistingArtifactBucket\n      ? CrossDeploymentArtifactBucket.fromLookup(this).artifactBucket\n      : undefined;\n\n    this.pipeline = new Pipeline(this, \"DeploymentCodePipeline\", {\n      artifactBucket: artifactBucket,\n      pipelineType: PipelineType.V2,\n      pipelineName: props.pipelineName,\n      crossAccountKeys: true,\n    });\n\n    if (props.includedFilePaths || props.excludedFilePaths) {\n      const filePaths: Record<string, string[]> = {};\n\n      if (props.includedFilePaths) {\n        filePaths[\"Includes\"] = props.includedFilePaths;\n      }\n      if (props.excludedFilePaths) {\n        filePaths[\"Excludes\"] = props.excludedFilePaths;\n      }\n\n      // Add event filter to only trigger if the push event is from `deploy` directory\n      const cfnPipeline = this.pipeline.node.defaultChild as CfnPipeline;\n      cfnPipeline.addPropertyOverride(\"Triggers\", [\n        {\n          GitConfiguration: {\n            Push: [\n              {\n                Branches: {\n                  Includes: [props.githubBranch],\n                },\n                FilePaths: filePaths,\n              },\n            ],\n            SourceActionName: codeStarSourceActionName,\n          },\n          ProviderType: \"CodeStarSourceConnection\",\n        },\n      ]);\n    }\n\n    const { synthBuildSpec = DEFAULT_SYNTH_STEP_PARTIAL_BUILD_SPEC } = props;\n    const cdkPipeline = new CodePipeline(this, \"CDKCodePipeline\", {\n      codePipeline: this.pipeline,\n      synth: new CodeBuildStep(\"CdkSynth\", {\n        installCommands: [\n          \"node -v\",\n          \"npm install --global corepack@latest\",\n          \"corepack --version\",\n          \"corepack enable\",\n        ],\n        commands: props.cdkSynthCmd,\n        input: sourceFile,\n        primaryOutputDirectory: props.cdkOut || \"cdk.out\",\n        partialBuildSpec: BuildSpec.fromObject(synthBuildSpec),\n      }),\n      selfMutation: true,\n      codeBuildDefaults: {\n        buildEnvironment: {\n          computeType: ComputeType.LARGE,\n          buildImage: LinuxArmBuildImage.AMAZON_LINUX_2_STANDARD_3_0,\n          environmentVariables: {\n            NODE_OPTIONS: {\n              value: \"--max-old-space-size=8192\",\n            },\n          },\n        },\n      },\n    });\n\n    const defaultStageEnv: StageEnvProps = {\n      beta: BETA_ENVIRONMENT,\n      gamma: GAMMA_ENVIRONMENT,\n      prod: PROD_ENVIRONMENT,\n    };\n    const stageEnv = props.stageEnv || defaultStageEnv;\n\n    // After assets are published, they can be removed from the assembly directory\n    // to help prevent hitting the CodePipeline artifact limit.\n    // https://github.com/aws/aws-cdk/issues/9917\n    let stripAssetsFromAssembly: CodeBuildStep | undefined;\n    if (props.stripAssemblyAssets) {\n      stripAssetsFromAssembly = new CodeBuildStep(\"StripAssetsFromAssembly\", {\n        input: cdkPipeline.cloudAssemblyFileSet,\n        commands: [\n          'S3_PATH=${CODEBUILD_SOURCE_VERSION#\"arn:aws:s3:::\"}',\n          \"ZIP_ARCHIVE=$(basename $S3_PATH)\",\n          \"echo $S3_PATH\",\n          \"echo $ZIP_ARCHIVE\",\n          \"ls\",\n          \"rm -rfv asset.*\",\n          \"zip -r -q -A $ZIP_ARCHIVE *\",\n          \"ls\",\n          \"aws s3 cp $ZIP_ARCHIVE s3://$S3_PATH\",\n        ],\n      });\n\n      cdkPipeline.addWave(\"BeforeStageDeployment\", {\n        pre: [stripAssetsFromAssembly],\n      });\n    }\n\n    cdkPipeline.addStage(\n      new DeploymentStage(\n        this,\n        \"OrcaBusBeta\",\n        stageEnv.beta,\n        props.stackName,\n        props.stack,\n        props.stackConfig.beta,\n        props.githubRepo,\n        props.githubBranch,\n      ),\n    );\n\n    cdkPipeline.addStage(\n      new DeploymentStage(\n        this,\n        \"OrcaBusGamma\",\n        stageEnv.gamma,\n        props.stackName,\n        props.stack,\n        props.stackConfig.gamma,\n        props.githubRepo,\n        props.githubBranch,\n      ),\n      {\n        post: [\n          new ManualApprovalActionStep(\"PromoteToProd\", {\n            actionName: \"PromoteToProd\",\n            // Custom steps bypass stage pre/post ordering, so runOrder must be explicitly set.\n            // Set to 5 to ensure this runs after all OrcaBusGamma stage steps complete.\n            // (Gamma deployment typically uses 2 steps, so 5 provides adequate buffer)\n            runOrder: 5,\n            // 60-minute timeout allows queued pipeline executions to proceed if approval expires\n            timeout: Duration.minutes(60),\n          }),\n        ],\n      },\n    );\n\n    cdkPipeline.addStage(\n      new DeploymentStage(\n        this,\n        \"OrcaBusProd\",\n        stageEnv.prod,\n        props.stackName,\n        props.stack,\n        props.stackConfig.prod,\n        props.githubRepo,\n        props.githubBranch,\n      ),\n    );\n\n    cdkPipeline.buildPipeline();\n\n    if (stripAssetsFromAssembly) {\n      cdkPipeline.pipeline.artifactBucket.grantReadWrite(\n        stripAssetsFromAssembly.project,\n      );\n    }\n\n    if (props.enableSlackNotification ?? true) {\n      const alertsBuildSlackConfigArn = StringParameter.valueForStringParameter(\n        this,\n        \"/chatbot_arn/slack/alerts-build\",\n      );\n      const target = SlackChannelConfiguration.fromSlackChannelConfigurationArn(\n        this,\n        \"SlackChannelConfiguration\",\n        alertsBuildSlackConfigArn,\n      );\n\n      this.pipeline.notifyOn(\"PipelineSlackNotification\", target, {\n        events: props.notificationEvents || [\n          PipelineNotificationEvents.PIPELINE_EXECUTION_FAILED,\n        ],\n        detailType: DetailType.FULL,\n        notificationRuleName: `OrcaBus-${props.pipelineName}`,\n      });\n    }\n  }\n}\n\n/**\n * Properties for ManualApprovalActionStep with required runOrder.\n */\ninterface ManualApprovalActionStepProps extends ManualApprovalActionProps {\n  /**\n   * The run order for this action in the pipeline stage. The stage Pre/Post order does not apply to this custom\n   * step/action, you need to explicitly set the runOrder.\n   */\n  runOrder: number;\n}\n/**\n * Custom manual approval step for CDK CodePipeline.\n *\n * This class bridges the gap to enable using ManualApprovalAction within a Step class,\n * making it compatible with cdk.pipelines constructs.\n *\n * @param id - The unique identifier for the step.\n * @param options - The properties for the manual approval action, including\n */\nclass ManualApprovalActionStep\n  extends Step\n  implements ICodePipelineActionFactory\n{\n  private readonly manualApprovalActionProps: ManualApprovalActionStepProps;\n  constructor(id: string, options: ManualApprovalActionStepProps) {\n    super(id);\n    this.manualApprovalActionProps = options;\n  }\n\n  public produceAction(\n    stage: IStage,\n    options: ProduceActionOptions,\n  ): CodePipelineActionFactoryResult {\n    stage.addAction(new ManualApprovalAction(this.manualApprovalActionProps));\n\n    return { runOrdersConsumed: 1 };\n  }\n}\n\nclass DeploymentStage extends Stage {\n  constructor(\n    scope: Construct,\n    environmentName: string,\n    env: Environment,\n    stackName: string,\n    stackClass: new (scope: Construct, id: string, props: any) => Stack,\n    appStackProps: any,\n    githubRepo: string,\n    githubBranch?: string,\n  ) {\n    super(scope, environmentName, { env: env });\n\n    let source = `https://github.com/OrcaBus/${githubRepo}`;\n    if (githubBranch !== undefined && githubBranch !== \"main\") {\n      source = `${source}/tree/${githubBranch}`;\n    }\n\n    new stackClass(this, stackName, {\n      env: env,\n      tags: {\n        \"umccr-org:Product\": \"OrcaBus\",\n        \"umccr-org:Creator\": \"CDK\",\n        \"umccr-org:Service\": stackName,\n        \"umccr-org:Source\": source,\n      },\n      ...appStackProps,\n    });\n  }\n}\n"]}
+class FailOnDriftBuildStep extends pipelines_1.CodeBuildStep {
+    constructor(id, { accountEnv, stackId, cdkCommand, installCommand, }) {
+        const cdkInstall = installCommand
+            ? installCommand
+            : "pnpm install --frozen-lockfile --ignore-scripts";
+        super(id, {
+            commands: [
+                "node -v",
+                "npm install --global corepack@latest",
+                "corepack --version",
+                "corepack enable",
+                cdkInstall,
+                `LOOKUP_ROLE_ARN="arn:aws:iam::${accountEnv.account}:role/cdk-hnb659fds-lookup-role-${accountEnv.account}-${accountEnv.region}"`,
+                'SESSION_NAME="drift-check"',
+                'read AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN < <(aws sts assume-role --role-arn "$LOOKUP_ROLE_ARN" --role-session-name "$SESSION_NAME" --duration-seconds 900 --query \'Credentials.[AccessKeyId,SecretAccessKey,SessionToken]\' --output text)',
+                "export AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN",
+                `export AWS_DEFAULT_REGION="${accountEnv.region}"`,
+                "aws sts get-caller-identity",
+                `if ${cdkCommand} ls | grep -Fq "${stackId}"; then echo "Stack ${stackId} found; checking for drift..."; ${cdkCommand} drift "${stackId}" -e --fail; else echo "Stack not found in cdk ls; skipping drift check."; fi`,
+            ],
+            rolePolicyStatements: [
+                new aws_iam_1.PolicyStatement({
+                    actions: ["sts:AssumeRole"],
+                    resources: [
+                        `arn:aws:iam::${accountEnv.account}:role/cdk-hnb659fds-lookup-role-${accountEnv.account}-${accountEnv.region}`,
+                    ],
+                }),
+            ],
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipeline.js","sourceRoot":"","sources":["pipeline.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { Duration, Environment, Stack, Stage } from \"aws-cdk-lib\";\nimport {\n  BuildSpec,\n  ComputeType,\n  IProject,\n  LinuxArmBuildImage,\n  PipelineProject,\n} from \"aws-cdk-lib/aws-codebuild\";\nimport { StringParameter } from \"aws-cdk-lib/aws-ssm\";\nimport {\n  CodeBuildStep,\n  CodePipeline,\n  CodePipelineActionFactoryResult,\n  CodePipelineSource,\n  ICodePipelineActionFactory,\n  ProduceActionOptions,\n  Step,\n} from \"aws-cdk-lib/pipelines\";\nimport {\n  Pipeline,\n  CfnPipeline,\n  PipelineType,\n  PipelineNotificationEvents,\n  IStage,\n  Artifact,\n} from \"aws-cdk-lib/aws-codepipeline\";\nimport {\n  BETA_ENVIRONMENT,\n  GAMMA_ENVIRONMENT,\n  PROD_ENVIRONMENT,\n} from \"./config\";\nimport { SlackChannelConfiguration } from \"aws-cdk-lib/aws-chatbot\";\nimport { DetailType } from \"aws-cdk-lib/aws-codestarnotifications\";\nimport { CrossDeploymentArtifactBucket } from \"./artifact-bucket\";\nimport {\n  CodeBuildAction,\n  ManualApprovalAction,\n  ManualApprovalActionProps,\n} from \"aws-cdk-lib/aws-codepipeline-actions\";\nimport { PolicyStatement } from \"aws-cdk-lib/aws-iam\";\n\n/**\n * The default partial build spec for the synth step in the pipeline.\n */\nexport const DEFAULT_SYNTH_STEP_PARTIAL_BUILD_SPEC = {\n  phases: {\n    install: {\n      \"runtime-versions\": {\n        nodejs: \"22.x\",\n      },\n    },\n  },\n};\n\nexport interface StageEnvProps {\n  /**\n   * The environment for the beta stage\n   */\n  readonly beta: Environment;\n  /**\n   * The environment for the gamma stage\n   */\n  readonly gamma: Environment;\n  /**\n   * The environment for the prod stage\n   */\n  readonly prod: Environment;\n}\n\nexport interface StackConfigProps {\n  /**\n   * The configuration for the beta (dev) stage\n   */\n  readonly beta: Record<string, any>;\n  /**\n   * The configuration for the gamma (stg) stage\n   */\n  readonly gamma: Record<string, any>;\n  /**\n   * The configuration for the prod stage\n   */\n  readonly prod: Record<string, any>;\n}\n\n/**\n * Configuration for pre-deployment drift detection checks.\n */\nexport interface DriftCheckConfig {\n  /**\n   * CDK CLI entrypoint used to run the drift command.\n   * Examples: \"pnpm cdk\", \"pnpm cdk-stateful\", \"pnpm cdk-stateless\".\n   * Must support: \"drift <stackId>\".\n   */\n  readonly cdkCommand: string;\n  /**\n   * Command to install dependencies before running CDK.\n   * If your app is in a subdirectory, prefix with \"cd <dir> &&\".\n   * Example: \"cd dev && pnpm install --frozen-lockfile --ignore-scripts\"\n   *\n   * Default: \"pnpm install --frozen-lockfile --ignore-scripts\"\n   */\n  readonly installCommand?: string;\n}\n\nexport interface CodeBuildStepProps {\n  /**\n   * the main command for the build step to run\n   */\n  readonly command: string[];\n  /**\n   * Partial buildspec for this CodeBuildStep\n   */\n  readonly partialBuildSpec?: Record<string, any>;\n}\n\nexport interface DeploymentStackPipelineProps {\n  /**\n   * The GitHub branch name the pipeline will listen to.\n   * Avoid using branch names that contain special characters such as parentheses.\n   * Allowed special characters are: \"+ - = . _ : / @\".\n   * This restriction is due to AWS resource tagging requirements.\n   */\n  readonly githubBranch: string;\n  /**\n   * The repository name that exist in the 'OrcaBus' github organisation. e.g. `a-micro-service-repo`\n   */\n  readonly githubRepo: string;\n  /**\n   * The stack to which the pipeline will be deploying to its respective account\n   */\n  readonly stack: any;\n  /**\n   * The stack name (in cloudformation) for the stack defined in `stack`. The stack name will prepend with the stage\n   * name e.g. `OrcaBusBeta-<stackName>`, `OrcaBusGamma-<stackName>`, `OrcaBusProd-<stackName>`\n   */\n  readonly stackName: string;\n  /**\n   * The stack configuration/constants that will be passed to the stack props.\n   */\n  readonly stackConfig: StackConfigProps;\n  /**\n   * The pipeline name in the bastion account.\n   */\n  readonly pipelineName: string;\n  /**\n   * The list of patterns of Git repository file paths that, when a commit is pushed, are to be INCLUDED as criteria that starts the pipeline.\n   *\n   * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitfilepathfiltercriteria.html\n   *\n   */\n  readonly includedFilePaths?: string[];\n  /**\n   * The list of patterns of Git repository file paths that, when a commit is pushed, are to be EXCLUDED from starting the pipeline.\n   *\n   * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitfilepathfiltercriteria.html\n   *\n   */\n  readonly excludedFilePaths?: string[];\n  /**\n   * The command to run to synth the cdk stack which also installing the cdk dependencies. e.g. [\"yarn install --immutable\", \"yarn cdk synth\"]\n   */\n  readonly cdkSynthCmd: string[];\n  /**\n   * The location where the cdk output will be stored.\n   *\n   * @default cdk.out\n   */\n  readonly cdkOut?: string;\n  /**\n   * Additional configuration for the CodeBuild step during the CDK synth phase. It will passed as the `partialBuildSpec` to the `CodeBuildStep`.\n   *\n   * @default DEFAULT_SYNTH_STEP_PARTIAL_BUILD_SPEC\n   */\n  readonly synthBuildSpec?: Record<string, any>;\n  /**\n   * Configuration for the CodeBuild step that runs unit tests for the main application code.\n   * This step will execute in parallel with {@link unitIacTestConfig} as part of the synth stage dependencies.\n   * Both must succeed before the synth step runs.\n   *\n   * ensure your command includes 'cd' to the main app directory, as the build context starts from the root.\n   */\n  readonly unitAppTestConfig: CodeBuildStepProps;\n  /**\n   * Configuration for the CodeBuild step that runs unit tests for Infrastructure-as-Code (IaC) at the repository root.\n   * This step will execute in parallel with {@link unitAppTestConfig} as part of the synth stage dependencies.\n   * Both must succeed before the synth step runs.\n   *\n   * The default command will be from the root of the repo: [\"make install\", \"make test\"]\n   */\n  readonly unitIacTestConfig?: CodeBuildStepProps;\n  /**\n   * The stage environment for the deployment stack\n   */\n  readonly stageEnv?: StageEnvProps;\n  /**\n   * Enable notification to the 'alerts-build' slack channel.\n   * @default True\n   */\n  readonly enableSlackNotification?: boolean;\n  /**\n   * The pipeline notification events that will trigger a Slack channel notification.\n   * Only applies if `enableSlackNotification` is set to true.\n   *\n   * @default [PipelineNotificationEvents.PIPELINE_EXECUTION_FAILED] –\n   *   Only failed pipeline executions will trigger a notification.\n   */\n  readonly notificationEvents?: PipelineNotificationEvents[];\n\n  /**\n   * Whether to reuse the existing artifact bucket for cross-deployment pipelines.\n   * If set to true, it will look up the existing artifact bucket in the TOOLCHAIN account.\n   *\n   * @default True\n   */\n  readonly reuseExistingArtifactBucket?: boolean;\n\n  /**\n   * Remove assets from the CDK assembly pre-deployment to prevent hitting CodePipeline's 256 MB artifact size limit.\n   * Useful when CDK assets (Lambda code, Docker images, etc.) are large.\n   *\n   * @see https://github.com/aws/aws-cdk/issues/9917\n   */\n  readonly stripAssemblyAssets?: boolean;\n  /**\n   * Configuration for drift detection checks before deployment.\n   * If specified, the pipeline will check for CloudFormation drift and fail if detected.\n   */\n  readonly driftCheckConfig?: DriftCheckConfig;\n}\n\n/**\n * A CDK construct that creates a deployment pipeline across environments for the OrcaBus project.\n *\n * Prerequisite: Ensure that the \"CrossDeploymentArtifactBucket\" stack is deployed in the TOOLCHAIN account\n * before using this construct.\n */\nexport class DeploymentStackPipeline extends Construct {\n  /**\n   * The code pipeline construct that is created.\n   */\n  readonly pipeline: Pipeline;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: DeploymentStackPipelineProps,\n  ) {\n    super(scope, id);\n\n    const codeStarArn = StringParameter.valueForStringParameter(\n      this,\n      \"codestar_github_arn\",\n    );\n    const codeStarSourceActionName = \"pipeline-src\";\n    const sourceFile = CodePipelineSource.connection(\n      `OrcaBus/${props.githubRepo}`,\n      props.githubBranch,\n      {\n        connectionArn: codeStarArn,\n        actionName: codeStarSourceActionName,\n        triggerOnPush: true,\n      },\n    );\n\n    const isReusingExistingArtifactBucket =\n      props.reuseExistingArtifactBucket ?? true;\n    const artifactBucket = isReusingExistingArtifactBucket\n      ? CrossDeploymentArtifactBucket.fromLookup(this).artifactBucket\n      : undefined;\n\n    this.pipeline = new Pipeline(this, \"DeploymentCodePipeline\", {\n      artifactBucket: artifactBucket,\n      pipelineType: PipelineType.V2,\n      pipelineName: props.pipelineName,\n      crossAccountKeys: true,\n    });\n\n    if (props.includedFilePaths || props.excludedFilePaths) {\n      const filePaths: Record<string, string[]> = {};\n\n      if (props.includedFilePaths) {\n        filePaths[\"Includes\"] = props.includedFilePaths;\n      }\n      if (props.excludedFilePaths) {\n        filePaths[\"Excludes\"] = props.excludedFilePaths;\n      }\n\n      // Add event filter to only trigger if the push event is from `deploy` directory\n      const cfnPipeline = this.pipeline.node.defaultChild as CfnPipeline;\n      cfnPipeline.addPropertyOverride(\"Triggers\", [\n        {\n          GitConfiguration: {\n            Push: [\n              {\n                Branches: {\n                  Includes: [props.githubBranch],\n                },\n                FilePaths: filePaths,\n              },\n            ],\n            SourceActionName: codeStarSourceActionName,\n          },\n          ProviderType: \"CodeStarSourceConnection\",\n        },\n      ]);\n    }\n\n    // Add unit test for IaC at the root of the\n    const {\n      command: unitIacTestCommand = [\"make install\", \"make test\"],\n      partialBuildSpec: unitIacPartialBuildSpec = undefined,\n    } = props.unitIacTestConfig || {};\n    const unitIacTest = new CodeBuildStep(\"UnitIacTest\", {\n      commands: unitIacTestCommand,\n      input: sourceFile,\n      buildEnvironment: {\n        privileged: true,\n        computeType: ComputeType.LARGE,\n        buildImage: LinuxArmBuildImage.AMAZON_LINUX_2_STANDARD_3_0,\n        environmentVariables: {\n          NODE_OPTIONS: {\n            value: \"--max-old-space-size=8192\",\n          },\n        },\n      },\n      partialBuildSpec: unitIacPartialBuildSpec\n        ? BuildSpec.fromObject(unitIacPartialBuildSpec)\n        : undefined,\n    });\n\n    // Adding unit test for the main app\n    const {\n      command: unitAppTestCommand,\n      partialBuildSpec: unitAppPartialBuildSpec = undefined,\n    } = props.unitAppTestConfig;\n    const unitAppTest = new CodeBuildStep(\"UnitAppTest\", {\n      commands: unitAppTestCommand,\n      input: sourceFile,\n      buildEnvironment: {\n        privileged: true,\n        computeType: ComputeType.LARGE,\n        buildImage: LinuxArmBuildImage.AMAZON_LINUX_2_STANDARD_3_0,\n        environmentVariables: {\n          NODE_OPTIONS: {\n            value: \"--max-old-space-size=8192\",\n          },\n        },\n      },\n      partialBuildSpec: unitAppPartialBuildSpec\n        ? BuildSpec.fromObject(unitAppPartialBuildSpec)\n        : undefined,\n    });\n\n    const { synthBuildSpec = DEFAULT_SYNTH_STEP_PARTIAL_BUILD_SPEC } = props;\n    const synthStep = new CodeBuildStep(\"CdkSynth\", {\n      installCommands: [\n        \"node -v\",\n        \"npm install --global corepack@latest\",\n        \"corepack --version\",\n        \"corepack enable\",\n      ],\n      commands: props.cdkSynthCmd,\n      input: sourceFile,\n      primaryOutputDirectory: props.cdkOut || \"cdk.out\",\n      partialBuildSpec: BuildSpec.fromObject(synthBuildSpec),\n    });\n    synthStep.addStepDependency(unitIacTest);\n    synthStep.addStepDependency(unitAppTest);\n\n    const cdkPipeline = new CodePipeline(this, \"CDKCodePipeline\", {\n      codePipeline: this.pipeline,\n      synth: synthStep,\n      selfMutation: true,\n      codeBuildDefaults: {\n        buildEnvironment: {\n          computeType: ComputeType.LARGE,\n          buildImage: LinuxArmBuildImage.AMAZON_LINUX_2_STANDARD_3_0,\n          environmentVariables: {\n            NODE_OPTIONS: {\n              value: \"--max-old-space-size=8192\",\n            },\n          },\n        },\n      },\n    });\n\n    const defaultStageEnv: StageEnvProps = {\n      beta: BETA_ENVIRONMENT,\n      gamma: GAMMA_ENVIRONMENT,\n      prod: PROD_ENVIRONMENT,\n    };\n    const stageEnv = props.stageEnv || defaultStageEnv;\n\n    // After assets are published, they can be removed from the assembly directory\n    // to help prevent hitting the CodePipeline artifact limit.\n    // https://github.com/aws/aws-cdk/issues/9917\n    let stripAssetsFromAssembly: CodeBuildStep | undefined;\n    if (props.stripAssemblyAssets) {\n      stripAssetsFromAssembly = new CodeBuildStep(\"StripAssetsFromAssembly\", {\n        input: cdkPipeline.cloudAssemblyFileSet,\n        commands: [\n          'S3_PATH=${CODEBUILD_SOURCE_VERSION#\"arn:aws:s3:::\"}',\n          \"ZIP_ARCHIVE=$(basename $S3_PATH)\",\n          \"echo $S3_PATH\",\n          \"echo $ZIP_ARCHIVE\",\n          \"ls\",\n          \"rm -rfv asset.*\",\n          \"zip -r -q -A $ZIP_ARCHIVE *\",\n          \"ls\",\n          \"aws s3 cp $ZIP_ARCHIVE s3://$S3_PATH\",\n        ],\n      });\n\n      cdkPipeline.addWave(\"BeforeStageDeployment\", {\n        pre: [stripAssetsFromAssembly],\n      });\n    }\n\n    // Construct function to get StackId for drift check\n    const rootStackName = Stack.of(this).stackName;\n    const constructId = this.node.id;\n    const getStackId = (envName: string) =>\n      `${rootStackName}/${constructId}/${envName}/${props.stackName}`;\n\n    // Drift check config\n    const isDriftCheckStep = !!props.driftCheckConfig;\n    const cdkInstallCmd =\n      props.driftCheckConfig?.installCommand ??\n      \"pnpm install --frozen-lockfile --ignore-scripts\";\n    const cdkRunCmd = props.driftCheckConfig?.cdkCommand ?? ``;\n\n    const betaEnvName = \"OrcaBusBeta\";\n    cdkPipeline.addStage(\n      new DeploymentStage(\n        this,\n        betaEnvName,\n        stageEnv.beta,\n        props.stackName,\n        props.stack,\n        props.stackConfig.beta,\n        props.githubRepo,\n        props.githubBranch,\n      ),\n      {\n        pre: isDriftCheckStep\n          ? [\n              new FailOnDriftBuildStep(\"DriftOnFailBetaCheck\", {\n                accountEnv: stageEnv.beta,\n                stackId: getStackId(betaEnvName),\n                cdkCommand: cdkRunCmd,\n                installCommand: cdkInstallCmd,\n              }),\n            ]\n          : undefined,\n      },\n    );\n\n    /**\n     * GAMMA\n     */\n    const gammaEnvName = \"OrcaBusGamma\";\n\n    cdkPipeline.addStage(\n      new DeploymentStage(\n        this,\n        gammaEnvName,\n        stageEnv.gamma,\n        props.stackName,\n        props.stack,\n        props.stackConfig.gamma,\n        props.githubRepo,\n        props.githubBranch,\n      ),\n      {\n        pre: isDriftCheckStep\n          ? [\n              new FailOnDriftBuildStep(\"DriftOnFailGammaCheck\", {\n                accountEnv: stageEnv.gamma,\n                stackId: getStackId(gammaEnvName),\n                cdkCommand: cdkRunCmd,\n                installCommand: cdkInstallCmd,\n              }),\n            ]\n          : undefined,\n        post: [\n          new ManualApprovalActionStep(\"PromoteToProd\", {\n            actionName: \"PromoteToProd\",\n            // Custom steps bypass stage pre/post ordering, so runOrder must be explicitly set.\n            // Set to 5 to ensure this runs after all OrcaBusGamma stage steps complete.\n            // (Gamma deployment typically uses 2 steps, so 5 provides adequate buffer)\n            runOrder: 5,\n            // 60-minute timeout allows queued pipeline executions to proceed if approval expires\n            timeout: Duration.minutes(60),\n          }),\n        ],\n      },\n    );\n\n    /**\n     * PROD\n     */\n    const prodEnvName = \"OrcaBusProd\";\n\n    cdkPipeline.addStage(\n      new DeploymentStage(\n        this,\n        prodEnvName,\n        stageEnv.prod,\n        props.stackName,\n        props.stack,\n        props.stackConfig.prod,\n        props.githubRepo,\n        props.githubBranch,\n      ),\n      {\n        pre: isDriftCheckStep\n          ? [\n              new FailOnDriftBuildStep(\"DriftOnFailProdCheck\", {\n                accountEnv: stageEnv.prod,\n                stackId: getStackId(prodEnvName),\n                cdkCommand: cdkRunCmd,\n                installCommand: cdkInstallCmd,\n              }),\n            ]\n          : undefined,\n      },\n    );\n\n    cdkPipeline.buildPipeline();\n\n    if (stripAssetsFromAssembly) {\n      cdkPipeline.pipeline.artifactBucket.grantReadWrite(\n        stripAssetsFromAssembly.project,\n      );\n    }\n\n    if (props.enableSlackNotification ?? true) {\n      const alertsBuildSlackConfigArn = StringParameter.valueForStringParameter(\n        this,\n        \"/chatbot_arn/slack/alerts-build\",\n      );\n      const target = SlackChannelConfiguration.fromSlackChannelConfigurationArn(\n        this,\n        \"SlackChannelConfiguration\",\n        alertsBuildSlackConfigArn,\n      );\n\n      this.pipeline.notifyOn(\"PipelineSlackNotification\", target, {\n        events: props.notificationEvents || [\n          PipelineNotificationEvents.PIPELINE_EXECUTION_FAILED,\n        ],\n        detailType: DetailType.FULL,\n        notificationRuleName: `OrcaBus-${props.pipelineName}`,\n      });\n    }\n  }\n}\n\n/**\n * Properties for ManualApprovalActionStep with required runOrder.\n */\ninterface ManualApprovalActionStepProps extends ManualApprovalActionProps {\n  /**\n   * The run order for this action in the pipeline stage. The stage Pre/Post order does not apply to this custom\n   * step/action, you need to explicitly set the runOrder.\n   */\n  runOrder: number;\n}\n/**\n * Custom manual approval step for CDK CodePipeline.\n *\n * This class bridges the gap to enable using ManualApprovalAction within a Step class,\n * making it compatible with cdk.pipelines constructs.\n *\n * @param id - The unique identifier for the step.\n * @param options - The properties for the manual approval action, including\n */\nclass ManualApprovalActionStep\n  extends Step\n  implements ICodePipelineActionFactory\n{\n  private readonly manualApprovalActionProps: ManualApprovalActionStepProps;\n  constructor(id: string, options: ManualApprovalActionStepProps) {\n    super(id);\n    this.manualApprovalActionProps = options;\n  }\n\n  public produceAction(\n    stage: IStage,\n    options: ProduceActionOptions,\n  ): CodePipelineActionFactoryResult {\n    stage.addAction(new ManualApprovalAction(this.manualApprovalActionProps));\n\n    return { runOrdersConsumed: 1 };\n  }\n}\n\nclass DeploymentStage extends Stage {\n  constructor(\n    scope: Construct,\n    environmentName: string,\n    env: Environment,\n    stackName: string,\n    stackClass: new (scope: Construct, id: string, props: any) => Stack,\n    appStackProps: any,\n    githubRepo: string,\n    githubBranch?: string,\n  ) {\n    super(scope, environmentName, { env: env });\n\n    let source = `https://github.com/OrcaBus/${githubRepo}`;\n    if (githubBranch !== undefined && githubBranch !== \"main\") {\n      source = `${source}/tree/${githubBranch}`;\n    }\n\n    new stackClass(this, stackName, {\n      env: env,\n      tags: {\n        \"umccr-org:Product\": \"OrcaBus\",\n        \"umccr-org:Creator\": \"CDK\",\n        \"umccr-org:Service\": stackName,\n        \"umccr-org:Source\": source,\n      },\n      ...appStackProps,\n    });\n  }\n}\n\nexport interface FailOnDriftBuildStepProps {\n  /**\n   * AWS account and region where the drift check runs.\n   * Used to assume the CDK lookup role and set AWS_DEFAULT_REGION.\n   */\n  readonly accountEnv: Environment;\n  /**\n   * Fully qualified CDK stack ID to check for drift.\n   *\n   * Format: `<rootStack>/<constructId>/<envName>/<stackName>`\n   *\n   * Example: `DevStack/DeploymentPipeline/OrcaBusBeta/TestStack`\n   */\n  readonly stackId: string;\n  /**\n   * CDK CLI entrypoint used to run the drift command.\n   * Examples: \"pnpm cdk\", \"pnpm cdk-stateful\", \"pnpm cdk-stateless\".\n   * Must support: \"drift <stackId>\".\n   */\n  readonly cdkCommand: string;\n  /**\n   * Command to install dependencies before running CDK.\n   * If your app is in a subdirectory, prefix with \"cd <dir> &&\".\n   * Example: \"cd dev && pnpm install --frozen-lockfile --ignore-scripts\"\n   *\n   * Default: \"pnpm install --frozen-lockfile --ignore-scripts\"\n   */\n  readonly installCommand?: string;\n}\n\nclass FailOnDriftBuildStep extends CodeBuildStep {\n  constructor(\n    id: string,\n    {\n      accountEnv,\n      stackId,\n      cdkCommand,\n      installCommand,\n    }: FailOnDriftBuildStepProps,\n  ) {\n    const cdkInstall = installCommand\n      ? installCommand\n      : \"pnpm install --frozen-lockfile --ignore-scripts\";\n\n    super(id, {\n      commands: [\n        \"node -v\",\n        \"npm install --global corepack@latest\",\n        \"corepack --version\",\n        \"corepack enable\",\n        cdkInstall,\n\n        `LOOKUP_ROLE_ARN=\"arn:aws:iam::${accountEnv.account}:role/cdk-hnb659fds-lookup-role-${accountEnv.account}-${accountEnv.region}\"`,\n        'SESSION_NAME=\"drift-check\"',\n        'read AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN < <(aws sts assume-role --role-arn \"$LOOKUP_ROLE_ARN\" --role-session-name \"$SESSION_NAME\" --duration-seconds 900 --query \\'Credentials.[AccessKeyId,SecretAccessKey,SessionToken]\\' --output text)',\n        \"export AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN\",\n        `export AWS_DEFAULT_REGION=\"${accountEnv.region}\"`,\n        \"aws sts get-caller-identity\",\n\n        `if ${cdkCommand} ls | grep -Fq \"${stackId}\"; then echo \"Stack ${stackId} found; checking for drift...\"; ${cdkCommand} drift \"${stackId}\" -e --fail; else echo \"Stack not found in cdk ls; skipping drift check.\"; fi`,\n      ],\n      rolePolicyStatements: [\n        new PolicyStatement({\n          actions: [\"sts:AssumeRole\"],\n          resources: [\n            `arn:aws:iam::${accountEnv.account}:role/cdk-hnb659fds-lookup-role-${accountEnv.account}-${accountEnv.region}`,\n          ],\n        }),\n      ],\n    });\n  }\n}\n"]}

package/dynamodb/index.js

@@ -40,7 +40,7 @@ const dynamodb = __importStar(require("aws-cdk-lib/aws-dynamodb"));
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const config_1 = require("./config");
 class DynamoDbPartitionedConstruct extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.dynamodb.DynamoDbPartitionedConstruct", version: "0.0.103" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.dynamodb.DynamoDbPartitionedConstruct", version: "1.0.0" };
     table;
     constructor(scope, id, props) {
         super(scope, id);
@@ -75,7 +75,7 @@ class DynamoDbPartitionedConstruct extends constructs_1.Construct {
 }
 exports.DynamoDbPartitionedConstruct = DynamoDbPartitionedConstruct;
 class DynamoDbNonPartitionedConstruct extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.dynamodb.DynamoDbNonPartitionedConstruct", version: "0.0.103" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.dynamodb.DynamoDbNonPartitionedConstruct", version: "1.0.0" };
     table;
     constructor(scope, id, props) {
         super(scope, id);

package/ecs/index.js

@@ -55,7 +55,7 @@ exports.LAMBDA_ARCHITECTURE_MAP = {
     ['ARM64']: lambda.Architecture.ARM_64
 };
 class EcsFargateTaskConstruct extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.ecs.EcsFargateTaskConstruct", version: "0.0.103" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.ecs.EcsFargateTaskConstruct", version: "1.0.0" };
     cluster;
     taskDefinition;
     taskExecutionRole;

package/eventbridge-rules/sfn-slack-notification.js

@@ -17,7 +17,7 @@ var SfnEventStatus;
     SfnEventStatus["ABORTED"] = "ABORTED";
 })(SfnEventStatus || (exports.SfnEventStatus = SfnEventStatus = {}));
 class SfnSlackNotification extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.eventbridgeRule.SfnSlackNotification", version: "0.0.103" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.eventbridgeRule.SfnSlackNotification", version: "1.0.0" };
     rule;
     constructor(scope, id, props) {
         super(scope, id);

package/lambda/index.js

@@ -57,7 +57,7 @@ function getPythonUvDockerImage() {
     return aws_cdk_lib_1.DockerImage.fromBuild(path_1.default.join(__dirname, 'build_python'));
 }
 class PythonUvFunction extends aws_lambda_python_alpha_1.PythonFunction {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.lambda.PythonUvFunction", version: "0.0.103" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@orcabus/platform-cdk-constructs.lambda.PythonUvFunction", version: "1.0.0" };
     // Class constructs, to be used for caching the layers
     // This means that if there are multiple lambdas throughout the stack
     // They will all use the same layer

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/fastq/workflow_helpers.py

@@ -7,7 +7,7 @@ Workflow helpers - a collection of helper functions for the workflow
 """
 
 # Standard library imports
-from typing import List
+from typing import List, Optional
 
 # Local imports
 from . import get_fastq_request
@@ -15,12 +15,35 @@ from .globals import FASTQ_ENDPOINT, FASTQ_SET_ENDPOINT
 from .models import FastqListRowDict
 
 
-def to_fastq_list_row(fastq_id) -> FastqListRowDict:
+def to_fastq_list_row(
+        fastq_id: str,
+        bucket: Optional[str] = None,
+        key_prefix: Optional[str] = None,
+) -> FastqListRowDict:
     return get_fastq_request(
-        f"{FASTQ_ENDPOINT}/{fastq_id}/toFastqListRow"
+        f"{FASTQ_ENDPOINT}/{fastq_id}/toFastqListRow",
+        params=dict(filter(
+            lambda param_iter_: param_iter_[1] is not None,
+            {
+                "bucket": bucket,
+                "keyPrefix": key_prefix,
+            }.items()
+        ))
     )
 
-def to_fastq_list_rows(fastq_set_id: str) -> List[FastqListRowDict]:
+
+def to_fastq_list_rows(
+        fastq_set_id: str,
+        bucket: Optional[str] = None,
+        key_prefix: Optional[str] = None,
+) -> List[FastqListRowDict]:
     return get_fastq_request(
-        f"{FASTQ_SET_ENDPOINT}/{fastq_set_id}/toFastqListRows"
+        f"{FASTQ_SET_ENDPOINT}/{fastq_set_id}/toFastqListRows",
+        params=dict(filter(
+            lambda param_iter_: param_iter_[1] is not None,
+            {
+                "bucket": bucket,
+                "keyPrefix": key_prefix,
+            }.items()
+        ))
     )

package/lambda/layers/orcabus_api_tools/src/orcabus_api_tools/filemanager/file_helpers.py

@@ -5,7 +5,7 @@ import json
 from functools import reduce
 from operator import concat
 from pathlib import Path
-from typing import List, Dict, Union
+from typing import List, Dict, Union, Optional, Unpack
 import typing
 import boto3
 from datetime import datetime, timedelta, timezone
@@ -14,7 +14,7 @@ from itertools import batched
 
 # Local imports
 from .errors import S3FileNotFoundError, S3DuplicateFileCopyError
-from .models import FileObject, StorageClassPriority
+from .models import FileObject, StorageClassPriority, FileQueryParameters
 from ..utils.miscell import get_bucket_key_pair_from_uri
 from . import (
     get_file_manager_request_response_results,
@@ -84,7 +84,10 @@ def get_file_object_from_id(s3_object_id: str) -> FileObject:
     return FileObject(**response[0])
 
 
-def get_file_object_from_ingest_id(ingest_id: str, **kwargs) -> FileObject:
+def get_file_object_from_ingest_id(
+        ingest_id: str,
+        **kwargs: Unpack[FileQueryParameters]
+) -> FileObject:
     response = get_file_manager_request_response_results(S3_LIST_ENDPOINT, {
         "ingestId": ingest_id,
         **kwargs
@@ -199,8 +202,21 @@ def get_s3_uri_from_s3_object_id(s3_object_id: str) -> str:
     return f"s3://{file_object['bucket']}/{file_object['key']}"
 
 
-def get_s3_uri_from_ingest_id(ingest_id: str) -> str:
-    file_object: FileObject = get_file_object_from_ingest_id(ingest_id)
+def get_s3_uri_from_ingest_id(
+        ingest_id: str,
+        bucket: Optional[str] = None,
+        key_prefix: Optional[str] = None
+) -> str:
+    file_object: FileObject = get_file_object_from_ingest_id(
+        ingest_id=ingest_id,
+        **dict(filter(
+            lambda param_iter_: param_iter_[1] is not None,
+            {
+                "bucket": bucket,
+                "key": f"{key_prefix}*" if key_prefix else None
+            }.items()
+        ))
+    )
     return f"s3://{file_object['bucket']}/{file_object['key']}"