@taimos/projen 0.1.78 → 0.1.80

package/lib/components/amplify-deploy.d.ts

@@ -0,0 +1,187 @@
+import { Component, github } from 'projen';
+import { GitHubProject } from 'projen/lib/github';
+/**
+ * One deploy stage: a git branch, the logical stage it serves, and the AWS
+ * account its Amplify apps live in.
+ *
+ * Both shapes seen in practice are expressible: separate accounts per stage
+ * (each entry has its own `account`), or a single account serving several
+ * branches (every entry repeats the same `account`, and the branch alone
+ * selects which Amplify branch is built).
+ */
+export interface AmplifyDeployStage {
+    /** The git branch the Amplify apps build from, e.g. `main` or `production`. */
+    readonly branch: string;
+    /**
+     * The logical stage this branch serves, e.g. `dev` or `prod`. Used as the
+     * GitHub environment so protection rules apply per stage.
+     */
+    readonly stageName: string;
+    /** The AWS account hosting this stage's Amplify apps. */
+    readonly account: string;
+}
+/**
+ * One Amplify Hosting application whose builds CI drives.
+ *
+ * Mirrors a `MonorepoAmplifyApp` entry in the generated `amplify.yml`; the
+ * `appRoot` should match so a build is triggered by exactly the directory it is
+ * built from.
+ */
+export interface AmplifyDeployApp {
+    /**
+     * Short key identifying the app. Used in the app-id SSM parameter path and,
+     * by default, in the workflow name.
+     *
+     * Must match the key the CDK side registers the app under.
+     */
+    readonly key: string;
+    /**
+     * The package path that is the Amplify app root, e.g. `packages/frontend`.
+     * `<appRoot>/**` becomes a push trigger path.
+     */
+    readonly appRoot: string;
+    /**
+     * Extra path globs that affect this app's build output.
+     *
+     * Set this for workspace packages the app consumes via `workspace:*` and that
+     * the build spec pre-builds — a shared API package, say. Without them a change
+     * to shared types would not rebuild the app and it would ship stale.
+     *
+     * @default []
+     */
+    readonly dependencyPaths?: string[];
+    /**
+     * Human-readable name used in step names and log lines.
+     *
+     * @default - the `key`
+     */
+    readonly label?: string;
+    /**
+     * The generated workflow name, which is also its `.yml` file name.
+     *
+     * @default - `<key>-deploy`
+     */
+    readonly workflowName?: string;
+}
+export interface GitHubAmplifyDeployOptions {
+    /** The Amplify apps to generate deploy workflows for. At least one. */
+    readonly apps: AmplifyDeployApp[];
+    /** The branches that deploy, and the account each one deploys into. At least one. */
+    readonly stages: AmplifyDeployStage[];
+    /**
+     * The GitHub OIDC deployment role every workflow assumes first, typically in
+     * a management account. The per-stage build-trigger role is reached from it
+     * by role chaining, so it must be allowed to `sts:AssumeRole` on that role —
+     * an IAM grant that lives outside the generated code.
+     */
+    readonly deploymentRoleArn: string;
+    /**
+     * Name of the per-account IAM role CI chains into to start builds.
+     *
+     * The same name is expected in every stage account, so the workflow can build
+     * the ARN from the account id alone. The CDK side must create a role with
+     * exactly this name.
+     *
+     * @default - `<project name>-amplify-build-trigger`
+     */
+    readonly buildTriggerRoleName?: string;
+    /**
+     * Prefix of the SSM parameter path holding each app's Amplify app id. The
+     * full path is `<prefix>/<app key>/app-id`.
+     *
+     * Reading the app id at run time means CI never hardcodes an id that changes
+     * whenever an app is replaced.
+     *
+     * @default - `/<project name>/amplify`
+     */
+    readonly parameterPrefix?: string;
+    /**
+     * The AWS region the Amplify apps live in.
+     *
+     * @default 'eu-central-1'
+     */
+    readonly region?: string;
+    /**
+     * Paths that change what *every* Amplify build produces, added to each app's
+     * own paths.
+     *
+     * @default - the Amplify build spec, the lockfile and the workspace file
+     */
+    readonly sharedBuildPaths?: string[];
+    /**
+     * The runner tags used to select the runner.
+     *
+     * @default ['ubuntu-latest']
+     */
+    readonly runnerTags?: string[];
+    /**
+     * Timeout for a deploy job, bounding a hung Amplify build.
+     *
+     * @default 45
+     */
+    readonly timeoutMinutes?: number;
+}
+/**
+ * Adds one path-scoped deploy workflow per Amplify Hosting app.
+ *
+ * Amplify's own auto-build fires on every push to a tracked branch. In a
+ * monorepo that means every frontend rebuilds whenever anything changes — the
+ * marketing site rebuilding for a backend-only commit and vice versa, once per
+ * tracked branch. Amplify bills build minutes, so most of those are waste.
+ *
+ * Amplify's native answer, `AMPLIFY_DIFF_DEPLOY`, diffs exactly one directory
+ * (`AMPLIFY_MONOREPO_APP_ROOT`, overridable via `AMPLIFY_DIFF_DEPLOY_ROOT` —
+ * still a single path). That is enough for a self-contained app but not for one
+ * that also depends on a shared workspace package: a one-directory diff would
+ * ship a stale frontend whenever the shared types changed. GitHub's `paths:`
+ * filters accept multiple globs, so builds move to CI.
+ *
+ * Each generated workflow resolves the pushed branch to its stage and account,
+ * chains OIDC -> deployment role -> build-trigger role, reads the app id from
+ * SSM, starts a `RELEASE` job and polls until it reaches a terminal state — so
+ * a failed Amplify build fails the workflow instead of passing silently.
+ *
+ * This component generates the CI half only. The infrastructure half belongs in
+ * the project's own CDK app, which must:
+ *
+ *   1. set `autoBuild: false` on every branch these workflows build,
+ *   2. publish each app's id to `<parameterPrefix>/<key>/app-id`, and
+ *   3. create a role named `buildTriggerRoleName` in each stage account,
+ *      trusted by `deploymentRoleArn` and granting `amplify:StartJob` +
+ *      `amplify:GetJob` on the tracked branch ARNs only.
+ *
+ * Use `buildTriggerRoleName` and `appIdParameterName()` from the projenrc to
+ * keep those names in step; a mismatch fails the workflow loudly at the
+ * assume-role or parameter-read step rather than skipping a deploy.
+ */
+export declare class GitHubAmplifyDeploy extends Component {
+    /** The generated deploy workflows, one per app. */
+    readonly workflows: github.GithubWorkflow[];
+    /** Name of the IAM role CI chains into, in every stage account. */
+    readonly buildTriggerRoleName: string;
+    /** Prefix of the SSM parameter path holding each app's Amplify app id. */
+    readonly parameterPrefix: string;
+    private readonly region;
+    constructor(scope: GitHubProject, options: GitHubAmplifyDeployOptions);
+    /**
+     * The SSM parameter path holding an app's Amplify app id. The CDK side must
+     * publish the id under exactly this name.
+     */
+    appIdParameterName(key: string): string;
+    /**
+     * The job-level `environment:` expression mapping branch to stage, so each
+     * stage keeps whatever GitHub environment protection rules it has. The first
+     * stage is the fallback; every later stage gets an explicit branch test.
+     */
+    private environmentExpression;
+    /**
+     * Bash mapping the pushed branch to its stage and build-trigger role ARN, so
+     * account ids live only in the projenrc. A branch that is not a deploy branch
+     * is an error rather than a silent no-op.
+     */
+    private resolveStageScript;
+    /** Reads the app id from SSM and starts a RELEASE build. */
+    private startBuildScript;
+    /** Polls the job until it reaches a terminal state, failing on a bad one. */
+    private waitForBuildScript;
+}

