@taimos/projen 0.1.63 → 0.1.65

package/lib/projects/cdk-app.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaimosCdkApp = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
@@ -10,6 +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.65" };
     constructor(options) {
         super({
             authorEmail: 'info@taimos.de',
@@ -44,6 +44,4 @@ class TaimosCdkApp extends projen_1.awscdk.AwsCdkTypeScriptApp {
     }
 }
 exports.TaimosCdkApp = TaimosCdkApp;
-_a = JSII_RTTI_SYMBOL_1;
-TaimosCdkApp[_a] = { fqn: "@taimos/projen.TaimosCdkApp", version: "0.1.63" };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/projects/cdk-construct.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaimosCdkConstructLibrary = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
@@ -10,6 +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.65" };
     constructor(options) {
         super({
             authorOrganization: true,
@@ -63,6 +63,4 @@ class TaimosCdkConstructLibrary extends projen_1.awscdk.AwsCdkConstructLibrary {
     }
 }
 exports.TaimosCdkConstructLibrary = TaimosCdkConstructLibrary;
-_a = JSII_RTTI_SYMBOL_1;
-TaimosCdkConstructLibrary[_a] = { fqn: "@taimos/projen.TaimosCdkConstructLibrary", version: "0.1.63" };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/projects/index.d.ts

@@ -4,3 +4,4 @@ export * from './private-ts-lib';
 export * from './private-cdk-app';
 export * from './cdk-construct';
 export * from './prod-cdk-app';
+export * from './monorepo';

package/lib/projects/index.js

@@ -20,4 +20,5 @@ __exportStar(require("./private-ts-lib"), exports);
 __exportStar(require("./private-cdk-app"), exports);
 __exportStar(require("./cdk-construct"), exports);
 __exportStar(require("./prod-cdk-app"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvamVjdHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQjtBQUMxQiwyQ0FBeUI7QUFDekIsbURBQWlDO0FBQ2pDLG9EQUFrQztBQUNsQyxrREFBZ0M7QUFDaEMsaURBQStCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jZGstYXBwJztcbmV4cG9ydCAqIGZyb20gJy4vdHMtbGliJztcbmV4cG9ydCAqIGZyb20gJy4vcHJpdmF0ZS10cy1saWInO1xuZXhwb3J0ICogZnJvbSAnLi9wcml2YXRlLWNkay1hcHAnO1xuZXhwb3J0ICogZnJvbSAnLi9jZGstY29uc3RydWN0JztcbmV4cG9ydCAqIGZyb20gJy4vcHJvZC1jZGstYXBwJztcbiJdfQ==
+__exportStar(require("./monorepo"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvamVjdHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDRDQUEwQjtBQUMxQiwyQ0FBeUI7QUFDekIsbURBQWlDO0FBQ2pDLG9EQUFrQztBQUNsQyxrREFBZ0M7QUFDaEMsaURBQStCO0FBQy9CLDZDQUEyQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2RrLWFwcCc7XG5leHBvcnQgKiBmcm9tICcuL3RzLWxpYic7XG5leHBvcnQgKiBmcm9tICcuL3ByaXZhdGUtdHMtbGliJztcbmV4cG9ydCAqIGZyb20gJy4vcHJpdmF0ZS1jZGstYXBwJztcbmV4cG9ydCAqIGZyb20gJy4vY2RrLWNvbnN0cnVjdCc7XG5leHBvcnQgKiBmcm9tICcuL3Byb2QtY2RrLWFwcCc7XG5leHBvcnQgKiBmcm9tICcuL21vbm9yZXBvJztcbiJdfQ==

package/lib/projects/monorepo.d.ts

@@ -0,0 +1,204 @@
+import { github, typescript, YamlFile } from 'projen';
+import { GitHubAssignApprover } from 'projen-pipelines';
+/**
+ * The frontend framework an Amplify Hosting application is built with.
+ *
+ * Selects sensible defaults for the build command, artifact directory and
+ * cache paths in the generated `amplify.yml`.
+ */
+export declare enum MonorepoAmplifyFramework {
+    /** A Next.js app — artifacts in `<appRoot>/.next`, built via `run build`. */
+    NEXTJS = "nextjs",
+    /** An Angular app — artifacts in `<appRoot>/dist/<filter>/browser`, built via `run build:${BUILD_ENV}`. */
+    ANGULAR = "angular"
+}
+/**
+ * One AWS Amplify Hosting application served from a workspace package.
+ *
+ * Renders a single entry under `applications:` in the generated `amplify.yml`.
+ * Amplify does not auto-detect PNPM workspaces, so the generated build spec
+ * runs `corepack enable` + a root `pnpm install` and pre-builds any shared
+ * packages before building the app from its `appRoot` (see ADR-0002).
+ */
+export interface MonorepoAmplifyApp {
+    /**
+     * The package path that is the Amplify app root, e.g. `packages/frontend`.
+     */
+    readonly appRoot: string;
+    /**
+     * The frontend framework, used to pick build/artifact/cache defaults.
+     */
+    readonly framework: MonorepoAmplifyFramework;
+    /**
+     * The pnpm package name to build, used as the `--filter` target,
+     * e.g. `deploymon-frontend` or `radball-digital-portal`.
+     */
+    readonly buildFilter: string;
+    /**
+     * Workspace packages to build before the app, as `--filter` targets.
+     *
+     * Typically the shared API package the app consumes via `workspace:*`,
+     * e.g. `['@taimos/deploymon-api']`.
+     *
+     * @default []
+     */
+    readonly preBuildFilters?: string[];
+    /**
+     * Override the build command run in the Amplify `build` phase.
+     *
+     * @default - `pnpm --filter <buildFilter> run build` for Next.js, or
+     * `pnpm --filter <buildFilter> run build:${BUILD_ENV}` for Angular.
+     */
+    readonly buildCommand?: string;
+    /**
+     * Override the artifact base directory.
+     *
+     * @default - `<appRoot>/.next` for Next.js, or
+     * `<appRoot>/dist/<buildFilter>/browser` for Angular.
+     */
+    readonly artifactBaseDirectory?: string;
+    /**
+     * Override the Amplify build cache paths.
+     *
+     * @default - `node_modules/**` plus the framework build cache
+     * (`<appRoot>/.next/cache/**` or `<appRoot>/.angular/cache/**`).
+     */
+    readonly cachePaths?: string[];
+}
+/**
+ * PNPM workspace tuning for the generated `pnpm-workspace.yaml`.
+ */
+export interface MonorepoWorkspaceOptions {
+    /**
+     * The workspace package globs.
+     *
+     * @default ['packages/*']
+     */
+    readonly packages?: string[];
+    /**
+     * Version overrides forced across the whole workspace
+     * (the `overrides:` field). Omitted from the file when empty.
+     *
+     * @default {}
+     */
+    readonly overrides?: {
+        [name: string]: string;
+    };
+    /**
+     * Dependencies allowed to run install/build scripts. pnpm >= 10 blocks these
+     * by default. The list populates both `allowBuilds` and
+     * `onlyBuiltDependencies` so pnpm does not treat `node_modules` as stale.
+     *
+     * @default ['@aws-amplify/cli', 'esbuild', 'sharp', 'unrs-resolver']
+     */
+    readonly allowedBuilds?: string[];
+    /**
+     * Minimum age in minutes a published version must have before it may be
+     * installed (`minimumReleaseAge`).
+     *
+     * @default 2880 // 2 days
+     */
+    readonly minimumReleaseAge?: number;
+    /**
+     * Packages exempt from `minimumReleaseAge` so our own tooling can update
+     * without the cooldown.
+     *
+     * @default ['projen-pipelines', 'cdk-serverless', '@taimos/projen']
+     */
+    readonly minimumReleaseAgeExclude?: string[];
+}
+/**
+ * One author-to-approvers routing rule for the PR approver assignment.
+ */
+export interface MonorepoApproverMapping {
+    /**
+     * The GitHub username opening the PR.
+     */
+    readonly author: string;
+    /**
+     * The GitHub usernames assigned to review when `author` opens a PR.
+     */
+    readonly approvers: string[];
+}
+export interface MonorepoProjectOptions extends typescript.TypeScriptProjectOptions {
+    /**
+     * The pnpm version pinned for the workspace and CI.
+     *
+     * @default '10.33.0'
+     */
+    readonly pnpmWorkspaceVersion?: string;
+    /**
+     * The Node.js version used in the generated build workflow.
+     *
+     * @default '22'
+     */
+    readonly nodeVersion?: string;
+    /**
+     * PNPM workspace tuning for the generated `pnpm-workspace.yaml`.
+     */
+    readonly workspaceOptions?: MonorepoWorkspaceOptions;
+    /**
+     * Whether to add `cdk-serverless` as a workspace dev dependency.
+     *
+     * @default false
+     */
+    readonly cdkServerless?: boolean;
+    /**
+     * Whether to assign PR approvers via `GitHubAssignApprover`.
+     *
+     * @default true
+     */
+    readonly assignApprover?: boolean;
+    /**
+     * Author-to-approvers routing for the PR approver assignment.
+     * Only used when `assignApprover` is enabled.
+     *
+     * @default - hoegertn and hoegerma review each other
+     */
+    readonly approverMapping?: MonorepoApproverMapping[];
+    /**
+     * Approvers assigned when no author-specific mapping matches.
+     * Only used when `assignApprover` is enabled.
+     *
+     * @default ['hoegertn', 'hoegerma']
+     */
+    readonly defaultApprovers?: string[];
+    /**
+     * Whether the unified build workflow also runs `pnpm -r run test`.
+     *
+     * @default true
+     */
+    readonly runTestsInBuild?: boolean;
+    /**
+     * AWS Amplify Hosting applications. When set, an `amplify.yml` is generated
+     * with one entry per app. When omitted, no `amplify.yml` is created.
+     *
+     * @default []
+     */
+    readonly amplifyApps?: MonorepoAmplifyApp[];
+}
+/**
+ * Private PNPM-workspace monorepo root, following Taimos ADR-0002.
+ *
+ * The root only orchestrates the workspace — building, testing and linting are
+ * delegated to the workspace packages via `pnpm -r`. This project generates the
+ * `pnpm-workspace.yaml`, the root convenience scripts, a unified PR build
+ * workflow and (optionally) an Amplify Hosting build spec. The projen-managed
+ * sub-projects (api, backend, infra) are added with the `parent`/`outdir`
+ * pattern in the consuming `.projenrc.ts`; plain workspace packages (e.g.
+ * Next.js apps) are picked up by the `packages/*` glob.
+ *
+ * @pjid taimos-monorepo
+ */
+export declare class MonorepoProject extends typescript.TypeScriptProject {
+    /** The generated `pnpm-workspace.yaml`. */
+    readonly workspaceFile: YamlFile;
+    /** The unified PR build workflow. */
+    readonly prBuildWorkflow: github.GithubWorkflow;
+    /** The generated `amplify.yml`, if any Amplify apps were configured. */
+    readonly amplifyFile?: YamlFile;
+    /** The PR approver assignment, if enabled. */
+    readonly assignApprover?: GitHubAssignApprover;
+    constructor(options: MonorepoProjectOptions);
+    private renderAmplifyApp;
+}

package/lib/projects/monorepo.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonorepoProject = exports.MonorepoAmplifyFramework = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+const projen_pipelines_1 = require("projen-pipelines");
+/**
+ * The frontend framework an Amplify Hosting application is built with.
+ *
+ * Selects sensible defaults for the build command, artifact directory and
+ * cache paths in the generated `amplify.yml`.
+ */
+var MonorepoAmplifyFramework;
+(function (MonorepoAmplifyFramework) {
+    /** A Next.js app — artifacts in `<appRoot>/.next`, built via `run build`. */
+    MonorepoAmplifyFramework["NEXTJS"] = "nextjs";
+    /** An Angular app — artifacts in `<appRoot>/dist/<filter>/browser`, built via `run build:${BUILD_ENV}`. */
+    MonorepoAmplifyFramework["ANGULAR"] = "angular";
+})(MonorepoAmplifyFramework || (exports.MonorepoAmplifyFramework = MonorepoAmplifyFramework = {}));
+/**
+ * Private PNPM-workspace monorepo root, following Taimos ADR-0002.
+ *
+ * The root only orchestrates the workspace — building, testing and linting are
+ * delegated to the workspace packages via `pnpm -r`. This project generates the
+ * `pnpm-workspace.yaml`, the root convenience scripts, a unified PR build
+ * workflow and (optionally) an Amplify Hosting build spec. The projen-managed
+ * sub-projects (api, backend, infra) are added with the `parent`/`outdir`
+ * pattern in the consuming `.projenrc.ts`; plain workspace packages (e.g.
+ * Next.js apps) are picked up by the `packages/*` glob.
+ *
+ * @pjid taimos-monorepo
+ */
+class MonorepoProject extends projen_1.typescript.TypeScriptProject {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@taimos/projen.MonorepoProject", version: "0.1.65" };
+    /** The generated `pnpm-workspace.yaml`. */
+    workspaceFile;
+    /** The unified PR build workflow. */
+    prBuildWorkflow;
+    /** The generated `amplify.yml`, if any Amplify apps were configured. */
+    amplifyFile;
+    /** The PR approver assignment, if enabled. */
+    assignApprover;
+    constructor(options) {
+        const pnpmVersion = options.pnpmWorkspaceVersion ?? '10.33.0';
+        super({
+            licensed: false,
+            release: false,
+            depsUpgrade: false,
+            // The root only orchestrates the workspace — no app code lives here.
+            jest: false,
+            eslint: false,
+            sampleCode: false,
+            // CI is the single hand-rolled workflow below that delegates to packages.
+            buildWorkflow: false,
+            ...options,
+            // Forced — defining what a Taimos monorepo root is.
+            packageManager: projen_1.javascript.NodePackageManager.PNPM,
+            pnpmVersion,
+            projenrcTs: true,
+            github: true,
+            githubOptions: {
+                projenCredentials: projen_1.github.GithubCredentials.fromApp(),
+                mergify: false,
+                mergeQueue: true,
+                ...options.githubOptions,
+                mergeQueueOptions: {
+                    autoQueue: true,
+                    ...options.githubOptions?.mergeQueueOptions,
+                },
+                pullRequestLintOptions: {
+                    ...options.githubOptions?.pullRequestLintOptions,
+                    semanticTitleOptions: {
+                        ...options.githubOptions?.pullRequestLintOptions?.semanticTitleOptions,
+                        // Fixed allowed PR title types for a Taimos monorepo.
+                        types: ['feat', 'fix', 'chore', 'docs', 'spec', 'ci'],
+                    },
+                },
+            },
+            devDeps: [
+                '@taimos/projen',
+                'projen-pipelines',
+                ...(options.cdkServerless ?? false ? ['cdk-serverless'] : []),
+                ...options.devDeps ?? [],
+            ],
+        });
+        // Private workspace root — never published, resolves packages locally.
+        this.package.addField('private', true);
+        // PR approver routing.
+        if (options.assignApprover ?? true) {
+            this.assignApprover = new projen_pipelines_1.GitHubAssignApprover(this, {
+                approverMapping: options.approverMapping ?? [
+                    { author: 'hoegertn', approvers: ['hoegerma'] },
+                    { author: 'hoegerma', approvers: ['hoegertn'] },
+                ],
+                defaultApprovers: options.defaultApprovers ?? ['hoegertn', 'hoegerma'],
+            });
+        }
+        // The projenrc is split into modules under .projen/ — make them part of the
+        // dev tsconfig so the IDE and ts-node type-check them.
+        this.tsconfigDev?.addInclude('.projen/*.ts');
+        // pnpm workspace definition.
+        const ws = options.workspaceOptions ?? {};
+        const allowedBuilds = ws.allowedBuilds ?? ['@aws-amplify/cli', 'esbuild', 'sharp', 'unrs-resolver'];
+        const allowBuilds = {};
+        for (const dep of allowedBuilds) {
+            allowBuilds[dep] = true;
+        }
+        this.workspaceFile = new projen_1.YamlFile(this, 'pnpm-workspace.yaml', {
+            obj: {
+                packages: ws.packages ?? ['packages/*'],
+                // Allow native/build-step packages to run install scripts (pnpm >= 10
+                // blocks these by default), so pnpm does not treat node_modules as stale.
+                allowBuilds,
+                onlyBuiltDependencies: allowedBuilds,
+                ...(ws.overrides && Object.keys(ws.overrides).length > 0 ? { overrides: ws.overrides } : {}),
+                minimumReleaseAge: ws.minimumReleaseAge ?? 2880, // 2 days in minutes
+                minimumReleaseAgeExclude: ws.minimumReleaseAgeExclude ?? [
+                    'projen-pipelines',
+                    'cdk-serverless',
+                    '@taimos/projen',
+                ],
+            },
+        });
+        // Convenience root scripts delegate to the workspace.
+        const rootPkg = this.tryFindObjectFile('package.json');
+        rootPkg.addOverride('scripts.build', 'pnpm -r run build');
+        rootPkg.addOverride('scripts.test', 'pnpm -r run test');
+        rootPkg.addOverride('scripts.lint', 'pnpm -r run eslint');
+        // Unified PR build workflow — builds (and optionally tests) every workspace
+        // package in dependency order.
+        const nodeVersion = options.nodeVersion ?? '22';
+        const buildSteps = [
+            { name: 'Checkout', uses: 'actions/checkout@v4' },
+            { name: 'Setup pnpm', uses: 'pnpm/action-setup@v4', with: { version: pnpmVersion } },
+            {
+                name: 'Setup Node.js',
+                uses: 'actions/setup-node@v4',
+                with: { 'node-version': nodeVersion, 'cache': 'pnpm' },
+            },
+            { name: 'Install', run: 'pnpm install --frozen-lockfile' },
+            { name: 'Build', run: 'pnpm -r run build' },
+        ];
+        if (options.runTestsInBuild ?? true) {
+            buildSteps.push({ name: 'Test', run: 'pnpm -r run test' });
+        }
+        // Path filter: only trigger builds when workspace package files change.
+        // Changes to specs or docs alone should not trigger a new build.
+        const workspacePackages = ws.packages ?? ['packages/*'];
+        const buildPaths = workspacePackages.map((pkg) => `${pkg}/**`);
+        this.prBuildWorkflow = new projen_1.github.GithubWorkflow(this.github, 'build');
+        this.prBuildWorkflow.on({
+            pullRequest: { paths: buildPaths },
+            push: { branches: ['main'], paths: buildPaths },
+            workflowDispatch: {},
+        });
+        this.prBuildWorkflow.addJob('build', {
+            runsOn: ['ubuntu-latest'],
+            permissions: { contents: projen_1.github.workflows.JobPermission.READ },
+            steps: buildSteps,
+        });
+        // AWS Amplify Hosting build spec. PNPM workspaces are not auto-detected by
+        // Amplify, so each app installs at the repo root, pre-builds its shared
+        // packages, then builds from its appRoot (see ADR-0002).
+        if (options.amplifyApps && options.amplifyApps.length > 0) {
+            this.amplifyFile = new projen_1.YamlFile(this, 'amplify.yml', {
+                obj: {
+                    version: 1,
+                    applications: options.amplifyApps.map((app) => this.renderAmplifyApp(app)),
+                },
+            });
+        }
+    }
+    renderAmplifyApp(app) {
+        const angular = app.framework === MonorepoAmplifyFramework.ANGULAR;
+        const preBuild = [
+            'corepack enable',
+            // Force pnpm's hoisted linker for the Amplify build only — Amplify's
+            // managed compute traces runtime deps from a flat node_modules.
+            'pnpm install --frozen-lockfile --node-linker hoisted',
+            ...(app.preBuildFilters ?? []).map((f) => `pnpm --filter ${f} run build`),
+        ];
+        // BUILD_ENV (dev|prod) is provided as an Amplify environment variable.
+        const buildCommand = app.buildCommand ?? (angular
+            ? `pnpm --filter ${app.buildFilter} run build:\${BUILD_ENV}`
+            : `pnpm --filter ${app.buildFilter} run build`);
+        const baseDirectory = app.artifactBaseDirectory ?? (angular
+            ? `${app.appRoot}/dist/${app.buildFilter}/browser`
+            : `${app.appRoot}/.next`);
+        const cachePaths = app.cachePaths ?? [
+            'node_modules/**/*',
+            angular ? `${app.appRoot}/.angular/cache/**/*` : `${app.appRoot}/.next/cache/**/*`,
+        ];
+        return {
+            appRoot: app.appRoot,
+            frontend: {
+                // Install/build from the monorepo root so the workspace root
+                // package.json and pnpm-lock.yaml are available.
+                buildPath: '/',
+                phases: {
+                    preBuild: { commands: preBuild },
+                    build: { commands: [buildCommand] },
+                },
+                artifacts: { baseDirectory, files: ['**/*'] },
+                cache: { paths: cachePaths },
+            },
+        };
+    }
+}
+exports.MonorepoProject = MonorepoProject;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monorepo.js","sourceRoot":"","sources":["../../src/projects/monorepo.ts"],"names":[],"mappings":";;;;AAAA,mCAAkE;AAClE,uDAAwD;AAExD;;;;;GAKG;AACH,IAAY,wBAKX;AALD,WAAY,wBAAwB;IAClC,6EAA6E;IAC7E,6CAAiB,CAAA;IACjB,2GAA2G;IAC3G,+CAAmB,CAAA;AACrB,CAAC,EALW,wBAAwB,wCAAxB,wBAAwB,QAKnC;AA4LD;;;;;;;;;;;;GAYG;AACH,MAAa,eAAgB,SAAQ,mBAAU,CAAC,iBAAiB;;IAE/D,2CAA2C;IAC3B,aAAa,CAAW;IAExC,qCAAqC;IACrB,eAAe,CAAwB;IAEvD,wEAAwE;IACxD,WAAW,CAAY;IAEvC,8CAA8C;IAC9B,cAAc,CAAwB;IAEtD,YAAY,OAA+B;QACzC,MAAM,WAAW,GAAG,OAAO,CAAC,oBAAoB,IAAI,SAAS,CAAC;QAE9D,KAAK,CAAC;YACJ,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,KAAK;YACd,WAAW,EAAE,KAAK;YAClB,qEAAqE;YACrE,IAAI,EAAE,KAAK;YACX,MAAM,EAAE,KAAK;YACb,UAAU,EAAE,KAAK;YACjB,0EAA0E;YAC1E,aAAa,EAAE,KAAK;YACpB,GAAG,OAAO;YACV,oDAAoD;YACpD,cAAc,EAAE,mBAAU,CAAC,kBAAkB,CAAC,IAAI;YAClD,WAAW;YACX,UAAU,EAAE,IAAI;YAChB,MAAM,EAAE,IAAI;YACZ,aAAa,EAAE;gBACb,iBAAiB,EAAE,eAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE;gBACrD,OAAO,EAAE,KAAK;gBACd,UAAU,EAAE,IAAI;gBAChB,GAAG,OAAO,CAAC,aAAa;gBACxB,iBAAiB,EAAE;oBACjB,SAAS,EAAE,IAAI;oBACf,GAAG,OAAO,CAAC,aAAa,EAAE,iBAAiB;iBAC5C;gBACD,sBAAsB,EAAE;oBACtB,GAAG,OAAO,CAAC,aAAa,EAAE,sBAAsB;oBAChD,oBAAoB,EAAE;wBACpB,GAAG,OAAO,CAAC,aAAa,EAAE,sBAAsB,EAAE,oBAAoB;wBACtE,sDAAsD;wBACtD,KAAK,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC;qBACtD;iBACF;aACF;YACD,OAAO,EAAE;gBACP,gBAAgB;gBAChB,kBAAkB;gBAClB,GAAG,CAAC,OAAO,CAAC,aAAa,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC7D,GAAG,OAAO,CAAC,OAAO,IAAI,EAAE;aACzB;SACF,CAAC,CAAC;QAEH,uEAAuE;QACvE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QAEvC,uBAAuB;QACvB,IAAI,OAAO,CAAC,cAAc,IAAI,IAAI,EAAE,CAAC;YACnC,IAAI,CAAC,cAAc,GAAG,IAAI,uCAAoB,CAAC,IAAI,EAAE;gBACnD,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI;oBAC1C,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,UAAU,CAAC,EAAE;oBAC/C,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,CAAC,UAAU,CAAC,EAAE;iBAChD;gBACD,gBAAgB,EAAE,OAAO,CAAC,gBAAgB,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC;aACvE,CAAC,CAAC;QACL,CAAC;QAED,4EAA4E;QAC5E,uDAAuD;QACvD,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,cAAc,CAAC,CAAC;QAE7C,6BAA6B;QAC7B,MAAM,EAAE,GAAG,OAAO,CAAC,gBAAgB,IAAI,EAAE,CAAC;QAC1C,MAAM,aAAa,GAAG,EAAE,CAAC,aAAa,IAAI,CAAC,kBAAkB,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,CAAC,CAAC;QACpG,MAAM,WAAW,GAAgC,EAAE,CAAC;QACpD,KAAK,MAAM,GAAG,IAAI,aAAa,EAAE,CAAC;YAChC,WAAW,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;QAC1B,CAAC;QACD,IAAI,CAAC,aAAa,GAAG,IAAI,iBAAQ,CAAC,IAAI,EAAE,qBAAqB,EAAE;YAC7D,GAAG,EAAE;gBACH,QAAQ,EAAE,EAAE,CAAC,QAAQ,IAAI,CAAC,YAAY,CAAC;gBACvC,sEAAsE;gBACtE,0EAA0E;gBAC1E,WAAW;gBACX,qBAAqB,EAAE,aAAa;gBACpC,GAAG,CAAC,EAAE,CAAC,SAAS,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC5F,iBAAiB,EAAE,EAAE,CAAC,iBAAiB,IAAI,IAAI,EAAE,oBAAoB;gBACrE,wBAAwB,EAAE,EAAE,CAAC,wBAAwB,IAAI;oBACvD,kBAAkB;oBAClB,gBAAgB;oBAChB,gBAAgB;iBACjB;aACF;SACF,CAAC,CAAC;QAEH,sDAAsD;QACtD,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAE,CAAC;QACxD,OAAO,CAAC,WAAW,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC;QAC1D,OAAO,CAAC,WAAW,CAAC,cAAc,EAAE,kBAAkB,CAAC,CAAC;QACxD,OAAO,CAAC,WAAW,CAAC,cAAc,EAAE,oBAAoB,CAAC,CAAC;QAE1D,4EAA4E;QAC5E,+BAA+B;QAC/B,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,IAAI,CAAC;QAChD,MAAM,UAAU,GAA+B;YAC7C,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,qBAAqB,EAAE;YACjD,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,sBAAsB,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE;YACpF;gBACE,IAAI,EAAE,eAAe;gBACrB,IAAI,EAAE,uBAAuB;gBAC7B,IAAI,EAAE,EAAE,cAAc,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE;aACvD;YACD,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,gCAAgC,EAAE;YAC1D,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,mBAAmB,EAAE;SAC5C,CAAC;QACF,IAAI,OAAO,CAAC,eAAe,IAAI,IAAI,EAAE,CAAC;YACpC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,kBAAkB,EAAE,CAAC,CAAC;QAC7D,CAAC;QACD,wEAAwE;QACxE,iEAAiE;QACjE,MAAM,iBAAiB,GAAG,EAAE,CAAC,QAAQ,IAAI,CAAC,YAAY,CAAC,CAAC;QACxD,MAAM,UAAU,GAAG,iBAAiB,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,GAAG,KAAK,CAAC,CAAC;QAE/D,IAAI,CAAC,eAAe,GAAG,IAAI,eAAM,CAAC,cAAc,CAAC,IAAI,CAAC,MAAO,EAAE,OAAO,CAAC,CAAC;QACxE,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC;YACtB,WAAW,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE;YAClC,IAAI,EAAE,EAAE,QAAQ,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE;YAC/C,gBAAgB,EAAE,EAAE;SACrB,CAAC,CAAC;QACH,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,OAAO,EAAE;YACnC,MAAM,EAAE,CAAC,eAAe,CAAC;YACzB,WAAW,EAAE,EAAE,QAAQ,EAAE,eAAM,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE;YAC9D,KAAK,EAAE,UAAU;SAClB,CAAC,CAAC;QAEH,2EAA2E;QAC3E,wEAAwE;QACxE,yDAAyD;QACzD,IAAI,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1D,IAAI,CAAC,WAAW,GAAG,IAAI,iBAAQ,CAAC,IAAI,EAAE,aAAa,EAAE;gBACnD,GAAG,EAAE;oBACH,OAAO,EAAE,CAAC;oBACV,YAAY,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;iBAC3E;aACF,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEO,gBAAgB,CAAC,GAAuB;QAC9C,MAAM,OAAO,GAAG,GAAG,CAAC,SAAS,KAAK,wBAAwB,CAAC,OAAO,CAAC;QACnE,MAAM,QAAQ,GAAG;YACf,iBAAiB;YACjB,qEAAqE;YACrE,gEAAgE;YAChE,sDAAsD;YACtD,GAAG,CAAC,GAAG,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,YAAY,CAAC;SAC1E,CAAC;QACF,uEAAuE;QACvE,MAAM,YAAY,GAAG,GAAG,CAAC,YAAY,IAAI,CAAC,OAAO;YAC/C,CAAC,CAAC,iBAAiB,GAAG,CAAC,WAAW,0BAA0B;YAC5D,CAAC,CAAC,iBAAiB,GAAG,CAAC,WAAW,YAAY,CAAC,CAAC;QAClD,MAAM,aAAa,GAAG,GAAG,CAAC,qBAAqB,IAAI,CAAC,OAAO;YACzD,CAAC,CAAC,GAAG,GAAG,CAAC,OAAO,SAAS,GAAG,CAAC,WAAW,UAAU;YAClD,CAAC,CAAC,GAAG,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC;QAC5B,MAAM,UAAU,GAAG,GAAG,CAAC,UAAU,IAAI;YACnC,mBAAmB;YACnB,OAAO,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,OAAO,mBAAmB;SACnF,CAAC;QACF,OAAO;YACL,OAAO,EAAE,GAAG,CAAC,OAAO;YACpB,QAAQ,EAAE;gBACR,6DAA6D;gBAC7D,iDAAiD;gBACjD,SAAS,EAAE,GAAG;gBACd,MAAM,EAAE;oBACN,QAAQ,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE;oBAChC,KAAK,EAAE,EAAE,QAAQ,EAAE,CAAC,YAAY,CAAC,EAAE;iBACpC;gBACD,SAAS,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE;gBAC7C,KAAK,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE;aAC7B;SACF,CAAC;IACJ,CAAC;;AA5LH,0CA6LC","sourcesContent":["import { github, javascript, typescript, YamlFile } from 'projen';\nimport { GitHubAssignApprover } from 'projen-pipelines';\n\n/**\n * The frontend framework an Amplify Hosting application is built with.\n *\n * Selects sensible defaults for the build command, artifact directory and\n * cache paths in the generated `amplify.yml`.\n */\nexport enum MonorepoAmplifyFramework {\n  /** A Next.js app — artifacts in `<appRoot>/.next`, built via `run build`. */\n  NEXTJS = 'nextjs',\n  /** An Angular app — artifacts in `<appRoot>/dist/<filter>/browser`, built via `run build:${BUILD_ENV}`. */\n  ANGULAR = 'angular',\n}\n\n/**\n * One AWS Amplify Hosting application served from a workspace package.\n *\n * Renders a single entry under `applications:` in the generated `amplify.yml`.\n * Amplify does not auto-detect PNPM workspaces, so the generated build spec\n * runs `corepack enable` + a root `pnpm install` and pre-builds any shared\n * packages before building the app from its `appRoot` (see ADR-0002).\n */\nexport interface MonorepoAmplifyApp {\n  /**\n   * The package path that is the Amplify app root, e.g. `packages/frontend`.\n   */\n  readonly appRoot: string;\n\n  /**\n   * The frontend framework, used to pick build/artifact/cache defaults.\n   */\n  readonly framework: MonorepoAmplifyFramework;\n\n  /**\n   * The pnpm package name to build, used as the `--filter` target,\n   * e.g. `deploymon-frontend` or `radball-digital-portal`.\n   */\n  readonly buildFilter: string;\n\n  /**\n   * Workspace packages to build before the app, as `--filter` targets.\n   *\n   * Typically the shared API package the app consumes via `workspace:*`,\n   * e.g. `['@taimos/deploymon-api']`.\n   *\n   * @default []\n   */\n  readonly preBuildFilters?: string[];\n\n  /**\n   * Override the build command run in the Amplify `build` phase.\n   *\n   * @default - `pnpm --filter <buildFilter> run build` for Next.js, or\n   * `pnpm --filter <buildFilter> run build:${BUILD_ENV}` for Angular.\n   */\n  readonly buildCommand?: string;\n\n  /**\n   * Override the artifact base directory.\n   *\n   * @default - `<appRoot>/.next` for Next.js, or\n   * `<appRoot>/dist/<buildFilter>/browser` for Angular.\n   */\n  readonly artifactBaseDirectory?: string;\n\n  /**\n   * Override the Amplify build cache paths.\n   *\n   * @default - `node_modules/**` plus the framework build cache\n   * (`<appRoot>/.next/cache/**` or `<appRoot>/.angular/cache/**`).\n   */\n  readonly cachePaths?: string[];\n}\n\n/**\n * PNPM workspace tuning for the generated `pnpm-workspace.yaml`.\n */\nexport interface MonorepoWorkspaceOptions {\n  /**\n   * The workspace package globs.\n   *\n   * @default ['packages/*']\n   */\n  readonly packages?: string[];\n\n  /**\n   * Version overrides forced across the whole workspace\n   * (the `overrides:` field). Omitted from the file when empty.\n   *\n   * @default {}\n   */\n  readonly overrides?: { [name: string]: string };\n\n  /**\n   * Dependencies allowed to run install/build scripts. pnpm >= 10 blocks these\n   * by default. The list populates both `allowBuilds` and\n   * `onlyBuiltDependencies` so pnpm does not treat `node_modules` as stale.\n   *\n   * @default ['@aws-amplify/cli', 'esbuild', 'sharp', 'unrs-resolver']\n   */\n  readonly allowedBuilds?: string[];\n\n  /**\n   * Minimum age in minutes a published version must have before it may be\n   * installed (`minimumReleaseAge`).\n   *\n   * @default 2880 // 2 days\n   */\n  readonly minimumReleaseAge?: number;\n\n  /**\n   * Packages exempt from `minimumReleaseAge` so our own tooling can update\n   * without the cooldown.\n   *\n   * @default ['projen-pipelines', 'cdk-serverless', '@taimos/projen']\n   */\n  readonly minimumReleaseAgeExclude?: string[];\n}\n\n/**\n * One author-to-approvers routing rule for the PR approver assignment.\n */\nexport interface MonorepoApproverMapping {\n  /**\n   * The GitHub username opening the PR.\n   */\n  readonly author: string;\n\n  /**\n   * The GitHub usernames assigned to review when `author` opens a PR.\n   */\n  readonly approvers: string[];\n}\n\nexport interface MonorepoProjectOptions extends typescript.TypeScriptProjectOptions {\n  /**\n   * The pnpm version pinned for the workspace and CI.\n   *\n   * @default '10.33.0'\n   */\n  readonly pnpmWorkspaceVersion?: string;\n\n  /**\n   * The Node.js version used in the generated build workflow.\n   *\n   * @default '22'\n   */\n  readonly nodeVersion?: string;\n\n  /**\n   * PNPM workspace tuning for the generated `pnpm-workspace.yaml`.\n   */\n  readonly workspaceOptions?: MonorepoWorkspaceOptions;\n\n  /**\n   * Whether to add `cdk-serverless` as a workspace dev dependency.\n   *\n   * @default false\n   */\n  readonly cdkServerless?: boolean;\n\n  /**\n   * Whether to assign PR approvers via `GitHubAssignApprover`.\n   *\n   * @default true\n   */\n  readonly assignApprover?: boolean;\n\n  /**\n   * Author-to-approvers routing for the PR approver assignment.\n   * Only used when `assignApprover` is enabled.\n   *\n   * @default - hoegertn and hoegerma review each other\n   */\n  readonly approverMapping?: MonorepoApproverMapping[];\n\n  /**\n   * Approvers assigned when no author-specific mapping matches.\n   * Only used when `assignApprover` is enabled.\n   *\n   * @default ['hoegertn', 'hoegerma']\n   */\n  readonly defaultApprovers?: string[];\n\n  /**\n   * Whether the unified build workflow also runs `pnpm -r run test`.\n   *\n   * @default true\n   */\n  readonly runTestsInBuild?: boolean;\n\n  /**\n   * AWS Amplify Hosting applications. When set, an `amplify.yml` is generated\n   * with one entry per app. When omitted, no `amplify.yml` is created.\n   *\n   * @default []\n   */\n  readonly amplifyApps?: MonorepoAmplifyApp[];\n}\n\n/**\n * Private PNPM-workspace monorepo root, following Taimos ADR-0002.\n *\n * The root only orchestrates the workspace — building, testing and linting are\n * delegated to the workspace packages via `pnpm -r`. This project generates the\n * `pnpm-workspace.yaml`, the root convenience scripts, a unified PR build\n * workflow and (optionally) an Amplify Hosting build spec. The projen-managed\n * sub-projects (api, backend, infra) are added with the `parent`/`outdir`\n * pattern in the consuming `.projenrc.ts`; plain workspace packages (e.g.\n * Next.js apps) are picked up by the `packages/*` glob.\n *\n * @pjid taimos-monorepo\n */\nexport class MonorepoProject extends typescript.TypeScriptProject {\n\n  /** The generated `pnpm-workspace.yaml`. */\n  public readonly workspaceFile: YamlFile;\n\n  /** The unified PR build workflow. */\n  public readonly prBuildWorkflow: github.GithubWorkflow;\n\n  /** The generated `amplify.yml`, if any Amplify apps were configured. */\n  public readonly amplifyFile?: YamlFile;\n\n  /** The PR approver assignment, if enabled. */\n  public readonly assignApprover?: GitHubAssignApprover;\n\n  constructor(options: MonorepoProjectOptions) {\n    const pnpmVersion = options.pnpmWorkspaceVersion ?? '10.33.0';\n\n    super({\n      licensed: false,\n      release: false,\n      depsUpgrade: false,\n      // The root only orchestrates the workspace — no app code lives here.\n      jest: false,\n      eslint: false,\n      sampleCode: false,\n      // CI is the single hand-rolled workflow below that delegates to packages.\n      buildWorkflow: false,\n      ...options,\n      // Forced — defining what a Taimos monorepo root is.\n      packageManager: javascript.NodePackageManager.PNPM,\n      pnpmVersion,\n      projenrcTs: true,\n      github: true,\n      githubOptions: {\n        projenCredentials: github.GithubCredentials.fromApp(),\n        mergify: false,\n        mergeQueue: true,\n        ...options.githubOptions,\n        mergeQueueOptions: {\n          autoQueue: true,\n          ...options.githubOptions?.mergeQueueOptions,\n        },\n        pullRequestLintOptions: {\n          ...options.githubOptions?.pullRequestLintOptions,\n          semanticTitleOptions: {\n            ...options.githubOptions?.pullRequestLintOptions?.semanticTitleOptions,\n            // Fixed allowed PR title types for a Taimos monorepo.\n            types: ['feat', 'fix', 'chore', 'docs', 'spec', 'ci'],\n          },\n        },\n      },\n      devDeps: [\n        '@taimos/projen',\n        'projen-pipelines',\n        ...(options.cdkServerless ?? false ? ['cdk-serverless'] : []),\n        ...options.devDeps ?? [],\n      ],\n    });\n\n    // Private workspace root — never published, resolves packages locally.\n    this.package.addField('private', true);\n\n    // PR approver routing.\n    if (options.assignApprover ?? true) {\n      this.assignApprover = new GitHubAssignApprover(this, {\n        approverMapping: options.approverMapping ?? [\n          { author: 'hoegertn', approvers: ['hoegerma'] },\n          { author: 'hoegerma', approvers: ['hoegertn'] },\n        ],\n        defaultApprovers: options.defaultApprovers ?? ['hoegertn', 'hoegerma'],\n      });\n    }\n\n    // The projenrc is split into modules under .projen/ — make them part of the\n    // dev tsconfig so the IDE and ts-node type-check them.\n    this.tsconfigDev?.addInclude('.projen/*.ts');\n\n    // pnpm workspace definition.\n    const ws = options.workspaceOptions ?? {};\n    const allowedBuilds = ws.allowedBuilds ?? ['@aws-amplify/cli', 'esbuild', 'sharp', 'unrs-resolver'];\n    const allowBuilds: { [name: string]: boolean } = {};\n    for (const dep of allowedBuilds) {\n      allowBuilds[dep] = true;\n    }\n    this.workspaceFile = new YamlFile(this, 'pnpm-workspace.yaml', {\n      obj: {\n        packages: ws.packages ?? ['packages/*'],\n        // Allow native/build-step packages to run install scripts (pnpm >= 10\n        // blocks these by default), so pnpm does not treat node_modules as stale.\n        allowBuilds,\n        onlyBuiltDependencies: allowedBuilds,\n        ...(ws.overrides && Object.keys(ws.overrides).length > 0 ? { overrides: ws.overrides } : {}),\n        minimumReleaseAge: ws.minimumReleaseAge ?? 2880, // 2 days in minutes\n        minimumReleaseAgeExclude: ws.minimumReleaseAgeExclude ?? [\n          'projen-pipelines',\n          'cdk-serverless',\n          '@taimos/projen',\n        ],\n      },\n    });\n\n    // Convenience root scripts delegate to the workspace.\n    const rootPkg = this.tryFindObjectFile('package.json')!;\n    rootPkg.addOverride('scripts.build', 'pnpm -r run build');\n    rootPkg.addOverride('scripts.test', 'pnpm -r run test');\n    rootPkg.addOverride('scripts.lint', 'pnpm -r run eslint');\n\n    // Unified PR build workflow — builds (and optionally tests) every workspace\n    // package in dependency order.\n    const nodeVersion = options.nodeVersion ?? '22';\n    const buildSteps: github.workflows.JobStep[] = [\n      { name: 'Checkout', uses: 'actions/checkout@v4' },\n      { name: 'Setup pnpm', uses: 'pnpm/action-setup@v4', with: { version: pnpmVersion } },\n      {\n        name: 'Setup Node.js',\n        uses: 'actions/setup-node@v4',\n        with: { 'node-version': nodeVersion, 'cache': 'pnpm' },\n      },\n      { name: 'Install', run: 'pnpm install --frozen-lockfile' },\n      { name: 'Build', run: 'pnpm -r run build' },\n    ];\n    if (options.runTestsInBuild ?? true) {\n      buildSteps.push({ name: 'Test', run: 'pnpm -r run test' });\n    }\n    // Path filter: only trigger builds when workspace package files change.\n    // Changes to specs or docs alone should not trigger a new build.\n    const workspacePackages = ws.packages ?? ['packages/*'];\n    const buildPaths = workspacePackages.map((pkg) => `${pkg}/**`);\n\n    this.prBuildWorkflow = new github.GithubWorkflow(this.github!, 'build');\n    this.prBuildWorkflow.on({\n      pullRequest: { paths: buildPaths },\n      push: { branches: ['main'], paths: buildPaths },\n      workflowDispatch: {},\n    });\n    this.prBuildWorkflow.addJob('build', {\n      runsOn: ['ubuntu-latest'],\n      permissions: { contents: github.workflows.JobPermission.READ },\n      steps: buildSteps,\n    });\n\n    // AWS Amplify Hosting build spec. PNPM workspaces are not auto-detected by\n    // Amplify, so each app installs at the repo root, pre-builds its shared\n    // packages, then builds from its appRoot (see ADR-0002).\n    if (options.amplifyApps && options.amplifyApps.length > 0) {\n      this.amplifyFile = new YamlFile(this, 'amplify.yml', {\n        obj: {\n          version: 1,\n          applications: options.amplifyApps.map((app) => this.renderAmplifyApp(app)),\n        },\n      });\n    }\n  }\n\n  private renderAmplifyApp(app: MonorepoAmplifyApp) {\n    const angular = app.framework === MonorepoAmplifyFramework.ANGULAR;\n    const preBuild = [\n      'corepack enable',\n      // Force pnpm's hoisted linker for the Amplify build only — Amplify's\n      // managed compute traces runtime deps from a flat node_modules.\n      'pnpm install --frozen-lockfile --node-linker hoisted',\n      ...(app.preBuildFilters ?? []).map((f) => `pnpm --filter ${f} run build`),\n    ];\n    // BUILD_ENV (dev|prod) is provided as an Amplify environment variable.\n    const buildCommand = app.buildCommand ?? (angular\n      ? `pnpm --filter ${app.buildFilter} run build:\\${BUILD_ENV}`\n      : `pnpm --filter ${app.buildFilter} run build`);\n    const baseDirectory = app.artifactBaseDirectory ?? (angular\n      ? `${app.appRoot}/dist/${app.buildFilter}/browser`\n      : `${app.appRoot}/.next`);\n    const cachePaths = app.cachePaths ?? [\n      'node_modules/**/*',\n      angular ? `${app.appRoot}/.angular/cache/**/*` : `${app.appRoot}/.next/cache/**/*`,\n    ];\n    return {\n      appRoot: app.appRoot,\n      frontend: {\n        // Install/build from the monorepo root so the workspace root\n        // package.json and pnpm-lock.yaml are available.\n        buildPath: '/',\n        phases: {\n          preBuild: { commands: preBuild },\n          build: { commands: [buildCommand] },\n        },\n        artifacts: { baseDirectory, files: ['**/*'] },\n        cache: { paths: cachePaths },\n      },\n    };\n  }\n}\n"]}

package/lib/projects/private-cdk-app.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrivateTaimosCdkApp = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
@@ -11,6 +10,7 @@ const cdk_app_1 = require("./cdk-app");
  * @pjid taimos-cdk-app-private
  */
 class PrivateTaimosCdkApp extends cdk_app_1.TaimosCdkApp {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@taimos/projen.PrivateTaimosCdkApp", version: "0.1.65" };
     constructor(options) {
         super({
             licensed: false,
@@ -22,6 +22,4 @@ class PrivateTaimosCdkApp extends cdk_app_1.TaimosCdkApp {
     }
 }
 exports.PrivateTaimosCdkApp = PrivateTaimosCdkApp;
-_a = JSII_RTTI_SYMBOL_1;
-PrivateTaimosCdkApp[_a] = { fqn: "@taimos/projen.PrivateTaimosCdkApp", version: "0.1.63" };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZS1jZGstYXBwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb2plY3RzL3ByaXZhdGUtY2RrLWFwcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLG1DQUFvQztBQUNwQyx1Q0FBOEQ7QUFNOUQ7Ozs7R0FJRztBQUNILE1BQWEsbUJBQW9CLFNBQVEsc0JBQVk7SUFFbkQsWUFBWSxPQUFtQztRQUM3QyxLQUFLLENBQUM7WUFDSixRQUFRLEVBQUUsS0FBSztZQUNmLFNBQVMsRUFBRSxtQkFBVSxDQUFDLFNBQVMsQ0FBQyxVQUFVO1lBQzFDLEdBQUcsT0FBTztTQUNYLENBQUMsQ0FBQztRQUVILElBQUksQ0FBQyxVQUFVLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUNsQyxJQUFJLENBQUMsT0FBTyxDQUFDLG9CQUFvQixDQUFDLENBQUM7SUFDckMsQ0FBQzs7QUFYSCxrREFZQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGphdmFzY3JpcHQgfSBmcm9tICdwcm9qZW4nO1xuaW1wb3J0IHsgVGFpbW9zQ2RrQXBwLCBUYWltb3NDZGtBcHBPcHRpb25zIH0gZnJvbSAnLi9jZGstYXBwJztcblxuZXhwb3J0IGludGVyZmFjZSBQcml2YXRlVGFpbW9zQ2RrQXBwT3B0aW9ucyBleHRlbmRzIFRhaW1vc0Nka0FwcE9wdGlvbnMge1xuICAvL1xufVxuXG4vKipcbiAqIFByaXZhdGUgQVdTIENESyBhcHAgaW4gVHlwZVNjcmlwdFxuICpcbiAqIEBwamlkIHRhaW1vcy1jZGstYXBwLXByaXZhdGVcbiAqL1xuZXhwb3J0IGNsYXNzIFByaXZhdGVUYWltb3NDZGtBcHAgZXh0ZW5kcyBUYWltb3NDZGtBcHAge1xuXG4gIGNvbnN0cnVjdG9yKG9wdGlvbnM6IFByaXZhdGVUYWltb3NDZGtBcHBPcHRpb25zKSB7XG4gICAgc3VwZXIoe1xuICAgICAgbGljZW5zZWQ6IGZhbHNlLFxuICAgICAgbnBtQWNjZXNzOiBqYXZhc2NyaXB0Lk5wbUFjY2Vzcy5SRVNUUklDVEVELFxuICAgICAgLi4ub3B0aW9ucyxcbiAgICB9KTtcblxuICAgIHRoaXMuYWRkRGV2RGVwcygnQHRhaW1vcy9wcm9qZW4nKTtcbiAgICB0aGlzLmFkZERlcHMoJ0B0YWltb3MvY29uc3RydWN0cycpO1xuICB9XG59Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZS1jZGstYXBwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb2plY3RzL3ByaXZhdGUtY2RrLWFwcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBQUEsbUNBQW9DO0FBQ3BDLHVDQUE4RDtBQU05RDs7OztHQUlHO0FBQ0gsTUFBYSxtQkFBb0IsU0FBUSxzQkFBWTs7SUFFbkQsWUFBWSxPQUFtQztRQUM3QyxLQUFLLENBQUM7WUFDSixRQUFRLEVBQUUsS0FBSztZQUNmLFNBQVMsRUFBRSxtQkFBVSxDQUFDLFNBQVMsQ0FBQyxVQUFVO1lBQzFDLEdBQUcsT0FBTztTQUNYLENBQUMsQ0FBQztRQUVILElBQUksQ0FBQyxVQUFVLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUNsQyxJQUFJLENBQUMsT0FBTyxDQUFDLG9CQUFvQixDQUFDLENBQUM7SUFDckMsQ0FBQzs7QUFYSCxrREFZQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGphdmFzY3JpcHQgfSBmcm9tICdwcm9qZW4nO1xuaW1wb3J0IHsgVGFpbW9zQ2RrQXBwLCBUYWltb3NDZGtBcHBPcHRpb25zIH0gZnJvbSAnLi9jZGstYXBwJztcblxuZXhwb3J0IGludGVyZmFjZSBQcml2YXRlVGFpbW9zQ2RrQXBwT3B0aW9ucyBleHRlbmRzIFRhaW1vc0Nka0FwcE9wdGlvbnMge1xuICAvL1xufVxuXG4vKipcbiAqIFByaXZhdGUgQVdTIENESyBhcHAgaW4gVHlwZVNjcmlwdFxuICpcbiAqIEBwamlkIHRhaW1vcy1jZGstYXBwLXByaXZhdGVcbiAqL1xuZXhwb3J0IGNsYXNzIFByaXZhdGVUYWltb3NDZGtBcHAgZXh0ZW5kcyBUYWltb3NDZGtBcHAge1xuXG4gIGNvbnN0cnVjdG9yKG9wdGlvbnM6IFByaXZhdGVUYWltb3NDZGtBcHBPcHRpb25zKSB7XG4gICAgc3VwZXIoe1xuICAgICAgbGljZW5zZWQ6IGZhbHNlLFxuICAgICAgbnBtQWNjZXNzOiBqYXZhc2NyaXB0Lk5wbUFjY2Vzcy5SRVNUUklDVEVELFxuICAgICAgLi4ub3B0aW9ucyxcbiAgICB9KTtcblxuICAgIHRoaXMuYWRkRGV2RGVwcygnQHRhaW1vcy9wcm9qZW4nKTtcbiAgICB0aGlzLmFkZERlcHMoJ0B0YWltb3MvY29uc3RydWN0cycpO1xuICB9XG59Il19

package/lib/projects/private-ts-lib.js

@@ -1,5 +1,4 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaimosPrivateTypescriptLibrary = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
@@ -11,6 +10,7 @@ const ts_lib_1 = require("./ts-lib");
  * @pjid taimos-ts-lib-private
  */
 class TaimosPrivateTypescriptLibrary extends ts_lib_1.TaimosTypescriptLibrary {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@taimos/projen.TaimosPrivateTypescriptLibrary", version: "0.1.65" };
     constructor(options) {
         super({
             licensed: false,
@@ -20,6 +20,4 @@ class TaimosPrivateTypescriptLibrary extends ts_lib_1.TaimosTypescriptLibrary {
     }
 }
 exports.TaimosPrivateTypescriptLibrary = TaimosPrivateTypescriptLibrary;
-_a = JSII_RTTI_SYMBOL_1;
-TaimosPrivateTypescriptLibrary[_a] = { fqn: "@taimos/projen.TaimosPrivateTypescriptLibrary", version: "0.1.63" };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZS10cy1saWIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvamVjdHMvcHJpdmF0ZS10cy1saWIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxtQ0FBb0M7QUFDcEMscUNBQW1GO0FBTW5GOzs7O0dBSUc7QUFDSCxNQUFhLDhCQUErQixTQUFRLGdDQUF1QjtJQUV6RSxZQUFZLE9BQThDO1FBQ3hELEtBQUssQ0FBQztZQUNKLFFBQVEsRUFBRSxLQUFLO1lBQ2YsU0FBUyxFQUFFLG1CQUFVLENBQUMsU0FBUyxDQUFDLFVBQVU7WUFDMUMsR0FBRyxPQUFPO1NBQ1gsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzs7QUFSSCx3RUFVQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGphdmFzY3JpcHQgfSBmcm9tICdwcm9qZW4nO1xuaW1wb3J0IHsgVGFpbW9zVHlwZXNjcmlwdExpYnJhcnksIFRhaW1vc1R5cGVzY3JpcHRMaWJyYXJ5T3B0aW9ucyB9IGZyb20gJy4vdHMtbGliJztcblxuZXhwb3J0IGludGVyZmFjZSBUYWltb3NQcml2YXRlVHlwZXNjcmlwdExpYnJhcnlPcHRpb25zIGV4dGVuZHMgVGFpbW9zVHlwZXNjcmlwdExpYnJhcnlPcHRpb25zIHtcbiAgLy9cbn1cblxuLyoqXG4gKiBQcml2YXRlIFR5cGVTY3JpcHQgbGlicmFyeVxuICpcbiAqIEBwamlkIHRhaW1vcy10cy1saWItcHJpdmF0ZVxuICovXG5leHBvcnQgY2xhc3MgVGFpbW9zUHJpdmF0ZVR5cGVzY3JpcHRMaWJyYXJ5IGV4dGVuZHMgVGFpbW9zVHlwZXNjcmlwdExpYnJhcnkge1xuXG4gIGNvbnN0cnVjdG9yKG9wdGlvbnM6IFRhaW1vc1ByaXZhdGVUeXBlc2NyaXB0TGlicmFyeU9wdGlvbnMpIHtcbiAgICBzdXBlcih7XG4gICAgICBsaWNlbnNlZDogZmFsc2UsXG4gICAgICBucG1BY2Nlc3M6IGphdmFzY3JpcHQuTnBtQWNjZXNzLlJFU1RSSUNURUQsXG4gICAgICAuLi5vcHRpb25zLFxuICAgIH0pO1xuICB9XG5cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZS10cy1saWIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvamVjdHMvcHJpdmF0ZS10cy1saWIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLG1DQUFvQztBQUNwQyxxQ0FBbUY7QUFNbkY7Ozs7R0FJRztBQUNILE1BQWEsOEJBQStCLFNBQVEsZ0NBQXVCOztJQUV6RSxZQUFZLE9BQThDO1FBQ3hELEtBQUssQ0FBQztZQUNKLFFBQVEsRUFBRSxLQUFLO1lBQ2YsU0FBUyxFQUFFLG1CQUFVLENBQUMsU0FBUyxDQUFDLFVBQVU7WUFDMUMsR0FBRyxPQUFPO1NBQ1gsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzs7QUFSSCx3RUFVQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGphdmFzY3JpcHQgfSBmcm9tICdwcm9qZW4nO1xuaW1wb3J0IHsgVGFpbW9zVHlwZXNjcmlwdExpYnJhcnksIFRhaW1vc1R5cGVzY3JpcHRMaWJyYXJ5T3B0aW9ucyB9IGZyb20gJy4vdHMtbGliJztcblxuZXhwb3J0IGludGVyZmFjZSBUYWltb3NQcml2YXRlVHlwZXNjcmlwdExpYnJhcnlPcHRpb25zIGV4dGVuZHMgVGFpbW9zVHlwZXNjcmlwdExpYnJhcnlPcHRpb25zIHtcbiAgLy9cbn1cblxuLyoqXG4gKiBQcml2YXRlIFR5cGVTY3JpcHQgbGlicmFyeVxuICpcbiAqIEBwamlkIHRhaW1vcy10cy1saWItcHJpdmF0ZVxuICovXG5leHBvcnQgY2xhc3MgVGFpbW9zUHJpdmF0ZVR5cGVzY3JpcHRMaWJyYXJ5IGV4dGVuZHMgVGFpbW9zVHlwZXNjcmlwdExpYnJhcnkge1xuXG4gIGNvbnN0cnVjdG9yKG9wdGlvbnM6IFRhaW1vc1ByaXZhdGVUeXBlc2NyaXB0TGlicmFyeU9wdGlvbnMpIHtcbiAgICBzdXBlcih7XG4gICAgICBsaWNlbnNlZDogZmFsc2UsXG4gICAgICBucG1BY2Nlc3M6IGphdmFzY3JpcHQuTnBtQWNjZXNzLlJFU1RSSUNURUQsXG4gICAgICAuLi5vcHRpb25zLFxuICAgIH0pO1xuICB9XG5cbn1cbiJdfQ==