@jjrawlins/cdk-deploy-pr-github-action 0.0.0

package/lib/CdkDeployPipeline.js

@@ -0,0 +1,274 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdkDeployPipeline = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const github_1 = require("projen/lib/github");
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+const CdkDeployDispatchWorkflow_1 = require("./CdkDeployDispatchWorkflow");
+const utils_1 = require("./utils");
+const CHECKOUT_VERSION = 'v5';
+const SETUP_NODE_VERSION = 'v5';
+const AWS_CREDENTIALS_VERSION = 'v5';
+const UPLOAD_ARTIFACT_VERSION = 'v4';
+const DOWNLOAD_ARTIFACT_VERSION = 'v5';
+/**
+ * Generates GitHub Actions workflows for CDK deployments.
+ *
+ * Creates a `deploy.yml` workflow with:
+ * - Synth job to compile and synthesize the CDK app
+ * - Asset publish job to upload Lambda/container assets to AWS
+ * - Per-stage deploy jobs with GitHub Environments, parallel execution, and concurrency groups
+ *
+ * Optionally creates a `deploy-dispatch.yml` workflow for manual deployments and rollbacks.
+ */
+class CdkDeployPipeline {
+    constructor(project, options) {
+        const { pkgNamespace, stackPrefix, iamRoleArn, iamRoleRegion = 'us-east-1', nodeVersion = '24.x', cdkCommand = 'npx cdk', installCommand = 'yarn install --check-files --frozen-lockfile', stages, manualDeployment = true, useGithubPackagesForAssembly = true, branchName = 'main', } = options;
+        // Validate inputs
+        if (stages.length === 0) {
+            throw new Error('At least one deployment stage must be defined');
+        }
+        const stageNames = new Set(stages.map((s) => s.name));
+        for (const stage of stages) {
+            if (stage.dependsOn) {
+                for (const dep of stage.dependsOn) {
+                    if (!stageNames.has(dep)) {
+                        throw new Error(`Stage '${stage.name}' depends on '${dep}', which is not a defined stage. Available: ${[...stageNames].join(', ')}`);
+                    }
+                    if (dep === stage.name) {
+                        throw new Error(`Stage '${stage.name}' cannot depend on itself`);
+                    }
+                }
+            }
+        }
+        (0, utils_1.validateNoCycles)(stages);
+        if (useGithubPackagesForAssembly && !pkgNamespace) {
+            throw new Error('pkgNamespace is required when useGithubPackagesForAssembly is enabled');
+        }
+        // Create the deploy workflow
+        const gh = project.github ?? new github_1.GitHub(project);
+        const workflow = new github_1.GithubWorkflow(gh, 'deploy', {
+            fileName: 'deploy.yml',
+        });
+        workflow.on({
+            push: { branches: [branchName] },
+            workflowDispatch: {},
+        });
+        const appName = project.name ?? stackPrefix.toLowerCase();
+        // Build jobs object
+        const jobs = {};
+        // --- Synth Job ---
+        jobs.synth = {
+            name: 'Synthesize CDK application',
+            runsOn: ['ubuntu-latest'],
+            permissions: {
+                contents: workflows_model_1.JobPermission.READ,
+                packages: workflows_model_1.JobPermission.READ,
+            },
+            env: { CI: 'true' },
+            steps: [
+                {
+                    name: 'Checkout',
+                    uses: `actions/checkout@${CHECKOUT_VERSION}`,
+                    with: { 'fetch-depth': 0 },
+                },
+                {
+                    name: 'Setup Node.js',
+                    uses: `actions/setup-node@${SETUP_NODE_VERSION}`,
+                    with: {
+                        'node-version': nodeVersion,
+                        'registry-url': 'https://npm.pkg.github.com',
+                    },
+                },
+                {
+                    name: 'Install dependencies',
+                    run: installCommand,
+                    env: { NODE_AUTH_TOKEN: '${{ secrets.GITHUB_TOKEN }}', GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },
+                },
+                {
+                    name: 'Synth',
+                    run: `${cdkCommand} synth`,
+                },
+                {
+                    name: 'Upload cloud assembly',
+                    uses: `actions/upload-artifact@${UPLOAD_ARTIFACT_VERSION}`,
+                    with: {
+                        name: 'cloud-assembly',
+                        path: 'cdk.out/',
+                    },
+                },
+            ],
+        };
+        // --- Publish Assets Job ---
+        const publishSteps = [
+            {
+                name: 'Checkout',
+                uses: `actions/checkout@${CHECKOUT_VERSION}`,
+                with: { 'fetch-depth': 0 },
+            },
+            {
+                name: 'Setup Node.js',
+                uses: `actions/setup-node@${SETUP_NODE_VERSION}`,
+                with: {
+                    'node-version': nodeVersion,
+                    'registry-url': 'https://npm.pkg.github.com',
+                },
+            },
+            {
+                name: 'Install dependencies',
+                run: installCommand,
+                env: { NODE_AUTH_TOKEN: '${{ secrets.GITHUB_TOKEN }}', GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },
+            },
+            {
+                name: 'Download cloud assembly',
+                uses: `actions/download-artifact@${DOWNLOAD_ARTIFACT_VERSION}`,
+                with: { name: 'cloud-assembly', path: 'cdk.out/' },
+            },
+            {
+                name: 'AWS Credentials',
+                uses: `aws-actions/configure-aws-credentials@${AWS_CREDENTIALS_VERSION}`,
+                with: {
+                    'role-to-assume': iamRoleArn,
+                    'role-session-name': 'GitHubAction',
+                    'aws-region': iamRoleRegion,
+                },
+            },
+            {
+                name: 'Publish assets',
+                run: 'npx cdk-assets publish -p cdk.out/**/*-assets.json',
+            },
+        ];
+        if (useGithubPackagesForAssembly) {
+            publishSteps.push({
+                name: 'Configure git identity',
+                run: [
+                    'git config user.name "github-actions[bot]"',
+                    'git config user.email "41898282+github-actions[bot]@users.noreply.github.com"',
+                ].join('\n'),
+            }, {
+                name: 'Create assembly package',
+                run: [
+                    `echo '${JSON.stringify({ name: `${pkgNamespace}/${appName}`, version: '0.0.0' })}' > cdk.out/package.json`,
+                    'cd cdk.out && npm version --no-git-tag-version from-git || npm version --no-git-tag-version patch',
+                ].join('\n'),
+                env: { NODE_AUTH_TOKEN: '${{ secrets.GITHUB_TOKEN }}', GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },
+            }, {
+                name: 'Publish assembly to GitHub Packages',
+                run: 'cd cdk.out && npm publish',
+                env: { NODE_AUTH_TOKEN: '${{ secrets.GITHUB_TOKEN }}', GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },
+            });
+        }
+        jobs['publish-assets'] = {
+            name: 'Publish assets to AWS',
+            needs: ['synth'],
+            runsOn: ['ubuntu-latest'],
+            permissions: {
+                contents: workflows_model_1.JobPermission.WRITE,
+                packages: workflows_model_1.JobPermission.WRITE,
+                idToken: workflows_model_1.JobPermission.WRITE,
+            },
+            env: { CI: 'true' },
+            steps: publishSteps,
+        };
+        // --- Per-Stage Deploy Jobs ---
+        for (const stage of stages) {
+            const jobId = `deploy-${(0, utils_1.toKebabCase)(stage.name)}`;
+            const stacks = stage.stacks ?? [`${stackPrefix}-${stage.name}`];
+            const githubEnv = stage.environment ?? stage.name;
+            const roleArn = stage.iamRoleArn ?? iamRoleArn;
+            const roleRegion = stage.iamRoleRegion ?? iamRoleRegion ?? stage.env.region;
+            // Compute needs
+            let needs;
+            if (stage.dependsOn && stage.dependsOn.length > 0) {
+                needs = stage.dependsOn.map((dep) => `deploy-${(0, utils_1.toKebabCase)(dep)}`);
+            }
+            else {
+                needs = ['publish-assets'];
+            }
+            const deployCommand = stacks
+                .map((s) => `${cdkCommand} deploy ${s} --require-approval never --app cdk.out`)
+                .join(' && ');
+            jobs[jobId] = {
+                name: `Deploy ${stage.name}`,
+                needs: needs,
+                runsOn: ['ubuntu-latest'],
+                environment: githubEnv,
+                concurrency: {
+                    'group': `deploy-${(0, utils_1.toKebabCase)(stage.name)}`,
+                    'cancel-in-progress': false,
+                },
+                permissions: {
+                    contents: workflows_model_1.JobPermission.READ,
+                    packages: workflows_model_1.JobPermission.READ,
+                    idToken: workflows_model_1.JobPermission.WRITE,
+                },
+                env: { CI: 'true' },
+                steps: [
+                    {
+                        name: 'Checkout',
+                        uses: `actions/checkout@${CHECKOUT_VERSION}`,
+                    },
+                    {
+                        name: 'Setup Node.js',
+                        uses: `actions/setup-node@${SETUP_NODE_VERSION}`,
+                        with: {
+                            'node-version': nodeVersion,
+                            'registry-url': 'https://npm.pkg.github.com',
+                        },
+                    },
+                    {
+                        name: 'Install dependencies',
+                        run: installCommand,
+                        env: { NODE_AUTH_TOKEN: '${{ secrets.GITHUB_TOKEN }}', GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },
+                    },
+                    {
+                        name: 'Download cloud assembly',
+                        uses: `actions/download-artifact@${DOWNLOAD_ARTIFACT_VERSION}`,
+                        with: { name: 'cloud-assembly', path: 'cdk.out/' },
+                    },
+                    {
+                        name: 'AWS Credentials',
+                        uses: `aws-actions/configure-aws-credentials@${AWS_CREDENTIALS_VERSION}`,
+                        with: {
+                            'role-to-assume': roleArn,
+                            'role-session-name': 'GitHubAction',
+                            'aws-region': roleRegion,
+                        },
+                    },
+                    {
+                        name: `Deploy ${stage.name}`,
+                        run: deployCommand,
+                    },
+                ],
+            };
+            // Create projen task for local usage
+            project.addTask(`deploy:${stage.name}`, {
+                description: `Deploy to ${stage.name}`,
+                exec: stacks
+                    .map((s) => `${cdkCommand} deploy ${s} --require-approval never`)
+                    .join(' && '),
+            });
+        }
+        // Add all jobs to the workflow
+        workflow.addJobs(jobs);
+        // --- Dispatch Workflow ---
+        if (manualDeployment && useGithubPackagesForAssembly) {
+            new CdkDeployDispatchWorkflow_1.CdkDeployDispatchWorkflow(project, {
+                stages,
+                pkgNamespace,
+                appName,
+                stackPrefix,
+                iamRoleArn,
+                iamRoleRegion,
+                nodeVersion,
+                cdkCommand,
+                installCommand,
+            });
+        }
+    }
+}
+exports.CdkDeployPipeline = CdkDeployPipeline;
+_a = JSII_RTTI_SYMBOL_1;
+CdkDeployPipeline[_a] = { fqn: "@jjrawlins/cdk-deploy-pr-github-action.CdkDeployPipeline", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CdkDeployPipeline.js","sourceRoot":"","sources":["../src/CdkDeployPipeline.ts"],"names":[],"mappings":"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","sourcesContent":["import { GitHub, GithubWorkflow } from 'projen/lib/github';\nimport { JobPermission } from 'projen/lib/github/workflows-model';\nimport { CdkDeployDispatchWorkflow } from './CdkDeployDispatchWorkflow';\nimport { CdkDeployPipelineOptions, DeployStageOptions } from './types';\nimport { toKebabCase, validateNoCycles } from './utils';\n\nconst CHECKOUT_VERSION = 'v5';\nconst SETUP_NODE_VERSION = 'v5';\nconst AWS_CREDENTIALS_VERSION = 'v5';\nconst UPLOAD_ARTIFACT_VERSION = 'v4';\nconst DOWNLOAD_ARTIFACT_VERSION = 'v5';\n\n/**\n * Generates GitHub Actions workflows for CDK deployments.\n *\n * Creates a `deploy.yml` workflow with:\n * - Synth job to compile and synthesize the CDK app\n * - Asset publish job to upload Lambda/container assets to AWS\n * - Per-stage deploy jobs with GitHub Environments, parallel execution, and concurrency groups\n *\n * Optionally creates a `deploy-dispatch.yml` workflow for manual deployments and rollbacks.\n */\nexport class CdkDeployPipeline {\n  constructor(project: any, options: CdkDeployPipelineOptions) {\n    const {\n      pkgNamespace,\n      stackPrefix,\n      iamRoleArn,\n      iamRoleRegion = 'us-east-1',\n      nodeVersion = '24.x',\n      cdkCommand = 'npx cdk',\n      installCommand = 'yarn install --check-files --frozen-lockfile',\n      stages,\n      manualDeployment = true,\n      useGithubPackagesForAssembly = true,\n      branchName = 'main',\n    } = options;\n\n    // Validate inputs\n    if (stages.length === 0) {\n      throw new Error('At least one deployment stage must be defined');\n    }\n\n    const stageNames = new Set(stages.map((s) => s.name));\n    for (const stage of stages) {\n      if (stage.dependsOn) {\n        for (const dep of stage.dependsOn) {\n          if (!stageNames.has(dep)) {\n            throw new Error(\n              `Stage '${stage.name}' depends on '${dep}', which is not a defined stage. Available: ${[...stageNames].join(', ')}`,\n            );\n          }\n          if (dep === stage.name) {\n            throw new Error(`Stage '${stage.name}' cannot depend on itself`);\n          }\n        }\n      }\n    }\n    validateNoCycles(stages);\n\n    if (useGithubPackagesForAssembly && !pkgNamespace) {\n      throw new Error(\n        'pkgNamespace is required when useGithubPackagesForAssembly is enabled',\n      );\n    }\n\n    // Create the deploy workflow\n    const gh = project.github ?? new GitHub(project);\n    const workflow = new GithubWorkflow(gh, 'deploy', {\n      fileName: 'deploy.yml',\n    });\n\n    workflow.on({\n      push: { branches: [branchName] },\n      workflowDispatch: {},\n    });\n\n    const appName = project.name ?? stackPrefix.toLowerCase();\n\n    // Build jobs object\n    const jobs: Record<string, any> = {};\n\n    // --- Synth Job ---\n    jobs.synth = {\n      name: 'Synthesize CDK application',\n      runsOn: ['ubuntu-latest'],\n      permissions: {\n        contents: JobPermission.READ,\n        packages: JobPermission.READ,\n      },\n      env: { CI: 'true' },\n      steps: [\n        {\n          name: 'Checkout',\n          uses: `actions/checkout@${CHECKOUT_VERSION}`,\n          with: { 'fetch-depth': 0 },\n        },\n        {\n          name: 'Setup Node.js',\n          uses: `actions/setup-node@${SETUP_NODE_VERSION}`,\n          with: {\n            'node-version': nodeVersion,\n            'registry-url': 'https://npm.pkg.github.com',\n          },\n        },\n        {\n          name: 'Install dependencies',\n          run: installCommand,\n          env: { NODE_AUTH_TOKEN: '${{ secrets.GITHUB_TOKEN }}', GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },\n        },\n        {\n          name: 'Synth',\n          run: `${cdkCommand} synth`,\n        },\n        {\n          name: 'Upload cloud assembly',\n          uses: `actions/upload-artifact@${UPLOAD_ARTIFACT_VERSION}`,\n          with: {\n            name: 'cloud-assembly',\n            path: 'cdk.out/',\n          },\n        },\n      ],\n    };\n\n    // --- Publish Assets Job ---\n    const publishSteps: any[] = [\n      {\n        name: 'Checkout',\n        uses: `actions/checkout@${CHECKOUT_VERSION}`,\n        with: { 'fetch-depth': 0 },\n      },\n      {\n        name: 'Setup Node.js',\n        uses: `actions/setup-node@${SETUP_NODE_VERSION}`,\n        with: {\n          'node-version': nodeVersion,\n          'registry-url': 'https://npm.pkg.github.com',\n        },\n      },\n      {\n        name: 'Install dependencies',\n        run: installCommand,\n        env: { NODE_AUTH_TOKEN: '${{ secrets.GITHUB_TOKEN }}', GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },\n      },\n      {\n        name: 'Download cloud assembly',\n        uses: `actions/download-artifact@${DOWNLOAD_ARTIFACT_VERSION}`,\n        with: { name: 'cloud-assembly', path: 'cdk.out/' },\n      },\n      {\n        name: 'AWS Credentials',\n        uses: `aws-actions/configure-aws-credentials@${AWS_CREDENTIALS_VERSION}`,\n        with: {\n          'role-to-assume': iamRoleArn,\n          'role-session-name': 'GitHubAction',\n          'aws-region': iamRoleRegion,\n        },\n      },\n      {\n        name: 'Publish assets',\n        run: 'npx cdk-assets publish -p cdk.out/**/*-assets.json',\n      },\n    ];\n\n    if (useGithubPackagesForAssembly) {\n      publishSteps.push(\n        {\n          name: 'Configure git identity',\n          run: [\n            'git config user.name \"github-actions[bot]\"',\n            'git config user.email \"41898282+github-actions[bot]@users.noreply.github.com\"',\n          ].join('\\n'),\n        },\n        {\n          name: 'Create assembly package',\n          run: [\n            `echo '${JSON.stringify({ name: `${pkgNamespace}/${appName}`, version: '0.0.0' })}' > cdk.out/package.json`,\n            'cd cdk.out && npm version --no-git-tag-version from-git || npm version --no-git-tag-version patch',\n          ].join('\\n'),\n          env: { NODE_AUTH_TOKEN: '${{ secrets.GITHUB_TOKEN }}', GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },\n        },\n        {\n          name: 'Publish assembly to GitHub Packages',\n          run: 'cd cdk.out && npm publish',\n          env: { NODE_AUTH_TOKEN: '${{ secrets.GITHUB_TOKEN }}', GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },\n        },\n      );\n    }\n\n    jobs['publish-assets'] = {\n      name: 'Publish assets to AWS',\n      needs: ['synth'],\n      runsOn: ['ubuntu-latest'],\n      permissions: {\n        contents: JobPermission.WRITE,\n        packages: JobPermission.WRITE,\n        idToken: JobPermission.WRITE,\n      },\n      env: { CI: 'true' },\n      steps: publishSteps,\n    };\n\n    // --- Per-Stage Deploy Jobs ---\n    for (const stage of stages) {\n      const jobId = `deploy-${toKebabCase(stage.name)}`;\n      const stacks =\n        stage.stacks ?? [`${stackPrefix}-${stage.name}`];\n      const githubEnv = stage.environment ?? stage.name;\n      const roleArn = stage.iamRoleArn ?? iamRoleArn;\n      const roleRegion =\n        stage.iamRoleRegion ?? iamRoleRegion ?? stage.env.region;\n\n      // Compute needs\n      let needs: string[];\n      if (stage.dependsOn && stage.dependsOn.length > 0) {\n        needs = stage.dependsOn.map(\n          (dep) => `deploy-${toKebabCase(dep)}`,\n        );\n      } else {\n        needs = ['publish-assets'];\n      }\n\n      const deployCommand = stacks\n        .map((s) => `${cdkCommand} deploy ${s} --require-approval never --app cdk.out`)\n        .join(' && ');\n\n      jobs[jobId] = {\n        name: `Deploy ${stage.name}`,\n        needs: needs,\n        runsOn: ['ubuntu-latest'],\n        environment: githubEnv,\n        concurrency: {\n          'group': `deploy-${toKebabCase(stage.name)}`,\n          'cancel-in-progress': false,\n        },\n        permissions: {\n          contents: JobPermission.READ,\n          packages: JobPermission.READ,\n          idToken: JobPermission.WRITE,\n        },\n        env: { CI: 'true' },\n        steps: [\n          {\n            name: 'Checkout',\n            uses: `actions/checkout@${CHECKOUT_VERSION}`,\n          },\n          {\n            name: 'Setup Node.js',\n            uses: `actions/setup-node@${SETUP_NODE_VERSION}`,\n            with: {\n              'node-version': nodeVersion,\n              'registry-url': 'https://npm.pkg.github.com',\n            },\n          },\n          {\n            name: 'Install dependencies',\n            run: installCommand,\n            env: { NODE_AUTH_TOKEN: '${{ secrets.GITHUB_TOKEN }}', GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },\n          },\n          {\n            name: 'Download cloud assembly',\n            uses: `actions/download-artifact@${DOWNLOAD_ARTIFACT_VERSION}`,\n            with: { name: 'cloud-assembly', path: 'cdk.out/' },\n          },\n          {\n            name: 'AWS Credentials',\n            uses: `aws-actions/configure-aws-credentials@${AWS_CREDENTIALS_VERSION}`,\n            with: {\n              'role-to-assume': roleArn,\n              'role-session-name': 'GitHubAction',\n              'aws-region': roleRegion,\n            },\n          },\n          {\n            name: `Deploy ${stage.name}`,\n            run: deployCommand,\n          },\n        ],\n      };\n\n      // Create projen task for local usage\n      project.addTask(`deploy:${stage.name}`, {\n        description: `Deploy to ${stage.name}`,\n        exec: stacks\n          .map((s) => `${cdkCommand} deploy ${s} --require-approval never`)\n          .join(' && '),\n      });\n    }\n\n    // Add all jobs to the workflow\n    workflow.addJobs(jobs);\n\n    // --- Dispatch Workflow ---\n    if (manualDeployment && useGithubPackagesForAssembly) {\n      new CdkDeployDispatchWorkflow(project, {\n        stages,\n        pkgNamespace,\n        appName,\n        stackPrefix,\n        iamRoleArn,\n        iamRoleRegion,\n        nodeVersion,\n        cdkCommand,\n        installCommand,\n      });\n    }\n  }\n}\n\n/**\n * Internal helper to build deploy dispatch workflow options from pipeline options.\n * Exported for use by CdkDeployDispatchWorkflow.\n */\nexport interface DeployDispatchInternalOptions {\n  readonly stages: DeployStageOptions[];\n  readonly pkgNamespace: string;\n  readonly appName: string;\n  readonly stackPrefix: string;\n  readonly iamRoleArn: string;\n  readonly iamRoleRegion: string;\n  readonly nodeVersion: string;\n  readonly cdkCommand: string;\n  readonly installCommand: string;\n}\n"]}

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './CdkDeployPipeline';
+export * from './CdkDeployDispatchWorkflow';
+export * from './utils';

package/lib/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./CdkDeployPipeline"), exports);
+__exportStar(require("./CdkDeployDispatchWorkflow"), exports);
+__exportStar(require("./utils"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBDQUF3QjtBQUN4QixzREFBb0M7QUFDcEMsOERBQTRDO0FBQzVDLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9DZGtEZXBsb3lQaXBlbGluZSc7XG5leHBvcnQgKiBmcm9tICcuL0Nka0RlcGxveURpc3BhdGNoV29ya2Zsb3cnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlscyc7XG4iXX0=

package/lib/types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * AWS environment target for a deployment stage.
+ */
+export interface AwsEnvironment {
+    /** AWS account ID */
+    readonly account: string;
+    /** AWS region */
+    readonly region: string;
+}
+/**
+ * Configuration for a single deployment stage.
+ */
+export interface DeployStageOptions {
+    /** Stage name (used as suffix in job IDs and stack names, e.g., 'Sandbox', 'Production') */
+    readonly name: string;
+    /** AWS target environment (account + region) */
+    readonly env: AwsEnvironment;
+    /**
+     * GitHub Environment name for protection rules, secrets scoping, and deployment approvals.
+     * @default - uses the stage name
+     */
+    readonly environment?: string;
+    /**
+     * Override the default OIDC role ARN for this stage.
+     * Useful for cross-account deployments where each account has its own role.
+     */
+    readonly iamRoleArn?: string;
+    /**
+     * Override the default AWS region for OIDC credential assumption.
+     * @default - uses the pipeline-level iamRoleRegion or the stage env.region
+     */
+    readonly iamRoleRegion?: string;
+    /**
+     * Stage names that must complete successfully before this stage runs.
+     * Stages with no dependsOn run in parallel after the publish-assets job.
+     *
+     * @example ['Sandbox', 'Dev'] // waits for both before deploying
+     * @default - depends only on publish-assets (runs as soon as assets are ready)
+     */
+    readonly dependsOn?: string[];
+    /**
+     * Specific CDK stack names to deploy in this stage.
+     * @default - ['{stackPrefix}-{stageName}']
+     */
+    readonly stacks?: string[];
+}
+/**
+ * Configuration for the CDK deploy pipeline.
+ */
+export interface CdkDeployPipelineOptions {
+    /** npm scope for versioned cloud assembly packages (e.g., '@defiance-digital') */
+    readonly pkgNamespace: string;
+    /** Stack name prefix. Stage names are appended with a dash (e.g., 'MyApp' -> 'MyApp-Production') */
+    readonly stackPrefix: string;
+    /** Default OIDC role ARN for AWS credential assumption */
+    readonly iamRoleArn: string;
+    /**
+     * Default AWS region for OIDC credential assumption.
+     * @default 'us-east-1'
+     */
+    readonly iamRoleRegion?: string;
+    /**
+     * Node.js version for workflow runners.
+     * @default '24.x'
+     */
+    readonly nodeVersion?: string;
+    /**
+     * CDK CLI command prefix.
+     * @default 'npx cdk'
+     */
+    readonly cdkCommand?: string;
+    /**
+     * Package install command.
+     * @default 'yarn install --check-files --frozen-lockfile'
+     */
+    readonly installCommand?: string;
+    /** Deployment stages in declaration order */
+    readonly stages: DeployStageOptions[];
+    /**
+     * Generate a workflow_dispatch workflow for manual deployments and rollbacks.
+     * @default true
+     */
+    readonly manualDeployment?: boolean;
+    /**
+     * Version and publish cloud assembly to GitHub Packages for rollback support.
+     * @default true
+     */
+    readonly useGithubPackagesForAssembly?: boolean;
+    /**
+     * Branch that triggers deployments on push.
+     * @default 'main'
+     */
+    readonly branchName?: string;
+}

package/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Convert a string to kebab-case for use in file names and job IDs.
+ */
+export declare function toKebabCase(s: string): string;
+/**
+ * Convert a string to a valid GitHub Actions job ID.
+ * Job IDs must start with a letter or underscore and contain only alphanumerics, hyphens, and underscores.
+ */
+export declare function toGithubJobId(s: string): string;
+/**
+ * Validate that there are no circular dependencies in the stage graph.
+ * @throws Error if a cycle is detected
+ */
+export declare function validateNoCycles(stages: {
+    name: string;
+    dependsOn?: string[];
+}[]): void;

package/lib/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toKebabCase = toKebabCase;
+exports.toGithubJobId = toGithubJobId;
+exports.validateNoCycles = validateNoCycles;
+/**
+ * Convert a string to kebab-case for use in file names and job IDs.
+ */
+function toKebabCase(s) {
+    return s
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+/**
+ * Convert a string to a valid GitHub Actions job ID.
+ * Job IDs must start with a letter or underscore and contain only alphanumerics, hyphens, and underscores.
+ */
+function toGithubJobId(s) {
+    let out = s.replace(/[^A-Za-z0-9_-]+/g, '-');
+    out = out.replace(/-+/g, '-');
+    out = out.replace(/^-+|-+$/g, '');
+    out = out.toLowerCase();
+    if (!out || !/^[a-z_]/i.test(out)) {
+        out = `s-${out}`;
+    }
+    return out;
+}
+/**
+ * Validate that there are no circular dependencies in the stage graph.
+ * @throws Error if a cycle is detected
+ */
+function validateNoCycles(stages) {
+    const visited = new Set();
+    const inStack = new Set();
+    const stageMap = new Map(stages.map((s) => [s.name, s]));
+    function visit(name, path) {
+        if (inStack.has(name)) {
+            throw new Error(`Circular dependency detected: ${[...path, name].join(' -> ')}`);
+        }
+        if (visited.has(name)) {
+            return;
+        }
+        inStack.add(name);
+        const stage = stageMap.get(name);
+        if (stage?.dependsOn) {
+            for (const dep of stage.dependsOn) {
+                visit(dep, [...path, name]);
+            }
+        }
+        inStack.delete(name);
+        visited.add(name);
+    }
+    for (const stage of stages) {
+        visit(stage.name, []);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFHQSxrQ0FLQztBQU1ELHNDQVNDO0FBTUQsNENBOEJDO0FBM0REOztHQUVHO0FBQ0gsU0FBZ0IsV0FBVyxDQUFDLENBQVM7SUFDbkMsT0FBTyxDQUFDO1NBQ0wsT0FBTyxDQUFDLGdCQUFnQixFQUFFLEdBQUcsQ0FBQztTQUM5QixPQUFPLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQztTQUN2QixXQUFXLEVBQUUsQ0FBQztBQUNuQixDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsU0FBZ0IsYUFBYSxDQUFDLENBQVM7SUFDckMsSUFBSSxHQUFHLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxHQUFHLENBQUMsQ0FBQztJQUM3QyxHQUFHLEdBQUcsR0FBRyxDQUFDLE9BQU8sQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDOUIsR0FBRyxHQUFHLEdBQUcsQ0FBQyxPQUFPLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ2xDLEdBQUcsR0FBRyxHQUFHLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDeEIsSUFBSSxDQUFDLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUNsQyxHQUFHLEdBQUcsS0FBSyxHQUFHLEVBQUUsQ0FBQztJQUNuQixDQUFDO0lBQ0QsT0FBTyxHQUFHLENBQUM7QUFDYixDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsU0FBZ0IsZ0JBQWdCLENBQzlCLE1BQWdEO0lBRWhELE1BQU0sT0FBTyxHQUFHLElBQUksR0FBRyxFQUFVLENBQUM7SUFDbEMsTUFBTSxPQUFPLEdBQUcsSUFBSSxHQUFHLEVBQVUsQ0FBQztJQUNsQyxNQUFNLFFBQVEsR0FBRyxJQUFJLEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRXpELFNBQVMsS0FBSyxDQUFDLElBQVksRUFBRSxJQUFjO1FBQ3pDLElBQUksT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO1lBQ3RCLE1BQU0sSUFBSSxLQUFLLENBQ2IsaUNBQWlDLENBQUMsR0FBRyxJQUFJLEVBQUUsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQ2hFLENBQUM7UUFDSixDQUFDO1FBQ0QsSUFBSSxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDdEIsT0FBTztRQUNULENBQUM7UUFDRCxPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2xCLE1BQU0sS0FBSyxHQUFHLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDakMsSUFBSSxLQUFLLEVBQUUsU0FBUyxFQUFFLENBQUM7WUFDckIsS0FBSyxNQUFNLEdBQUcsSUFBSSxLQUFLLENBQUMsU0FBUyxFQUFFLENBQUM7Z0JBQ2xDLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQyxHQUFHLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQyxDQUFDO1lBQzlCLENBQUM7UUFDSCxDQUFDO1FBQ0QsT0FBTyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNyQixPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3BCLENBQUM7SUFFRCxLQUFLLE1BQU0sS0FBSyxJQUFJLE1BQU0sRUFBRSxDQUFDO1FBQzNCLEtBQUssQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ3hCLENBQUM7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb252ZXJ0IGEgc3RyaW5nIHRvIGtlYmFiLWNhc2UgZm9yIHVzZSBpbiBmaWxlIG5hbWVzIGFuZCBqb2IgSURzLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdG9LZWJhYkNhc2Uoczogc3RyaW5nKTogc3RyaW5nIHtcbiAgcmV0dXJuIHNcbiAgICAucmVwbGFjZSgvW15hLXpBLVowLTldKy9nLCAnLScpXG4gICAgLnJlcGxhY2UoL14tK3wtKyQvZywgJycpXG4gICAgLnRvTG93ZXJDYXNlKCk7XG59XG5cbi8qKlxuICogQ29udmVydCBhIHN0cmluZyB0byBhIHZhbGlkIEdpdEh1YiBBY3Rpb25zIGpvYiBJRC5cbiAqIEpvYiBJRHMgbXVzdCBzdGFydCB3aXRoIGEgbGV0dGVyIG9yIHVuZGVyc2NvcmUgYW5kIGNvbnRhaW4gb25seSBhbHBoYW51bWVyaWNzLCBoeXBoZW5zLCBhbmQgdW5kZXJzY29yZXMuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB0b0dpdGh1YkpvYklkKHM6IHN0cmluZyk6IHN0cmluZyB7XG4gIGxldCBvdXQgPSBzLnJlcGxhY2UoL1teQS1aYS16MC05Xy1dKy9nLCAnLScpO1xuICBvdXQgPSBvdXQucmVwbGFjZSgvLSsvZywgJy0nKTtcbiAgb3V0ID0gb3V0LnJlcGxhY2UoL14tK3wtKyQvZywgJycpO1xuICBvdXQgPSBvdXQudG9Mb3dlckNhc2UoKTtcbiAgaWYgKCFvdXQgfHwgIS9eW2Etel9dL2kudGVzdChvdXQpKSB7XG4gICAgb3V0ID0gYHMtJHtvdXR9YDtcbiAgfVxuICByZXR1cm4gb3V0O1xufVxuXG4vKipcbiAqIFZhbGlkYXRlIHRoYXQgdGhlcmUgYXJlIG5vIGNpcmN1bGFyIGRlcGVuZGVuY2llcyBpbiB0aGUgc3RhZ2UgZ3JhcGguXG4gKiBAdGhyb3dzIEVycm9yIGlmIGEgY3ljbGUgaXMgZGV0ZWN0ZWRcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHZhbGlkYXRlTm9DeWNsZXMoXG4gIHN0YWdlczogeyBuYW1lOiBzdHJpbmc7IGRlcGVuZHNPbj86IHN0cmluZ1tdIH1bXSxcbik6IHZvaWQge1xuICBjb25zdCB2aXNpdGVkID0gbmV3IFNldDxzdHJpbmc+KCk7XG4gIGNvbnN0IGluU3RhY2sgPSBuZXcgU2V0PHN0cmluZz4oKTtcbiAgY29uc3Qgc3RhZ2VNYXAgPSBuZXcgTWFwKHN0YWdlcy5tYXAoKHMpID0+IFtzLm5hbWUsIHNdKSk7XG5cbiAgZnVuY3Rpb24gdmlzaXQobmFtZTogc3RyaW5nLCBwYXRoOiBzdHJpbmdbXSk6IHZvaWQge1xuICAgIGlmIChpblN0YWNrLmhhcyhuYW1lKSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgICBgQ2lyY3VsYXIgZGVwZW5kZW5jeSBkZXRlY3RlZDogJHtbLi4ucGF0aCwgbmFtZV0uam9pbignIC0+ICcpfWAsXG4gICAgICApO1xuICAgIH1cbiAgICBpZiAodmlzaXRlZC5oYXMobmFtZSkpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG4gICAgaW5TdGFjay5hZGQobmFtZSk7XG4gICAgY29uc3Qgc3RhZ2UgPSBzdGFnZU1hcC5nZXQobmFtZSk7XG4gICAgaWYgKHN0YWdlPy5kZXBlbmRzT24pIHtcbiAgICAgIGZvciAoY29uc3QgZGVwIG9mIHN0YWdlLmRlcGVuZHNPbikge1xuICAgICAgICB2aXNpdChkZXAsIFsuLi5wYXRoLCBuYW1lXSk7XG4gICAgICB9XG4gICAgfVxuICAgIGluU3RhY2suZGVsZXRlKG5hbWUpO1xuICAgIHZpc2l0ZWQuYWRkKG5hbWUpO1xuICB9XG5cbiAgZm9yIChjb25zdCBzdGFnZSBvZiBzdGFnZXMpIHtcbiAgICB2aXNpdChzdGFnZS5uYW1lLCBbXSk7XG4gIH1cbn1cbiJdfQ==