package/lib/components/amplify-deploy.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubAmplifyDeploy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+/** Paths that invalidate every app's build output. */
+const DEFAULT_SHARED_BUILD_PATHS = [
+    'amplify.yml',
+    'pnpm-lock.yaml',
+    'pnpm-workspace.yaml',
+];
+/**
+ * Adds one path-scoped deploy workflow per Amplify Hosting app.
+ *
+ * Amplify's own auto-build fires on every push to a tracked branch. In a
+ * monorepo that means every frontend rebuilds whenever anything changes — the
+ * marketing site rebuilding for a backend-only commit and vice versa, once per
+ * tracked branch. Amplify bills build minutes, so most of those are waste.
+ *
+ * Amplify's native answer, `AMPLIFY_DIFF_DEPLOY`, diffs exactly one directory
+ * (`AMPLIFY_MONOREPO_APP_ROOT`, overridable via `AMPLIFY_DIFF_DEPLOY_ROOT` —
+ * still a single path). That is enough for a self-contained app but not for one
+ * that also depends on a shared workspace package: a one-directory diff would
+ * ship a stale frontend whenever the shared types changed. GitHub's `paths:`
+ * filters accept multiple globs, so builds move to CI.
+ *
+ * Each generated workflow resolves the pushed branch to its stage and account,
+ * chains OIDC -> deployment role -> build-trigger role, reads the app id from
+ * SSM, starts a `RELEASE` job and polls until it reaches a terminal state — so
+ * a failed Amplify build fails the workflow instead of passing silently.
+ *
+ * This component generates the CI half only. The infrastructure half belongs in
+ * the project's own CDK app, which must:
+ *
+ *   1. set `autoBuild: false` on every branch these workflows build,
+ *   2. publish each app's id to `<parameterPrefix>/<key>/app-id`, and
+ *   3. create a role named `buildTriggerRoleName` in each stage account,
+ *      trusted by `deploymentRoleArn` and granting `amplify:StartJob` +
+ *      `amplify:GetJob` on the tracked branch ARNs only.
+ *
+ * Use `buildTriggerRoleName` and `appIdParameterName()` from the projenrc to
+ * keep those names in step; a mismatch fails the workflow loudly at the
+ * assume-role or parameter-read step rather than skipping a deploy.
+ */
+class GitHubAmplifyDeploy extends projen_1.Component {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@taimos/projen.GitHubAmplifyDeploy", version: "0.1.80" };
+    /** The generated deploy workflows, one per app. */
+    workflows = [];
+    /** Name of the IAM role CI chains into, in every stage account. */
+    buildTriggerRoleName;
+    /** Prefix of the SSM parameter path holding each app's Amplify app id. */
+    parameterPrefix;
+    region;
+    constructor(scope, options) {
+        super(scope);
+        if (!scope.github) {
+            throw new Error('GitHubAmplifyDeploy requires a project with GitHub enabled');
+        }
+        if (options.apps.length === 0) {
+            throw new Error('GitHubAmplifyDeploy requires at least one app');
+        }
+        if (options.stages.length === 0) {
+            throw new Error('GitHubAmplifyDeploy requires at least one stage');
+        }
+        const keys = options.apps.map((app) => app.key);
+        const duplicateKey = keys.find((key, index) => keys.indexOf(key) !== index);
+        if (duplicateKey) {
+            throw new Error(`GitHubAmplifyDeploy app keys must be unique, got '${duplicateKey}' twice`);
+        }
+        const branches = options.stages.map((stage) => stage.branch);
+        const duplicateBranch = branches.find((branch, index) => branches.indexOf(branch) !== index);
+        if (duplicateBranch) {
+            throw new Error(`GitHubAmplifyDeploy stage branches must be unique, got '${duplicateBranch}' twice`);
+        }
+        this.buildTriggerRoleName = options.buildTriggerRoleName ?? `${scope.name}-amplify-build-trigger`;
+        this.parameterPrefix = options.parameterPrefix ?? `/${scope.name}/amplify`;
+        this.region = options.region ?? 'eu-central-1';
+        const sharedBuildPaths = options.sharedBuildPaths ?? DEFAULT_SHARED_BUILD_PATHS;
+        const runnerTags = options.runnerTags ?? ['ubuntu-latest'];
+        const timeoutMinutes = options.timeoutMinutes ?? 45;
+        for (const app of options.apps) {
+            const label = app.label ?? app.key;
+            const workflowName = app.workflowName ?? `${app.key}-deploy`;
+            const workflow = new projen_1.github.GithubWorkflow(scope.github, workflowName);
+            workflow.on({
+                push: {
+                    branches: options.stages.map((stage) => stage.branch),
+                    paths: [
+                        `${app.appRoot}/**`,
+                        ...(app.dependencyPaths ?? []),
+                        ...sharedBuildPaths,
+                        // Changing the workflow itself should prove it still works.
+                        `.github/workflows/${workflowName}.yml`,
+                    ],
+                },
+                // Manual redeploy, e.g. after a build-only failure.
+                workflowDispatch: {},
+            });
+            workflow.addJob('deploy', {
+                name: `Build and deploy the ${label} on Amplify`,
+                runsOn: runnerTags,
+                permissions: {
+                    contents: projen_1.github.workflows.JobPermission.READ,
+                    idToken: projen_1.github.workflows.JobPermission.WRITE,
+                },
+                environment: this.environmentExpression(options.stages),
+                concurrency: {
+                    'group': `${workflowName}-\${{ github.ref_name }}`,
+                    // Cancelling the workflow would not cancel the Amplify job it started,
+                    // so let runs queue instead of orphaning builds.
+                    'cancel-in-progress': false,
+                },
+                timeoutMinutes,
+                steps: [
+                    {
+                        name: 'Resolve stage',
+                        id: 'stage',
+                        run: this.resolveStageScript(options.stages),
+                    },
+                    {
+                        name: 'AWS credentials — deployment role',
+                        id: 'aws_credentials_deployment_role',
+                        uses: 'aws-actions/configure-aws-credentials@v5',
+                        with: {
+                            'role-to-assume': options.deploymentRoleArn,
+                            'role-session-name': 'GitHubAction',
+                            'aws-region': this.region,
+                        },
+                    },
+                    {
+                        name: 'AWS credentials — Amplify build trigger',
+                        id: 'aws_credentials_amplify_build_trigger',
+                        uses: 'aws-actions/configure-aws-credentials@v5',
+                        with: {
+                            'role-to-assume': '${{ steps.stage.outputs.role_arn }}',
+                            'role-session-name': 'AmplifyBuildTrigger',
+                            'aws-region': this.region,
+                            // Chain from the deployment role rather than re-using the OIDC
+                            // token, so no identity provider is needed in the stage account.
+                            'role-chaining': true,
+                            // The action tags sessions by default, which turns the chained
+                            // call into AssumeRole + TagSession. The trust policy grants
+                            // AssumeRole only, so tagging fails the step; the session is
+                            // already tagged by the first assume anyway.
+                            'role-skip-session-tagging': true,
+                        },
+                    },
+                    {
+                        name: `Start ${label} build`,
+                        id: 'start',
+                        run: this.startBuildScript(app, label),
+                    },
+                    {
+                        name: 'Wait for build to finish',
+                        id: 'wait_for_build_to_finish',
+                        run: this.waitForBuildScript(label),
+                    },
+                ],
+            });
+            this.workflows.push(workflow);
+        }
+    }
+    /**
+     * The SSM parameter path holding an app's Amplify app id. The CDK side must
+     * publish the id under exactly this name.
+     */
+    appIdParameterName(key) {
+        return `${this.parameterPrefix}/${key}/app-id`;
+    }
+    /**
+     * The job-level `environment:` expression mapping branch to stage, so each
+     * stage keeps whatever GitHub environment protection rules it has. The first
+     * stage is the fallback; every later stage gets an explicit branch test.
+     */
+    environmentExpression(stages) {
+        const [fallback, ...rest] = stages;
+        const tests = rest.map((s) => `github.ref_name == '${s.branch}' && '${s.stageName}' || `).join('');
+        return `\${{ ${tests}'${fallback.stageName}' }}`;
+    }
+    /**
+     * Bash mapping the pushed branch to its stage and build-trigger role ARN, so
+     * account ids live only in the projenrc. A branch that is not a deploy branch
+     * is an error rather than a silent no-op.
+     */
+    resolveStageScript(stages) {
+        const cases = stages.map((s) => `  ${s.branch}) stage='${s.stageName}'; account='${s.account}' ;;`);
+        return [
+            'set -euo pipefail',
+            'case "$GITHUB_REF_NAME" in',
+            ...cases,
+            '  *)',
+            '    echo "::error::$GITHUB_REF_NAME is not a deploy branch"',
+            '    exit 1',
+            '    ;;',
+            'esac',
+            `role="arn:aws:iam::$account:role/${this.buildTriggerRoleName}"`,
+            'echo "stage=$stage" >> "$GITHUB_OUTPUT"',
+            'echo "role_arn=$role" >> "$GITHUB_OUTPUT"',
+            'echo "Deploying $GITHUB_REF_NAME to stage $stage ($account)" >> "$GITHUB_STEP_SUMMARY"',
+        ].join('\n');
+    }
+    /** Reads the app id from SSM and starts a RELEASE build. */
+    startBuildScript(app, label) {
+        return [
+            'set -euo pipefail',
+            `app_id="$(aws ssm get-parameter --name '${this.appIdParameterName(app.key)}' --query Parameter.Value --output text)"`,
+            '# RELEASE builds the current tip of the branch. That is normally $GITHUB_SHA;',
+            '# if two pushes race, the tip wins and the earlier run is redundant rather',
+            '# than wrong. The job concurrency group keeps that rare.',
+            'job_id="$(aws amplify start-job \\',
+            '  --app-id "$app_id" \\',
+            '  --branch-name "$GITHUB_REF_NAME" \\',
+            '  --job-type RELEASE \\',
+            '  --job-reason "GitHub Actions $GITHUB_WORKFLOW run $GITHUB_RUN_ID for $GITHUB_SHA" \\',
+            '  --query jobSummary.jobId --output text)"',
+            'echo "app_id=$app_id" >> "$GITHUB_OUTPUT"',
+            'echo "job_id=$job_id" >> "$GITHUB_OUTPUT"',
+            `echo "Started ${label} Amplify job \$job_id on app \$app_id" >> "\$GITHUB_STEP_SUMMARY"`,
+        ].join('\n');
+    }
+    /** Polls the job until it reaches a terminal state, failing on a bad one. */
+    waitForBuildScript(label) {
+        return [
+            'set -euo pipefail',
+            'while true; do',
+            '  status="$(aws amplify get-job \\',
+            '    --app-id "${{ steps.start.outputs.app_id }}" \\',
+            '    --branch-name "$GITHUB_REF_NAME" \\',
+            '    --job-id "${{ steps.start.outputs.job_id }}" \\',
+            '    --query job.summary.status --output text)"',
+            '  case "$status" in',
+            '    SUCCEED)',
+            `      echo "${label} build succeeded" >> "\$GITHUB_STEP_SUMMARY"`,
+            '      exit 0',
+            '      ;;',
+            '    FAILED|CANCELLED)',
+            `      echo "::error::${label} Amplify job \${{ steps.start.outputs.job_id }} ended as \$status"`,
+            '      exit 1',
+            '      ;;',
+            '  esac',
+            '  echo "status: $status"',
+            '  sleep 15',
+            'done',
+        ].join('\n');
+    }
+}
+exports.GitHubAmplifyDeploy = GitHubAmplifyDeploy;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"amplify-deploy.js","sourceRoot":"","sources":["../../src/components/amplify-deploy.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, github } from 'projen';\nimport { GitHubProject } from 'projen/lib/github';\n\n/**\n * One deploy stage: a git branch, the logical stage it serves, and the AWS\n * account its Amplify apps live in.\n *\n * Both shapes seen in practice are expressible: separate accounts per stage\n * (each entry has its own `account`), or a single account serving several\n * branches (every entry repeats the same `account`, and the branch alone\n * selects which Amplify branch is built).\n */\nexport interface AmplifyDeployStage {\n  /** The git branch the Amplify apps build from, e.g. `main` or `production`. */\n  readonly branch: string;\n\n  /**\n   * The logical stage this branch serves, e.g. `dev` or `prod`. Used as the\n   * GitHub environment so protection rules apply per stage.\n   */\n  readonly stageName: string;\n\n  /** The AWS account hosting this stage's Amplify apps. */\n  readonly account: string;\n}\n\n/**\n * One Amplify Hosting application whose builds CI drives.\n *\n * Mirrors a `MonorepoAmplifyApp` entry in the generated `amplify.yml`; the\n * `appRoot` should match so a build is triggered by exactly the directory it is\n * built from.\n */\nexport interface AmplifyDeployApp {\n  /**\n   * Short key identifying the app. Used in the app-id SSM parameter path and,\n   * by default, in the workflow name.\n   *\n   * Must match the key the CDK side registers the app under.\n   */\n  readonly key: string;\n\n  /**\n   * The package path that is the Amplify app root, e.g. `packages/frontend`.\n   * `<appRoot>/**` becomes a push trigger path.\n   */\n  readonly appRoot: string;\n\n  /**\n   * Extra path globs that affect this app's build output.\n   *\n   * Set this for workspace packages the app consumes via `workspace:*` and that\n   * the build spec pre-builds — a shared API package, say. Without them a change\n   * to shared types would not rebuild the app and it would ship stale.\n   *\n   * @default []\n   */\n  readonly dependencyPaths?: string[];\n\n  /**\n   * Human-readable name used in step names and log lines.\n   *\n   * @default - the `key`\n   */\n  readonly label?: string;\n\n  /**\n   * The generated workflow name, which is also its `.yml` file name.\n   *\n   * @default - `<key>-deploy`\n   */\n  readonly workflowName?: string;\n}\n\nexport interface GitHubAmplifyDeployOptions {\n  /** The Amplify apps to generate deploy workflows for. At least one. */\n  readonly apps: AmplifyDeployApp[];\n\n  /** The branches that deploy, and the account each one deploys into. At least one. */\n  readonly stages: AmplifyDeployStage[];\n\n  /**\n   * The GitHub OIDC deployment role every workflow assumes first, typically in\n   * a management account. The per-stage build-trigger role is reached from it\n   * by role chaining, so it must be allowed to `sts:AssumeRole` on that role —\n   * an IAM grant that lives outside the generated code.\n   */\n  readonly deploymentRoleArn: string;\n\n  /**\n   * Name of the per-account IAM role CI chains into to start builds.\n   *\n   * The same name is expected in every stage account, so the workflow can build\n   * the ARN from the account id alone. The CDK side must create a role with\n   * exactly this name.\n   *\n   * @default - `<project name>-amplify-build-trigger`\n   */\n  readonly buildTriggerRoleName?: string;\n\n  /**\n   * Prefix of the SSM parameter path holding each app's Amplify app id. The\n   * full path is `<prefix>/<app key>/app-id`.\n   *\n   * Reading the app id at run time means CI never hardcodes an id that changes\n   * whenever an app is replaced.\n   *\n   * @default - `/<project name>/amplify`\n   */\n  readonly parameterPrefix?: string;\n\n  /**\n   * The AWS region the Amplify apps live in.\n   *\n   * @default 'eu-central-1'\n   */\n  readonly region?: string;\n\n  /**\n   * Paths that change what *every* Amplify build produces, added to each app's\n   * own paths.\n   *\n   * @default - the Amplify build spec, the lockfile and the workspace file\n   */\n  readonly sharedBuildPaths?: string[];\n\n  /**\n   * The runner tags used to select the runner.\n   *\n   * @default ['ubuntu-latest']\n   */\n  readonly runnerTags?: string[];\n\n  /**\n   * Timeout for a deploy job, bounding a hung Amplify build.\n   *\n   * @default 45\n   */\n  readonly timeoutMinutes?: number;\n}\n\n/** Paths that invalidate every app's build output. */\nconst DEFAULT_SHARED_BUILD_PATHS = [\n  'amplify.yml',\n  'pnpm-lock.yaml',\n  'pnpm-workspace.yaml',\n];\n\n/**\n * Adds one path-scoped deploy workflow per Amplify Hosting app.\n *\n * Amplify's own auto-build fires on every push to a tracked branch. In a\n * monorepo that means every frontend rebuilds whenever anything changes — the\n * marketing site rebuilding for a backend-only commit and vice versa, once per\n * tracked branch. Amplify bills build minutes, so most of those are waste.\n *\n * Amplify's native answer, `AMPLIFY_DIFF_DEPLOY`, diffs exactly one directory\n * (`AMPLIFY_MONOREPO_APP_ROOT`, overridable via `AMPLIFY_DIFF_DEPLOY_ROOT` —\n * still a single path). That is enough for a self-contained app but not for one\n * that also depends on a shared workspace package: a one-directory diff would\n * ship a stale frontend whenever the shared types changed. GitHub's `paths:`\n * filters accept multiple globs, so builds move to CI.\n *\n * Each generated workflow resolves the pushed branch to its stage and account,\n * chains OIDC -> deployment role -> build-trigger role, reads the app id from\n * SSM, starts a `RELEASE` job and polls until it reaches a terminal state — so\n * a failed Amplify build fails the workflow instead of passing silently.\n *\n * This component generates the CI half only. The infrastructure half belongs in\n * the project's own CDK app, which must:\n *\n *   1. set `autoBuild: false` on every branch these workflows build,\n *   2. publish each app's id to `<parameterPrefix>/<key>/app-id`, and\n *   3. create a role named `buildTriggerRoleName` in each stage account,\n *      trusted by `deploymentRoleArn` and granting `amplify:StartJob` +\n *      `amplify:GetJob` on the tracked branch ARNs only.\n *\n * Use `buildTriggerRoleName` and `appIdParameterName()` from the projenrc to\n * keep those names in step; a mismatch fails the workflow loudly at the\n * assume-role or parameter-read step rather than skipping a deploy.\n */\nexport class GitHubAmplifyDeploy extends Component {\n  /** The generated deploy workflows, one per app. */\n  public readonly workflows: github.GithubWorkflow[] = [];\n\n  /** Name of the IAM role CI chains into, in every stage account. */\n  public readonly buildTriggerRoleName: string;\n\n  /** Prefix of the SSM parameter path holding each app's Amplify app id. */\n  public readonly parameterPrefix: string;\n\n  private readonly region: string;\n\n  constructor(scope: GitHubProject, options: GitHubAmplifyDeployOptions) {\n    super(scope);\n\n    if (!scope.github) {\n      throw new Error('GitHubAmplifyDeploy requires a project with GitHub enabled');\n    }\n    if (options.apps.length === 0) {\n      throw new Error('GitHubAmplifyDeploy requires at least one app');\n    }\n    if (options.stages.length === 0) {\n      throw new Error('GitHubAmplifyDeploy requires at least one stage');\n    }\n\n    const keys = options.apps.map((app) => app.key);\n    const duplicateKey = keys.find((key, index) => keys.indexOf(key) !== index);\n    if (duplicateKey) {\n      throw new Error(`GitHubAmplifyDeploy app keys must be unique, got '${duplicateKey}' twice`);\n    }\n\n    const branches = options.stages.map((stage) => stage.branch);\n    const duplicateBranch = branches.find((branch, index) => branches.indexOf(branch) !== index);\n    if (duplicateBranch) {\n      throw new Error(`GitHubAmplifyDeploy stage branches must be unique, got '${duplicateBranch}' twice`);\n    }\n\n    this.buildTriggerRoleName = options.buildTriggerRoleName ?? `${scope.name}-amplify-build-trigger`;\n    this.parameterPrefix = options.parameterPrefix ?? `/${scope.name}/amplify`;\n    this.region = options.region ?? 'eu-central-1';\n\n    const sharedBuildPaths = options.sharedBuildPaths ?? DEFAULT_SHARED_BUILD_PATHS;\n    const runnerTags = options.runnerTags ?? ['ubuntu-latest'];\n    const timeoutMinutes = options.timeoutMinutes ?? 45;\n\n    for (const app of options.apps) {\n      const label = app.label ?? app.key;\n      const workflowName = app.workflowName ?? `${app.key}-deploy`;\n\n      const workflow = new github.GithubWorkflow(scope.github, workflowName);\n      workflow.on({\n        push: {\n          branches: options.stages.map((stage) => stage.branch),\n          paths: [\n            `${app.appRoot}/**`,\n            ...(app.dependencyPaths ?? []),\n            ...sharedBuildPaths,\n            // Changing the workflow itself should prove it still works.\n            `.github/workflows/${workflowName}.yml`,\n          ],\n        },\n        // Manual redeploy, e.g. after a build-only failure.\n        workflowDispatch: {},\n      });\n\n      workflow.addJob('deploy', {\n        name: `Build and deploy the ${label} on Amplify`,\n        runsOn: runnerTags,\n        permissions: {\n          contents: github.workflows.JobPermission.READ,\n          idToken: github.workflows.JobPermission.WRITE,\n        },\n        environment: this.environmentExpression(options.stages),\n        concurrency: {\n          'group': `${workflowName}-\\${{ github.ref_name }}`,\n          // Cancelling the workflow would not cancel the Amplify job it started,\n          // so let runs queue instead of orphaning builds.\n          'cancel-in-progress': false,\n        },\n        timeoutMinutes,\n        steps: [\n          {\n            name: 'Resolve stage',\n            id: 'stage',\n            run: this.resolveStageScript(options.stages),\n          },\n          {\n            name: 'AWS credentials — deployment role',\n            id: 'aws_credentials_deployment_role',\n            uses: 'aws-actions/configure-aws-credentials@v5',\n            with: {\n              'role-to-assume': options.deploymentRoleArn,\n              'role-session-name': 'GitHubAction',\n              'aws-region': this.region,\n            },\n          },\n          {\n            name: 'AWS credentials — Amplify build trigger',\n            id: 'aws_credentials_amplify_build_trigger',\n            uses: 'aws-actions/configure-aws-credentials@v5',\n            with: {\n              'role-to-assume': '${{ steps.stage.outputs.role_arn }}',\n              'role-session-name': 'AmplifyBuildTrigger',\n              'aws-region': this.region,\n              // Chain from the deployment role rather than re-using the OIDC\n              // token, so no identity provider is needed in the stage account.\n              'role-chaining': true,\n              // The action tags sessions by default, which turns the chained\n              // call into AssumeRole + TagSession. The trust policy grants\n              // AssumeRole only, so tagging fails the step; the session is\n              // already tagged by the first assume anyway.\n              'role-skip-session-tagging': true,\n            },\n          },\n          {\n            name: `Start ${label} build`,\n            id: 'start',\n            run: this.startBuildScript(app, label),\n          },\n          {\n            name: 'Wait for build to finish',\n            id: 'wait_for_build_to_finish',\n            run: this.waitForBuildScript(label),\n          },\n        ],\n      });\n\n      this.workflows.push(workflow);\n    }\n  }\n\n  /**\n   * The SSM parameter path holding an app's Amplify app id. The CDK side must\n   * publish the id under exactly this name.\n   */\n  public appIdParameterName(key: string): string {\n    return `${this.parameterPrefix}/${key}/app-id`;\n  }\n\n  /**\n   * The job-level `environment:` expression mapping branch to stage, so each\n   * stage keeps whatever GitHub environment protection rules it has. The first\n   * stage is the fallback; every later stage gets an explicit branch test.\n   */\n  private environmentExpression(stages: AmplifyDeployStage[]): string {\n    const [fallback, ...rest] = stages;\n    const tests = rest.map((s) => `github.ref_name == '${s.branch}' && '${s.stageName}' || `).join('');\n    return `\\${{ ${tests}'${fallback.stageName}' }}`;\n  }\n\n  /**\n   * Bash mapping the pushed branch to its stage and build-trigger role ARN, so\n   * account ids live only in the projenrc. A branch that is not a deploy branch\n   * is an error rather than a silent no-op.\n   */\n  private resolveStageScript(stages: AmplifyDeployStage[]): string {\n    const cases = stages.map((s) => `  ${s.branch}) stage='${s.stageName}'; account='${s.account}' ;;`);\n    return [\n      'set -euo pipefail',\n      'case \"$GITHUB_REF_NAME\" in',\n      ...cases,\n      '  *)',\n      '    echo \"::error::$GITHUB_REF_NAME is not a deploy branch\"',\n      '    exit 1',\n      '    ;;',\n      'esac',\n      `role=\"arn:aws:iam::$account:role/${this.buildTriggerRoleName}\"`,\n      'echo \"stage=$stage\" >> \"$GITHUB_OUTPUT\"',\n      'echo \"role_arn=$role\" >> \"$GITHUB_OUTPUT\"',\n      'echo \"Deploying $GITHUB_REF_NAME to stage $stage ($account)\" >> \"$GITHUB_STEP_SUMMARY\"',\n    ].join('\\n');\n  }\n\n  /** Reads the app id from SSM and starts a RELEASE build. */\n  private startBuildScript(app: AmplifyDeployApp, label: string): string {\n    return [\n      'set -euo pipefail',\n      `app_id=\"$(aws ssm get-parameter --name '${this.appIdParameterName(app.key)}' --query Parameter.Value --output text)\"`,\n      '# RELEASE builds the current tip of the branch. That is normally $GITHUB_SHA;',\n      '# if two pushes race, the tip wins and the earlier run is redundant rather',\n      '# than wrong. The job concurrency group keeps that rare.',\n      'job_id=\"$(aws amplify start-job \\\\',\n      '  --app-id \"$app_id\" \\\\',\n      '  --branch-name \"$GITHUB_REF_NAME\" \\\\',\n      '  --job-type RELEASE \\\\',\n      '  --job-reason \"GitHub Actions $GITHUB_WORKFLOW run $GITHUB_RUN_ID for $GITHUB_SHA\" \\\\',\n      '  --query jobSummary.jobId --output text)\"',\n      'echo \"app_id=$app_id\" >> \"$GITHUB_OUTPUT\"',\n      'echo \"job_id=$job_id\" >> \"$GITHUB_OUTPUT\"',\n      `echo \"Started ${label} Amplify job \\$job_id on app \\$app_id\" >> \"\\$GITHUB_STEP_SUMMARY\"`,\n    ].join('\\n');\n  }\n\n  /** Polls the job until it reaches a terminal state, failing on a bad one. */\n  private waitForBuildScript(label: string): string {\n    return [\n      'set -euo pipefail',\n      'while true; do',\n      '  status=\"$(aws amplify get-job \\\\',\n      '    --app-id \"${{ steps.start.outputs.app_id }}\" \\\\',\n      '    --branch-name \"$GITHUB_REF_NAME\" \\\\',\n      '    --job-id \"${{ steps.start.outputs.job_id }}\" \\\\',\n      '    --query job.summary.status --output text)\"',\n      '  case \"$status\" in',\n      '    SUCCEED)',\n      `      echo \"${label} build succeeded\" >> \"\\$GITHUB_STEP_SUMMARY\"`,\n      '      exit 0',\n      '      ;;',\n      '    FAILED|CANCELLED)',\n      `      echo \"::error::${label} Amplify job \\${{ steps.start.outputs.job_id }} ended as \\$status\"`,\n      '      exit 1',\n      '      ;;',\n      '  esac',\n      '  echo \"status: $status\"',\n      '  sleep 15',\n      'done',\n    ].join('\\n');\n  }\n}\n"]}

package/lib/components/index.d.ts

@@ -1 +1,2 @@
+export * from './amplify-deploy';
 export * from './production-release';

package/lib/components/index.js

@@ -14,5 +14,6 @@ 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("./amplify-deploy"), exports);
 __exportStar(require("./production-release"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tcG9uZW50cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsdURBQXFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wcm9kdWN0aW9uLXJlbGVhc2UnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29tcG9uZW50cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsbURBQWlDO0FBQ2pDLHVEQUFxQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYW1wbGlmeS1kZXBsb3knO1xuZXhwb3J0ICogZnJvbSAnLi9wcm9kdWN0aW9uLXJlbGVhc2UnO1xuIl19

package/lib/components/production-release.js

@@ -15,7 +15,7 @@ const projen_1 = require("projen");
  * dispatch time.
  */
 class GitHubProductionRelease extends projen_1.Component {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@taimos/projen.GitHubProductionRelease", version: "0.1.78" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@taimos/projen.GitHubProductionRelease", version: "0.1.80" };
     /**
      * Resolves the branch that is promoted — the project's default release branch.
      *

package/lib/projects/cdk-app.js

@@ -9,7 +9,7 @@ const projen_1 = require("projen");
  * @pjid taimos-cdk-app
  */
 class TaimosCdkApp extends projen_1.awscdk.AwsCdkTypeScriptApp {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@taimos/projen.TaimosCdkApp", version: "0.1.78" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@taimos/projen.TaimosCdkApp", version: "0.1.80" };
     constructor(options) {
         super({
             authorEmail: 'info@taimos.de',

package/lib/projects/cdk-construct.js

@@ -9,7 +9,7 @@ const projen_1 = require("projen");
  * @pjid taimos-awscdk-construct
  */
 class TaimosCdkConstructLibrary extends projen_1.awscdk.AwsCdkConstructLibrary {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@taimos/projen.TaimosCdkConstructLibrary", version: "0.1.78" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@taimos/projen.TaimosCdkConstructLibrary", version: "0.1.80" };
     constructor(options) {
         super({
             authorOrganization: true,

package/lib/projects/monorepo.d.ts

@@ -1,6 +1,6 @@
 import { github, typescript, YamlFile } from 'projen';
 import { GitHubAssignApprover } from 'projen-pipelines';
-import { GitHubProductionRelease, GitHubProductionReleaseOptions } from '../components';
+import { GitHubAmplifyDeploy, GitHubAmplifyDeployOptions, GitHubProductionRelease, GitHubProductionReleaseOptions } from '../components';
 /**
  * The frontend framework an Amplify Hosting application is built with.
  *
@@ -211,6 +211,18 @@ export interface MonorepoProjectOptions extends typescript.TypeScriptProjectOpti
      * @default - promote `main` to a `production` branch
      */
     readonly productionReleaseOptions?: GitHubProductionReleaseOptions;
+    /**
+     * Drive Amplify Hosting builds from GitHub Actions instead of Amplify's own
+     * auto-build, so an app only rebuilds when the packages it is built from
+     * actually changed (see `GitHubAmplifyDeploy`).
+     *
+     * Setting this generates one deploy workflow per listed app. The project's
+     * CDK app must disable `autoBuild` on the tracked branches and provide the
+     * app-id parameters and build-trigger role the workflows expect.
+     *
+     * @default - Amplify's own auto-build is left in place
+     */
+    readonly amplifyDeployOptions?: GitHubAmplifyDeployOptions;
 }
 /**
  * Private PNPM-workspace monorepo root, following Taimos ADR-0002.
@@ -236,6 +248,8 @@ export declare class MonorepoProject extends typescript.TypeScriptProject {
     readonly assignApprover?: GitHubAssignApprover;
     /** The production release workflow, if enabled. */
     readonly productionRelease?: GitHubProductionRelease;
+    /** The Amplify deploy workflows, when `amplifyDeployOptions` is set. */
+    readonly amplifyDeploy?: GitHubAmplifyDeploy;
     /** The default release branch (promoted by the production release workflow). */
     readonly defaultReleaseBranch: string;
     constructor(options: MonorepoProjectOptions);