cdklabs-projen-project-types 0.1.217 → 0.1.219

package/.jsii

@@ -85,7 +85,7 @@
     "stability": "stable"
   },
   "homepage": "https://github.com/cdklabs/cdklabs-projen-project-types.git",
-  "jsiiVersion": "5.5.19 (build 4b38fcf)",
+  "jsiiVersion": "5.5.21 (build db74302)",
   "license": "Apache-2.0",
   "metadata": {
     "jsii": {
@@ -108,7 +108,7 @@
     "cdklabs-projen-project-types.yarn": {
       "locationInModule": {
         "filename": "src/index.ts",
-        "line": 10
+        "line": 11
       },
       "symbolId": "src/yarn/index:"
     }
@@ -119,6 +119,150 @@
     }
   },
   "types": {
+    "cdklabs-projen-project-types.CdkCliIntegTestsWorkflow": {
+      "assembly": "cdklabs-projen-project-types",
+      "base": "projen.Component",
+      "docs": {
+        "remarks": "This MUST be a separate workflow that runs in privileged context. We have a couple\nof options:\n\n- `workflow_run`: we can trigger a privileged workflow run after the unprivileged\n  `pull_request` workflow finishes and reuse its output artifacts. The\n  problem is that the second run is disconnected from the PR so we would need\n  to script in visibility for approvals and success (by posting comments, for\n  example)\n- Use only a `pull_request_target` workflow on the PR: this either would run\n  a privileged workflow on any user code submission (might be fine given the\n  workflow's `permissions`, but I'm sure this will make our security team uneasy\n  anyway), OR this would mean any build needs human confirmation which means slow\n  feedback.\n- Use a `pull_request` for a regular fast-feedback build, and a separate\n  `pull_request_target` for the integ tests. This means we're building twice.\n\nUltimately, our build isn't heavy enough to put in a lot of effort deduping\nit, so we'll go with the simplest solution which is the last one: 2\nindependent workflows.\n\nprojen doesn't make it easy to copy the relevant parts of the 'build' workflow,\nso they're unfortunately duplicated here.",
+        "stability": "stable",
+        "summary": "Add a workflow for running the tests."
+      },
+      "fqn": "cdklabs-projen-project-types.CdkCliIntegTestsWorkflow",
+      "initializer": {
+        "docs": {
+          "stability": "stable"
+        },
+        "locationInModule": {
+          "filename": "src/cdk-cli-integ-tests.ts",
+          "line": 65
+        },
+        "parameters": [
+          {
+            "name": "repo",
+            "type": {
+              "fqn": "projen.javascript.NodeProject"
+            }
+          },
+          {
+            "name": "props",
+            "type": {
+              "fqn": "cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps"
+            }
+          }
+        ]
+      },
+      "kind": "class",
+      "locationInModule": {
+        "filename": "src/cdk-cli-integ-tests.ts",
+        "line": 64
+      },
+      "name": "CdkCliIntegTestsWorkflow",
+      "symbolId": "src/cdk-cli-integ-tests:CdkCliIntegTestsWorkflow"
+    },
+    "cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps": {
+      "assembly": "cdklabs-projen-project-types",
+      "datatype": true,
+      "docs": {
+        "stability": "stable"
+      },
+      "fqn": "cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps",
+      "kind": "interface",
+      "locationInModule": {
+        "filename": "src/cdk-cli-integ-tests.ts",
+        "line": 3
+      },
+      "name": "CdkCliIntegTestsWorkflowProps",
+      "properties": [
+        {
+          "abstract": true,
+          "docs": {
+            "remarks": "MUST be configured to require manual approval.",
+            "stability": "stable",
+            "summary": "GitHub environment name for approvals."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/cdk-cli-integ-tests.ts",
+            "line": 19
+          },
+          "name": "approvalEnvironment",
+          "type": {
+            "primitive": "string"
+          }
+        },
+        {
+          "abstract": true,
+          "docs": {
+            "stability": "stable",
+            "summary": "Runners for the workflow."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/cdk-cli-integ-tests.ts",
+            "line": 7
+          },
+          "name": "buildRunsOn",
+          "type": {
+            "primitive": "string"
+          }
+        },
+        {
+          "abstract": true,
+          "docs": {
+            "stability": "stable",
+            "summary": "Packages that are locally transfered (we will never use the upstream versions)."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/cdk-cli-integ-tests.ts",
+            "line": 35
+          },
+          "name": "localPackages",
+          "type": {
+            "collection": {
+              "elementtype": {
+                "primitive": "string"
+              },
+              "kind": "array"
+            }
+          }
+        },
+        {
+          "abstract": true,
+          "docs": {
+            "remarks": "MUST be configured without approvals, and with the following vars and secrets:\n\n- vars: AWS_ROLE_TO_ASSUME_FOR_TESTING\n\nAnd the role needs to be configured to allow the AssumeRole operation.",
+            "stability": "stable",
+            "summary": "GitHub environment name for running the tests."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/cdk-cli-integ-tests.ts",
+            "line": 30
+          },
+          "name": "testEnvironment",
+          "type": {
+            "primitive": "string"
+          }
+        },
+        {
+          "abstract": true,
+          "docs": {
+            "stability": "stable",
+            "summary": "Runners for the workflow."
+          },
+          "immutable": true,
+          "locationInModule": {
+            "filename": "src/cdk-cli-integ-tests.ts",
+            "line": 12
+          },
+          "name": "testRunsOn",
+          "type": {
+            "primitive": "string"
+          }
+        }
+      ],
+      "symbolId": "src/cdk-cli-integ-tests:CdkCliIntegTestsWorkflowProps"
+    },
     "cdklabs-projen-project-types.CdkCommonOptions": {
       "assembly": "cdklabs-projen-project-types",
       "datatype": true,
@@ -14127,6 +14271,6 @@
       "symbolId": "src/yarn/typescript-workspace-release:WorkspaceReleaseOptions"
     }
   },
-  "version": "0.1.217",
-  "fingerprint": "GB2971H+RE7g/bK6TndL6Qr2lggd39j+xysPvzNKA04="
+  "version": "0.1.219",
+  "fingerprint": "Z6Rcak4TCL7TMCclJwUD9H+1+EovWghNqAkm7JuprG8="
 }

package/API.md

@@ -2,6 +2,194 @@
 
 ## Constructs <a name="Constructs" id="Constructs"></a>
 
+### CdkCliIntegTestsWorkflow <a name="CdkCliIntegTestsWorkflow" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow"></a>
+
+Add a workflow for running the tests.
+
+This MUST be a separate workflow that runs in privileged context. We have a couple
+of options:
+
+- `workflow_run`: we can trigger a privileged workflow run after the unprivileged
+  `pull_request` workflow finishes and reuse its output artifacts. The
+  problem is that the second run is disconnected from the PR so we would need
+  to script in visibility for approvals and success (by posting comments, for
+  example)
+- Use only a `pull_request_target` workflow on the PR: this either would run
+  a privileged workflow on any user code submission (might be fine given the
+  workflow's `permissions`, but I'm sure this will make our security team uneasy
+  anyway), OR this would mean any build needs human confirmation which means slow
+  feedback.
+- Use a `pull_request` for a regular fast-feedback build, and a separate
+  `pull_request_target` for the integ tests. This means we're building twice.
+
+Ultimately, our build isn't heavy enough to put in a lot of effort deduping
+it, so we'll go with the simplest solution which is the last one: 2
+independent workflows.
+
+projen doesn't make it easy to copy the relevant parts of the 'build' workflow,
+so they're unfortunately duplicated here.
+
+#### Initializers <a name="Initializers" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.Initializer"></a>
+
+```typescript
+import { CdkCliIntegTestsWorkflow } from 'cdklabs-projen-project-types'
+
+new CdkCliIntegTestsWorkflow(repo: NodeProject, props: CdkCliIntegTestsWorkflowProps)
+```
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.Initializer.parameter.repo">repo</a></code> | <code>projen.javascript.NodeProject</code> | *No description.* |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.Initializer.parameter.props">props</a></code> | <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps">CdkCliIntegTestsWorkflowProps</a></code> | *No description.* |
+
+---
+
+##### `repo`<sup>Required</sup> <a name="repo" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.Initializer.parameter.repo"></a>
+
+- *Type:* projen.javascript.NodeProject
+
+---
+
+##### `props`<sup>Required</sup> <a name="props" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.Initializer.parameter.props"></a>
+
+- *Type:* <a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps">CdkCliIntegTestsWorkflowProps</a>
+
+---
+
+#### Methods <a name="Methods" id="Methods"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.toString">toString</a></code> | Returns a string representation of this construct. |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.postSynthesize">postSynthesize</a></code> | Called after synthesis. |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.preSynthesize">preSynthesize</a></code> | Called before synthesis. |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.synthesize">synthesize</a></code> | Synthesizes files to the project output directory. |
+
+---
+
+##### `toString` <a name="toString" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.toString"></a>
+
+```typescript
+public toString(): string
+```
+
+Returns a string representation of this construct.
+
+##### `postSynthesize` <a name="postSynthesize" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.postSynthesize"></a>
+
+```typescript
+public postSynthesize(): void
+```
+
+Called after synthesis.
+
+Order is *not* guaranteed.
+
+##### `preSynthesize` <a name="preSynthesize" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.preSynthesize"></a>
+
+```typescript
+public preSynthesize(): void
+```
+
+Called before synthesis.
+
+##### `synthesize` <a name="synthesize" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.synthesize"></a>
+
+```typescript
+public synthesize(): void
+```
+
+Synthesizes files to the project output directory.
+
+#### Static Functions <a name="Static Functions" id="Static Functions"></a>
+
+| **Name** | **Description** |
+| --- | --- |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.isConstruct">isConstruct</a></code> | Checks if `x` is a construct. |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.isComponent">isComponent</a></code> | Test whether the given construct is a component. |
+
+---
+
+##### `isConstruct` <a name="isConstruct" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.isConstruct"></a>
+
+```typescript
+import { CdkCliIntegTestsWorkflow } from 'cdklabs-projen-project-types'
+
+CdkCliIntegTestsWorkflow.isConstruct(x: any)
+```
+
+Checks if `x` is a construct.
+
+Use this method instead of `instanceof` to properly detect `Construct`
+instances, even when the construct library is symlinked.
+
+Explanation: in JavaScript, multiple copies of the `constructs` library on
+disk are seen as independent, completely different libraries. As a
+consequence, the class `Construct` in each copy of the `constructs` library
+is seen as a different class, and an instance of one class will not test as
+`instanceof` the other class. `npm install` will not create installations
+like this, but users may manually symlink construct libraries together or
+use a monorepo tool: in those cases, multiple copies of the `constructs`
+library can be accidentally installed, and `instanceof` will behave
+unpredictably. It is safest to avoid using `instanceof`, and using
+this type-testing method instead.
+
+###### `x`<sup>Required</sup> <a name="x" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.isConstruct.parameter.x"></a>
+
+- *Type:* any
+
+Any object.
+
+---
+
+##### `isComponent` <a name="isComponent" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.isComponent"></a>
+
+```typescript
+import { CdkCliIntegTestsWorkflow } from 'cdklabs-projen-project-types'
+
+CdkCliIntegTestsWorkflow.isComponent(x: any)
+```
+
+Test whether the given construct is a component.
+
+###### `x`<sup>Required</sup> <a name="x" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.isComponent.parameter.x"></a>
+
+- *Type:* any
+
+---
+
+#### Properties <a name="Properties" id="Properties"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.property.node">node</a></code> | <code>constructs.Node</code> | The tree node. |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.property.project">project</a></code> | <code>projen.Project</code> | *No description.* |
+
+---
+
+##### `node`<sup>Required</sup> <a name="node" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.property.node"></a>
+
+```typescript
+public readonly node: Node;
+```
+
+- *Type:* constructs.Node
+
+The tree node.
+
+---
+
+##### `project`<sup>Required</sup> <a name="project" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflow.property.project"></a>
+
+```typescript
+public readonly project: Project;
+```
+
+- *Type:* projen.Project
+
+---
+
+
 ### CdkConstructLibrary <a name="CdkConstructLibrary" id="cdklabs-projen-project-types.CdkConstructLibrary"></a>
 
 Create a Cdk Construct Library Project.
@@ -14484,6 +14672,96 @@ public readonly version: Version;
 
 ## Structs <a name="Structs" id="Structs"></a>
 
+### CdkCliIntegTestsWorkflowProps <a name="CdkCliIntegTestsWorkflowProps" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps"></a>
+
+#### Initializer <a name="Initializer" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps.Initializer"></a>
+
+```typescript
+import { CdkCliIntegTestsWorkflowProps } from 'cdklabs-projen-project-types'
+
+const cdkCliIntegTestsWorkflowProps: CdkCliIntegTestsWorkflowProps = { ... }
+```
+
+#### Properties <a name="Properties" id="Properties"></a>
+
+| **Name** | **Type** | **Description** |
+| --- | --- | --- |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps.property.approvalEnvironment">approvalEnvironment</a></code> | <code>string</code> | GitHub environment name for approvals. |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps.property.buildRunsOn">buildRunsOn</a></code> | <code>string</code> | Runners for the workflow. |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps.property.localPackages">localPackages</a></code> | <code>string[]</code> | Packages that are locally transfered (we will never use the upstream versions). |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps.property.testEnvironment">testEnvironment</a></code> | <code>string</code> | GitHub environment name for running the tests. |
+| <code><a href="#cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps.property.testRunsOn">testRunsOn</a></code> | <code>string</code> | Runners for the workflow. |
+
+---
+
+##### `approvalEnvironment`<sup>Required</sup> <a name="approvalEnvironment" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps.property.approvalEnvironment"></a>
+
+```typescript
+public readonly approvalEnvironment: string;
+```
+
+- *Type:* string
+
+GitHub environment name for approvals.
+
+MUST be configured to require manual approval.
+
+---
+
+##### `buildRunsOn`<sup>Required</sup> <a name="buildRunsOn" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps.property.buildRunsOn"></a>
+
+```typescript
+public readonly buildRunsOn: string;
+```
+
+- *Type:* string
+
+Runners for the workflow.
+
+---
+
+##### `localPackages`<sup>Required</sup> <a name="localPackages" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps.property.localPackages"></a>
+
+```typescript
+public readonly localPackages: string[];
+```
+
+- *Type:* string[]
+
+Packages that are locally transfered (we will never use the upstream versions).
+
+---
+
+##### `testEnvironment`<sup>Required</sup> <a name="testEnvironment" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps.property.testEnvironment"></a>
+
+```typescript
+public readonly testEnvironment: string;
+```
+
+- *Type:* string
+
+GitHub environment name for running the tests.
+
+MUST be configured without approvals, and with the following vars and secrets:
+
+- vars: AWS_ROLE_TO_ASSUME_FOR_TESTING
+
+And the role needs to be configured to allow the AssumeRole operation.
+
+---
+
+##### `testRunsOn`<sup>Required</sup> <a name="testRunsOn" id="cdklabs-projen-project-types.CdkCliIntegTestsWorkflowProps.property.testRunsOn"></a>
+
+```typescript
+public readonly testRunsOn: string;
+```
+
+- *Type:* string
+
+Runners for the workflow.
+
+---
+
 ### CdkCommonOptions <a name="CdkCommonOptions" id="cdklabs-projen-project-types.CdkCommonOptions"></a>
 
 CdkCommonOptions.

package/lib/cdk-cli-integ-tests.d.ts

@@ -0,0 +1,60 @@
+import { Component, javascript } from 'projen';
+export interface CdkCliIntegTestsWorkflowProps {
+    /**
+     * Runners for the workflow
+     */
+    readonly buildRunsOn: string;
+    /**
+     * Runners for the workflow
+     */
+    readonly testRunsOn: string;
+    /**
+     * GitHub environment name for approvals
+     *
+     * MUST be configured to require manual approval.
+     */
+    readonly approvalEnvironment: string;
+    /**
+     * GitHub environment name for running the tests
+     *
+     * MUST be configured without approvals, and with the following vars and secrets:
+     *
+     * - vars: AWS_ROLE_TO_ASSUME_FOR_TESTING
+     *
+     * And the role needs to be configured to allow the AssumeRole operation.
+     */
+    readonly testEnvironment: string;
+    /**
+     * Packages that are locally transfered (we will never use the upstream versions)
+     */
+    readonly localPackages: string[];
+}
+/**
+ * Add a workflow for running the tests
+ *
+ * This MUST be a separate workflow that runs in privileged context. We have a couple
+ * of options:
+ *
+ * - `workflow_run`: we can trigger a privileged workflow run after the unprivileged
+ *   `pull_request` workflow finishes and reuse its output artifacts. The
+ *   problem is that the second run is disconnected from the PR so we would need
+ *   to script in visibility for approvals and success (by posting comments, for
+ *   example)
+ * - Use only a `pull_request_target` workflow on the PR: this either would run
+ *   a privileged workflow on any user code submission (might be fine given the
+ *   workflow's `permissions`, but I'm sure this will make our security team uneasy
+ *   anyway), OR this would mean any build needs human confirmation which means slow
+ *   feedback.
+ * - Use a `pull_request` for a regular fast-feedback build, and a separate
+ *   `pull_request_target` for the integ tests. This means we're building twice.
+ *
+ * Ultimately, our build isn't heavy enough to put in a lot of effort deduping
+ * it, so we'll go with the simplest solution which is the last one: 2
+ * independent workflows.
+ *
+ * projen doesn't make it easy to copy the relevant parts of the 'build' workflow,
+ * so they're unfortunately duplicated here.
+ */
+export declare class CdkCliIntegTestsWorkflow extends Component {
+    constructor(repo: javascript.NodeProject, props: CdkCliIntegTestsWorkflowProps);
+}

package/lib/cdk-cli-integ-tests.js

@@ -0,0 +1,272 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdkCliIntegTestsWorkflow = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+/**
+ * Add a workflow for running the tests
+ *
+ * This MUST be a separate workflow that runs in privileged context. We have a couple
+ * of options:
+ *
+ * - `workflow_run`: we can trigger a privileged workflow run after the unprivileged
+ *   `pull_request` workflow finishes and reuse its output artifacts. The
+ *   problem is that the second run is disconnected from the PR so we would need
+ *   to script in visibility for approvals and success (by posting comments, for
+ *   example)
+ * - Use only a `pull_request_target` workflow on the PR: this either would run
+ *   a privileged workflow on any user code submission (might be fine given the
+ *   workflow's `permissions`, but I'm sure this will make our security team uneasy
+ *   anyway), OR this would mean any build needs human confirmation which means slow
+ *   feedback.
+ * - Use a `pull_request` for a regular fast-feedback build, and a separate
+ *   `pull_request_target` for the integ tests. This means we're building twice.
+ *
+ * Ultimately, our build isn't heavy enough to put in a lot of effort deduping
+ * it, so we'll go with the simplest solution which is the last one: 2
+ * independent workflows.
+ *
+ * projen doesn't make it easy to copy the relevant parts of the 'build' workflow,
+ * so they're unfortunately duplicated here.
+ */
+class CdkCliIntegTestsWorkflow extends projen_1.Component {
+    constructor(repo, props) {
+        super(repo);
+        const buildWorkflow = repo.buildWorkflow;
+        const runTestsWorkflow = repo.github?.addWorkflow('build-and-integ');
+        if (!buildWorkflow || !runTestsWorkflow) {
+            throw new Error('Expected build and run tests workflow');
+        }
+        buildWorkflow.workflow;
+        runTestsWorkflow.on({
+            pullRequestTarget: {
+                branches: ['main'],
+            },
+        });
+        // The 'build' part runs on the 'integ-approval' environment, which requires
+        // approval. The actual runs access the real environment, not requiring approval
+        // anymore.
+        //
+        // This is for 2 reasons:
+        // - The build job is the first one that runs. That means you get asked approval
+        //   immediately after push, instead of 5 minutes later after the build completes.
+        // - The build job is only one job, versus the tests which are a matrix build.
+        //   If the matrix test job needs approval, the Pull Request timeline gets spammed
+        //   with an approval request for every individual run.
+        runTestsWorkflow.addJob('build', {
+            environment: props.approvalEnvironment,
+            runsOn: [props.buildRunsOn],
+            permissions: {
+                contents: projen_1.github.workflows.JobPermission.READ,
+            },
+            env: {
+                CI: 'true',
+            },
+            steps: [
+                {
+                    name: 'Checkout',
+                    uses: 'actions/checkout@v4',
+                    with: {
+                        // IMPORTANT! This must be `head.sha` not `head.ref`, otherwise we
+                        // are vulnerable to a TOCTOU attack.
+                        ref: '${{ github.event.pull_request.head.sha }}',
+                        repository: '${{ github.event.pull_request.head.repo.full_name }}',
+                    },
+                },
+                {
+                    name: 'Setup Node.js',
+                    uses: 'actions/setup-node@v4',
+                    with: {
+                        'node-version': 'lts/*',
+                    },
+                },
+                {
+                    name: 'Install dependencies',
+                    run: 'yarn install --check-files',
+                },
+                {
+                    name: 'build',
+                    run: 'npx projen build',
+                },
+                {
+                    name: 'Upload artifact',
+                    uses: 'actions/upload-artifact@v4.4.0',
+                    with: {
+                        name: 'build-artifact',
+                        path: 'packages/**/dist/js/*.tgz',
+                        overwrite: 'true',
+                    },
+                },
+            ],
+        });
+        const verdaccioConfig = {
+            storage: './storage',
+            auth: { htpasswd: { file: './htpasswd' } },
+            uplinks: { npmjs: { url: 'https://registry.npmjs.org/' } },
+            packages: {},
+        };
+        for (const pack of props.localPackages) {
+            verdaccioConfig.packages[pack] = {
+                access: '$all',
+                publish: '$all',
+                proxy: 'none',
+            };
+        }
+        ;
+        verdaccioConfig.packages['**'] = {
+            access: '$all',
+            proxy: 'npmjs',
+        };
+        runTestsWorkflow.addJob('integ', {
+            environment: props.testEnvironment,
+            runsOn: [props.testRunsOn],
+            needs: ['build'],
+            permissions: {
+                contents: projen_1.github.workflows.JobPermission.READ,
+                idToken: projen_1.github.workflows.JobPermission.WRITE,
+            },
+            env: {
+                // Otherwise Maven is too noisy
+                MAVEN_ARGS: '--no-transfer-progress',
+                // This is not actually a canary, but this prevents the tests from making
+                // assumptions about the availability of source packages.
+                IS_CANARY: 'true',
+                CI: 'true',
+            },
+            strategy: {
+                failFast: false,
+                matrix: {
+                    domain: {
+                        suite: [
+                            'cli-integ-tests',
+                            'init-csharp',
+                            'init-fsharp',
+                            'init-go',
+                            'init-java',
+                            'init-javascript',
+                            'init-python',
+                            'init-typescript-app',
+                            'init-typescript-lib',
+                            'tool-integrations',
+                        ],
+                    },
+                },
+            },
+            steps: [
+                {
+                    name: 'Download build artifacts',
+                    uses: 'actions/download-artifact@v4',
+                    with: {
+                        name: 'build-artifact',
+                        path: 'packages',
+                    },
+                },
+                {
+                    name: 'Set up JDK 18',
+                    if: 'matrix.suite == \'init-java\' || matrix.suite == \'cli-integ-tests\'',
+                    uses: 'actions/setup-java@v4',
+                    with: {
+                        'java-version': '18',
+                        'distribution': 'corretto',
+                    },
+                },
+                {
+                    name: 'Authenticate Via OIDC Role',
+                    id: 'creds',
+                    uses: 'aws-actions/configure-aws-credentials@v4',
+                    with: {
+                        'aws-region': 'us-east-1',
+                        'role-duration-seconds': 4 * 60 * 60,
+                        // Expect this in Environment Variables
+                        'role-to-assume': '${{ vars.AWS_ROLE_TO_ASSUME_FOR_TESTING }}',
+                        'role-session-name': 'run-tests@aws-cdk-cli-integ',
+                        'output-credentials': true,
+                    },
+                },
+                // This is necessary for the init tests to succeed, they set up a git repo.
+                {
+                    name: 'Set git identity',
+                    run: [
+                        'git config --global user.name "aws-cdk-cli-integ"',
+                        'git config --global user.email "noreply@example.com"',
+                    ].join('\n'),
+                },
+                {
+                    name: 'Install Verdaccio',
+                    run: 'npm install -g verdaccio pm2',
+                },
+                {
+                    name: 'Create Verdaccio config',
+                    run: [
+                        'mkdir -p $HOME/.config/verdaccio',
+                        `echo '${JSON.stringify(verdaccioConfig)}' > $HOME/.config/verdaccio/config.yaml`,
+                    ].join('\n'),
+                },
+                {
+                    name: 'Start Verdaccio',
+                    run: [
+                        'pm2 start verdaccio -- --config $HOME/.config/verdaccio/config.yaml',
+                        'sleep 5 # Wait for Verdaccio to start',
+                    ].join('\n'),
+                },
+                {
+                    name: 'Configure npm to use local registry',
+                    run: [
+                        // This token is a bogus token. It doesn't represent any actual secret, it just needs to exist.
+                        'echo \'//localhost:4873/:_authToken="MWRjNDU3OTE1NTljYWUyOTFkMWJkOGUyYTIwZWMwNTI6YTgwZjkyNDE0NzgwYWQzNQ=="\' > ~/.npmrc',
+                        'echo \'registry=http://localhost:4873/\' >> ~/.npmrc',
+                    ].join('\n'),
+                },
+                {
+                    name: 'Find an locally publish all tarballs',
+                    run: 'find packages -name \\*.tgz -print0 | xargs -0 -n1 npm publish',
+                },
+                {
+                    name: 'Download and install the test artifact',
+                    run: [
+                        'npm install @aws-cdk-testing/cli-integ',
+                        // Move the installed files to the current directory, because as
+                        // currently configured the tests won't run from an installed
+                        // node_modules directory.
+                        'mv ./node_modules/@aws-cdk-testing/cli-integ/* .',
+                    ].join('\n'),
+                },
+                {
+                    name: 'Determine latest package versions',
+                    id: 'versions',
+                    run: [
+                        'CLI_VERSION=$(cd ${TMPDIR:-/tmp} && npm view aws-cdk version)',
+                        'echo "CLI version: ${CLI_VERSION}"',
+                        'echo "cli_version=${CLI_VERSION}" >> $GITHUB_OUTPUT',
+                        'LIB_VERSION=$(cd ${TMPDIR:-/tmp} && npm view aws-cdk-lib version)',
+                        'echo "lib version: ${LIB_VERSION}"',
+                        'echo "lib_version=${LIB_VERSION}" >> $GITHUB_OUTPUT',
+                    ].join('\n'),
+                },
+                {
+                    name: 'Run the test suite: ${{ matrix.suite }}',
+                    run: [
+                        'bin/run-suite --use-cli-release=${{ steps.versions.outputs.cli_version }} --framework-version=${{ steps.versions.outputs.lib_version }} ${{ matrix.suite }}',
+                    ].join('\n'),
+                    env: {
+                        // Concurrency only for long-running cli-integ-tests
+                        JEST_TEST_CONCURRENT: "${{ matrix.suite == 'cli-integ-tests' && 'true' || 'false' }}",
+                        JSII_SILENCE_WARNING_DEPRECATED_NODE_VERSION: 'true',
+                        JSII_SILENCE_WARNING_UNTESTED_NODE_VERSION: 'true',
+                        JSII_SILENCE_WARNING_KNOWN_BROKEN_NODE_VERSION: 'true',
+                        DOCKERHUB_DISABLED: 'true',
+                        AWS_REGIONS: ['us-east-2', 'eu-west-1', 'eu-north-1', 'ap-northeast-1', 'ap-south-1'].join(','),
+                        CDK_MAJOR_VERSION: '2',
+                        RELEASE_TAG: 'latest',
+                        GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',
+                    },
+                },
+            ],
+        });
+    }
+}
+exports.CdkCliIntegTestsWorkflow = CdkCliIntegTestsWorkflow;
+_a = JSII_RTTI_SYMBOL_1;
+CdkCliIntegTestsWorkflow[_a] = { fqn: "cdklabs-projen-project-types.CdkCliIntegTestsWorkflow", version: "0.1.219" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk-cli-integ-tests.js","sourceRoot":"","sources":["../src/cdk-cli-integ-tests.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, github, javascript } from 'projen';\n\nexport interface CdkCliIntegTestsWorkflowProps {\n  /**\n   * Runners for the workflow\n   */\n  readonly buildRunsOn: string;\n\n  /**\n   * Runners for the workflow\n   */\n  readonly testRunsOn: string;\n\n  /**\n   * GitHub environment name for approvals\n   *\n   * MUST be configured to require manual approval.\n   */\n  readonly approvalEnvironment: string;\n\n  /**\n   * GitHub environment name for running the tests\n   *\n   * MUST be configured without approvals, and with the following vars and secrets:\n   *\n   * - vars: AWS_ROLE_TO_ASSUME_FOR_TESTING\n   *\n   * And the role needs to be configured to allow the AssumeRole operation.\n   */\n  readonly testEnvironment: string;\n\n  /**\n   * Packages that are locally transfered (we will never use the upstream versions)\n   */\n  readonly localPackages: string[];\n}\n\n/**\n * Add a workflow for running the tests\n *\n * This MUST be a separate workflow that runs in privileged context. We have a couple\n * of options:\n *\n * - `workflow_run`: we can trigger a privileged workflow run after the unprivileged\n *   `pull_request` workflow finishes and reuse its output artifacts. The\n *   problem is that the second run is disconnected from the PR so we would need\n *   to script in visibility for approvals and success (by posting comments, for\n *   example)\n * - Use only a `pull_request_target` workflow on the PR: this either would run\n *   a privileged workflow on any user code submission (might be fine given the\n *   workflow's `permissions`, but I'm sure this will make our security team uneasy\n *   anyway), OR this would mean any build needs human confirmation which means slow\n *   feedback.\n * - Use a `pull_request` for a regular fast-feedback build, and a separate\n *   `pull_request_target` for the integ tests. This means we're building twice.\n *\n * Ultimately, our build isn't heavy enough to put in a lot of effort deduping\n * it, so we'll go with the simplest solution which is the last one: 2\n * independent workflows.\n *\n * projen doesn't make it easy to copy the relevant parts of the 'build' workflow,\n * so they're unfortunately duplicated here.\n */\nexport class CdkCliIntegTestsWorkflow extends Component {\n  constructor(repo: javascript.NodeProject, props: CdkCliIntegTestsWorkflowProps) {\n    super(repo);\n\n    const buildWorkflow = repo.buildWorkflow;\n    const runTestsWorkflow = repo.github?.addWorkflow('build-and-integ');\n    if (!buildWorkflow || !runTestsWorkflow) {\n      throw new Error('Expected build and run tests workflow');\n    }\n    ((buildWorkflow as any).workflow as github.GithubWorkflow);\n\n    runTestsWorkflow.on({\n      pullRequestTarget: {\n        branches: ['main'],\n      },\n    });\n    // The 'build' part runs on the 'integ-approval' environment, which requires\n    // approval. The actual runs access the real environment, not requiring approval\n    // anymore.\n    //\n    // This is for 2 reasons:\n    // - The build job is the first one that runs. That means you get asked approval\n    //   immediately after push, instead of 5 minutes later after the build completes.\n    // - The build job is only one job, versus the tests which are a matrix build.\n    //   If the matrix test job needs approval, the Pull Request timeline gets spammed\n    //   with an approval request for every individual run.\n    runTestsWorkflow.addJob('build', {\n      environment: props.approvalEnvironment,\n      runsOn: [props.buildRunsOn],\n      permissions: {\n        contents: github.workflows.JobPermission.READ,\n      },\n      env: {\n        CI: 'true',\n      },\n      steps: [\n        {\n          name: 'Checkout',\n          uses: 'actions/checkout@v4',\n          with: {\n            // IMPORTANT! This must be `head.sha` not `head.ref`, otherwise we\n            // are vulnerable to a TOCTOU attack.\n            ref: '${{ github.event.pull_request.head.sha }}',\n            repository: '${{ github.event.pull_request.head.repo.full_name }}',\n          },\n        },\n        {\n          name: 'Setup Node.js',\n          uses: 'actions/setup-node@v4',\n          with: {\n            'node-version': 'lts/*',\n          },\n        },\n        {\n          name: 'Install dependencies',\n          run: 'yarn install --check-files',\n        },\n        {\n          name: 'build',\n          run: 'npx projen build',\n        },\n        {\n          name: 'Upload artifact',\n          uses: 'actions/upload-artifact@v4.4.0',\n          with: {\n            name: 'build-artifact',\n            path: 'packages/**/dist/js/*.tgz',\n            overwrite: 'true',\n          },\n        },\n      ],\n    });\n\n    const verdaccioConfig = {\n      storage: './storage',\n      auth: { htpasswd: { file: './htpasswd' } },\n      uplinks: { npmjs: { url: 'https://registry.npmjs.org/' } },\n      packages: {} as Record<string, unknown>,\n    };\n\n    for (const pack of props.localPackages) {\n      verdaccioConfig.packages[pack] = {\n        access: '$all',\n        publish: '$all',\n        proxy: 'none',\n      };\n    };\n    verdaccioConfig.packages['**'] = {\n      access: '$all',\n      proxy: 'npmjs',\n    };\n\n    runTestsWorkflow.addJob('integ', {\n      environment: props.testEnvironment,\n      runsOn: [props.testRunsOn],\n      needs: ['build'],\n      permissions: {\n        contents: github.workflows.JobPermission.READ,\n        idToken: github.workflows.JobPermission.WRITE,\n      },\n      env: {\n        // Otherwise Maven is too noisy\n        MAVEN_ARGS: '--no-transfer-progress',\n        // This is not actually a canary, but this prevents the tests from making\n        // assumptions about the availability of source packages.\n        IS_CANARY: 'true',\n        CI: 'true',\n      },\n      strategy: {\n        failFast: false,\n        matrix: {\n          domain: {\n            suite: [\n              'cli-integ-tests',\n              'init-csharp',\n              'init-fsharp',\n              'init-go',\n              'init-java',\n              'init-javascript',\n              'init-python',\n              'init-typescript-app',\n              'init-typescript-lib',\n              'tool-integrations',\n            ],\n          },\n        },\n      },\n      steps: [\n        {\n          name: 'Download build artifacts',\n          uses: 'actions/download-artifact@v4',\n          with: {\n            name: 'build-artifact',\n            path: 'packages',\n          },\n        },\n        {\n          name: 'Set up JDK 18',\n          if: 'matrix.suite == \\'init-java\\' || matrix.suite == \\'cli-integ-tests\\'',\n          uses: 'actions/setup-java@v4',\n          with: {\n            'java-version': '18',\n            'distribution': 'corretto',\n          },\n        },\n        {\n          name: 'Authenticate Via OIDC Role',\n          id: 'creds',\n          uses: 'aws-actions/configure-aws-credentials@v4',\n          with: {\n            'aws-region': 'us-east-1',\n            'role-duration-seconds': 4 * 60 * 60,\n            // Expect this in Environment Variables\n            'role-to-assume': '${{ vars.AWS_ROLE_TO_ASSUME_FOR_TESTING }}',\n            'role-session-name': 'run-tests@aws-cdk-cli-integ',\n            'output-credentials': true,\n          },\n        },\n        // This is necessary for the init tests to succeed, they set up a git repo.\n        {\n          name: 'Set git identity',\n          run: [\n            'git config --global user.name \"aws-cdk-cli-integ\"',\n            'git config --global user.email \"noreply@example.com\"',\n          ].join('\\n'),\n        },\n        {\n          name: 'Install Verdaccio',\n          run: 'npm install -g verdaccio pm2',\n        },\n        {\n          name: 'Create Verdaccio config',\n          run: [\n            'mkdir -p $HOME/.config/verdaccio',\n            `echo '${JSON.stringify(verdaccioConfig)}' > $HOME/.config/verdaccio/config.yaml`,\n          ].join('\\n'),\n        },\n        {\n          name: 'Start Verdaccio',\n          run: [\n            'pm2 start verdaccio -- --config $HOME/.config/verdaccio/config.yaml',\n            'sleep 5 # Wait for Verdaccio to start',\n          ].join('\\n'),\n        },\n        {\n          name: 'Configure npm to use local registry',\n          run: [\n            // This token is a bogus token. It doesn't represent any actual secret, it just needs to exist.\n            'echo \\'//localhost:4873/:_authToken=\"MWRjNDU3OTE1NTljYWUyOTFkMWJkOGUyYTIwZWMwNTI6YTgwZjkyNDE0NzgwYWQzNQ==\"\\' > ~/.npmrc',\n            'echo \\'registry=http://localhost:4873/\\' >> ~/.npmrc',\n          ].join('\\n'),\n        },\n        {\n          name: 'Find an locally publish all tarballs',\n          run: 'find packages -name \\\\*.tgz -print0 | xargs -0 -n1 npm publish',\n        },\n        {\n          name: 'Download and install the test artifact',\n          run: [\n            'npm install @aws-cdk-testing/cli-integ',\n            // Move the installed files to the current directory, because as\n            // currently configured the tests won't run from an installed\n            // node_modules directory.\n            'mv ./node_modules/@aws-cdk-testing/cli-integ/* .',\n          ].join('\\n'),\n        },\n        {\n          name: 'Determine latest package versions',\n          id: 'versions',\n          run: [\n            'CLI_VERSION=$(cd ${TMPDIR:-/tmp} && npm view aws-cdk version)',\n            'echo \"CLI version: ${CLI_VERSION}\"',\n            'echo \"cli_version=${CLI_VERSION}\" >> $GITHUB_OUTPUT',\n            'LIB_VERSION=$(cd ${TMPDIR:-/tmp} && npm view aws-cdk-lib version)',\n            'echo \"lib version: ${LIB_VERSION}\"',\n            'echo \"lib_version=${LIB_VERSION}\" >> $GITHUB_OUTPUT',\n          ].join('\\n'),\n        },\n        {\n          name: 'Run the test suite: ${{ matrix.suite }}',\n          run: [\n            'bin/run-suite --use-cli-release=${{ steps.versions.outputs.cli_version }} --framework-version=${{ steps.versions.outputs.lib_version }} ${{ matrix.suite }}',\n          ].join('\\n'),\n          env: {\n            // Concurrency only for long-running cli-integ-tests\n            JEST_TEST_CONCURRENT: \"${{ matrix.suite == 'cli-integ-tests' && 'true' || 'false' }}\",\n            JSII_SILENCE_WARNING_DEPRECATED_NODE_VERSION: 'true',\n            JSII_SILENCE_WARNING_UNTESTED_NODE_VERSION: 'true',\n            JSII_SILENCE_WARNING_KNOWN_BROKEN_NODE_VERSION: 'true',\n            DOCKERHUB_DISABLED: 'true',\n            AWS_REGIONS: ['us-east-2', 'eu-west-1', 'eu-north-1', 'ap-northeast-1', 'ap-south-1'].join(','),\n            CDK_MAJOR_VERSION: '2',\n            RELEASE_TAG: 'latest',\n            GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n          },\n        },\n      ],\n    });\n  }\n}\n"]}

package/lib/cdk.js

@@ -55,7 +55,7 @@ class CdkConstructLibrary extends projen_1.awscdk.AwsCdkConstructLibrary {
 }
 exports.CdkConstructLibrary = CdkConstructLibrary;
 _a = JSII_RTTI_SYMBOL_1;
-CdkConstructLibrary[_a] = { fqn: "cdklabs-projen-project-types.CdkConstructLibrary", version: "0.1.217" };
+CdkConstructLibrary[_a] = { fqn: "cdklabs-projen-project-types.CdkConstructLibrary", version: "0.1.219" };
 /**
  * Create a Cdk TypeScript Project
  *
@@ -71,5 +71,5 @@ class CdkTypeScriptProject extends projen_1.typescript.TypeScriptProject {
 }
 exports.CdkTypeScriptProject = CdkTypeScriptProject;
 _b = JSII_RTTI_SYMBOL_1;
-CdkTypeScriptProject[_b] = { fqn: "cdklabs-projen-project-types.CdkTypeScriptProject", version: "0.1.217" };
+CdkTypeScriptProject[_b] = { fqn: "cdklabs-projen-project-types.CdkTypeScriptProject", version: "0.1.219" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/cdklabs.js

@@ -120,7 +120,7 @@ class CdklabsConstructLibrary extends cdk_1.CdkConstructLibrary {
 }
 exports.CdklabsConstructLibrary = CdklabsConstructLibrary;
 _a = JSII_RTTI_SYMBOL_1;
-CdklabsConstructLibrary[_a] = { fqn: "cdklabs-projen-project-types.CdklabsConstructLibrary", version: "0.1.217" };
+CdklabsConstructLibrary[_a] = { fqn: "cdklabs-projen-project-types.CdklabsConstructLibrary", version: "0.1.219" };
 /**
  * Create a Cdklabs TypeScript Project
  *
@@ -140,7 +140,7 @@ class CdklabsTypeScriptProject extends cdk_1.CdkTypeScriptProject {
 }
 exports.CdklabsTypeScriptProject = CdklabsTypeScriptProject;
 _b = JSII_RTTI_SYMBOL_1;
-CdklabsTypeScriptProject[_b] = { fqn: "cdklabs-projen-project-types.CdklabsTypeScriptProject", version: "0.1.217" };
+CdklabsTypeScriptProject[_b] = { fqn: "cdklabs-projen-project-types.CdklabsTypeScriptProject", version: "0.1.219" };
 /**
  * Create a Cdklabs Jsii Project
  *
@@ -163,5 +163,5 @@ class CdklabsJsiiProject extends jsii_1.CdkJsiiProject {
 }
 exports.CdklabsJsiiProject = CdklabsJsiiProject;
 _c = JSII_RTTI_SYMBOL_1;
-CdklabsJsiiProject[_c] = { fqn: "cdklabs-projen-project-types.CdklabsJsiiProject", version: "0.1.217" };
+CdklabsJsiiProject[_c] = { fqn: "cdklabs-projen-project-types.CdklabsJsiiProject", version: "0.1.219" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdklabs.js","sourceRoot":"","sources":["../src/cdklabs.ts"],"names":[],"mappings":"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","sourcesContent":["import { basename } from 'path';\nimport { UpdateSnapshot } from 'projen/lib/javascript';\nimport { deepMerge } from 'projen/lib/util';\n\nexport enum JsiiLanguage {\n  PYTHON,\n  JAVA,\n  DOTNET,\n  GO,\n};\n\nimport {\n  CdkConstructLibrary,\n  CdkTypeScriptProject,\n  CdkTypeScriptProjectOptions,\n} from './cdk';\nimport { CdkConstructLibraryOptions } from './cdk-construct-library-options';\nimport { CdkJsiiProjectOptions } from './cdk-jsii-options';\nimport { CdkJsiiProject } from './jsii';\n// eslint-disable-next-line import/order\nimport { ReleasableCommits } from 'projen';\n\n// override these properties no matter what values are given client-side\nconst cdklabsForcedProps = {\n  author: 'Amazon Web Services',\n  authorName: 'Amazon Web Services',\n  authorAddress: 'aws-cdk-dev@amazon.com',\n  authorEmail: 'aws-cdk-dev@amazon.com',\n  authorOrganization: true,\n};\n\nconst cdklabsDefaultProps: Partial<CdklabsConstructLibraryOptions> = {\n  autoApproveUpgrades: true,\n  minNodeVersion: '18.12.0',\n  workflowNodeVersion: 'lts/*',\n  jestOptions: {\n    updateSnapshot: UpdateSnapshot.ALWAYS,\n  },\n  defaultReleaseBranch: 'main',\n  // Default is to release only features and fixes. If we don't do this, every projen\n  // project will basically release every day, because it will see devDependencies updates\n  // every day, even though those are not interesting.\n  releasableCommits: ReleasableCommits.featuresAndFixes(),\n  jsiiVersion: '~5.7',\n};\n\nfunction createCdklabsPublishingDefaults(npmPackageName: string, langs?: JsiiLanguage[]) {\n  const packageBasename = basename(npmPackageName);\n\n  return createPublishingDefaults('cdklabs', packageBasename, Boolean(packageBasename !== npmPackageName), langs);\n};\n\nfunction createPublishingDefaults(namespace: string, packageBasename: string, alwaysUseNamespace = true, langs?: JsiiLanguage[]) {\n  const piPyPrefix = alwaysUseNamespace ? `${namespace}.` : '';\n  const nugetPrefix = alwaysUseNamespace ? `${upperCaseName(namespace)}.` : `${upperCaseName(namespace)}`;\n\n  return {\n    ...publishLanguageWrapper(JsiiLanguage.PYTHON, {\n      publishToPypi: {\n        distName: `${piPyPrefix}${packageBasename}`,\n        module: `${piPyPrefix}${changeDelimiter(packageBasename, '_')}`,\n      },\n    }),\n    ...publishLanguageWrapper(JsiiLanguage.JAVA, {\n      publishToMaven: {\n        javaPackage: `io.github.${namespace}.${changeDelimiter(packageBasename, '.')}`,\n        mavenGroupId: `io.github.${namespace}`,\n        mavenArtifactId: packageBasename,\n        mavenEndpoint: 'https://s01.oss.sonatype.org',\n      },\n    }),\n    ...publishLanguageWrapper(JsiiLanguage.DOTNET, {\n      publishToNuget: {\n        dotNetNamespace: `${nugetPrefix}${upperCaseName(packageBasename)}`,\n        packageId: `${nugetPrefix}${upperCaseName(packageBasename)}`,\n      },\n    }),\n    ...publishLanguageWrapper(JsiiLanguage.GO, {\n      publishToGo: {\n        moduleName: `github.com/${namespace}/${packageBasename}-go`,\n      },\n    }),\n  };\n\n  function publishLanguageWrapper(lang: JsiiLanguage, obj: Record<string, any>) {\n    return publishLanguage(lang) ? obj : {};\n  }\n\n  function publishLanguage(lang: JsiiLanguage): boolean {\n    // langs not specified === all languages published\n    if (!langs) { return true; }\n    if (langs.includes(lang)) { return true; }\n    return false;\n  }\n\n  function upperCaseName(str: string) {\n    let words = str.split('-');\n    words = words.map((w) => w[0].toUpperCase() + w.substring(1));\n    return words.join('');\n  }\n\n  function changeDelimiter(str: string, delim: string) {\n    return str.split('-').join(delim);\n  }\n};\n\nexport interface CdklabsPublishingProjectOptions {\n  /**\n   * Set default publishing properties. Setting this property guarantees\n   * that your project will have reasonable publishing names. You can choose\n   * to modify them however you wish with the traditional `publishToPypi`,\n   * `publishToMaven`, `publishToNuget`, and `publishToGo` properties, and\n   * your configuration will be respected.\n   *\n   * This should be set to false only if you do not plan on releasing the package.\n   *\n   * @default true\n   */\n  readonly cdklabsPublishingDefaults?: boolean;\n\n  /**\n   * Specify specific languages to publish to. This can be used when the library\n   * is experimental only, because stable libraries must publish to all jsii languages.\n   * This should be used in conjunction with `cdklabsPublishingDefaults: true`; otherwise\n   * it is a no-op.\n   *\n   * @default - all jsii target languages\n   */\n  readonly jsiiTargetLanguages?: JsiiLanguage[];\n}\n\nexport interface CdklabsConstructLibraryOptions extends CdkConstructLibraryOptions, CdklabsPublishingProjectOptions { }\n\n/**\n * Create a Cdklabs Construct Library Project\n *\n * @pjid cdklabs-construct-lib\n */\nexport class CdklabsConstructLibrary extends CdkConstructLibrary {\n  constructor(options: CdklabsConstructLibraryOptions) {\n    const cdklabsPublishingDefaultProps: Record<string, any> = (options.cdklabsPublishingDefaults ?? true) ?\n      createCdklabsPublishingDefaults(options.name, options.jsiiTargetLanguages) : {};\n\n    // the leftmost object is mutated and returned by deepMerge\n    const mergedOptions = deepMerge([\n      {},\n      cdklabsDefaultProps,\n      cdklabsPublishingDefaultProps,\n      options,\n      cdklabsForcedProps,\n    ]) as CdkConstructLibraryOptions;\n\n    super(mergedOptions);\n  }\n}\n\nexport interface CdklabsTypeScriptProjectOptions extends CdkTypeScriptProjectOptions { }\n\n/**\n * Create a Cdklabs TypeScript Project\n *\n * @pjid cdklabs-ts-proj\n */\nexport class CdklabsTypeScriptProject extends CdkTypeScriptProject {\n  constructor(options: CdklabsTypeScriptProjectOptions) {\n    // the leftmost object is mutated and returned by deepMerge\n    const mergedOptions = deepMerge([\n      {},\n      cdklabsDefaultProps,\n      options,\n      cdklabsForcedProps,\n    ]) as CdkConstructLibraryOptions;\n\n    super(mergedOptions);\n  }\n}\n\nexport interface CdklabsJsiiProjectOptions extends CdkJsiiProjectOptions, CdklabsPublishingProjectOptions { }\n\n/**\n * Create a Cdklabs Jsii Project\n *\n * @pjid cdklabs-jsii-proj\n */\nexport class CdklabsJsiiProject extends CdkJsiiProject {\n  constructor(options: CdklabsJsiiProjectOptions) {\n    const cdklabsPublishingDefaultProps: Record<string, any> = (options.cdklabsPublishingDefaults ?? true) ?\n      createCdklabsPublishingDefaults(options.name, options.jsiiTargetLanguages) : {};\n    // the leftmost object is mutated and returned by deepMerge\n    const mergedOptions = deepMerge([\n      {},\n      cdklabsDefaultProps,\n      cdklabsPublishingDefaultProps,\n      options,\n      cdklabsForcedProps,\n    ]) as CdklabsJsiiProjectOptions;\n\n    super(mergedOptions);\n  }\n}\n"]}

package/lib/index.d.ts

@@ -6,4 +6,5 @@ export * from './common-options';
 export * from './jsii';
 export * from './cdklabs';
 export * from './rosetta';
+export * from './cdk-cli-integ-tests';
 export * as yarn from './yarn';

package/lib/index.js

@@ -23,5 +23,6 @@ __exportStar(require("./common-options"), exports);
 __exportStar(require("./jsii"), exports);
 __exportStar(require("./cdklabs"), exports);
 __exportStar(require("./rosetta"), exports);
+__exportStar(require("./cdk-cli-integ-tests"), exports);
 exports.yarn = require("./yarn");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx3Q0FBc0I7QUFDdEIsdURBQXFDO0FBQ3JDLGtFQUFnRDtBQUNoRCxxREFBbUM7QUFDbkMsbURBQWlDO0FBQ2pDLHlDQUF1QjtBQUN2Qiw0Q0FBMEI7QUFDMUIsNENBQTBCO0FBRTFCLGlDQUErQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2RrJztcbmV4cG9ydCAqIGZyb20gJy4vY2RrLWNvbW1vbi1vcHRpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vY2RrLWNvbnN0cnVjdC1saWJyYXJ5LW9wdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9jZGstanNpaS1vcHRpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vY29tbW9uLW9wdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9qc2lpJztcbmV4cG9ydCAqIGZyb20gJy4vY2RrbGFicyc7XG5leHBvcnQgKiBmcm9tICcuL3Jvc2V0dGEnO1xuXG5leHBvcnQgKiBhcyB5YXJuIGZyb20gJy4veWFybic7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx3Q0FBc0I7QUFDdEIsdURBQXFDO0FBQ3JDLGtFQUFnRDtBQUNoRCxxREFBbUM7QUFDbkMsbURBQWlDO0FBQ2pDLHlDQUF1QjtBQUN2Qiw0Q0FBMEI7QUFDMUIsNENBQTBCO0FBQzFCLHdEQUFzQztBQUV0QyxpQ0FBK0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Nkayc7XG5leHBvcnQgKiBmcm9tICcuL2Nkay1jb21tb24tb3B0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL2Nkay1jb25zdHJ1Y3QtbGlicmFyeS1vcHRpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vY2RrLWpzaWktb3B0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbW1vbi1vcHRpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vanNpaSc7XG5leHBvcnQgKiBmcm9tICcuL2Nka2xhYnMnO1xuZXhwb3J0ICogZnJvbSAnLi9yb3NldHRhJztcbmV4cG9ydCAqIGZyb20gJy4vY2RrLWNsaS1pbnRlZy10ZXN0cyc7XG5cbmV4cG9ydCAqIGFzIHlhcm4gZnJvbSAnLi95YXJuJztcbiJdfQ==

package/lib/jsii.js

@@ -28,5 +28,5 @@ class CdkJsiiProject extends projen_1.cdk.JsiiProject {
 }
 exports.CdkJsiiProject = CdkJsiiProject;
 _a = JSII_RTTI_SYMBOL_1;
-CdkJsiiProject[_a] = { fqn: "cdklabs-projen-project-types.CdkJsiiProject", version: "0.1.217" };
+CdkJsiiProject[_a] = { fqn: "cdklabs-projen-project-types.CdkJsiiProject", version: "0.1.219" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNpaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9qc2lpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsbUNBQTZCO0FBRTdCLHFEQUF3RjtBQUV4Rjs7OztHQUlHO0FBQ0gsTUFBYSxjQUFlLFNBQVEsWUFBRyxDQUFDLFdBQVc7SUFHakQsWUFBWSxPQUE4QjtRQUN4QyxNQUFNLElBQUksR0FBRyxJQUFBLDBDQUF5QixFQUFDO1lBQ3JDLEdBQUcsT0FBTztZQUNWLGtEQUFrRDtZQUNsRCxVQUFVLEVBQUUsT0FBTyxDQUFDLFVBQVUsSUFBSSxPQUFPLENBQUMsYUFBYTtTQUN4RCxDQUFDLENBQUM7UUFDSCxLQUFLLENBQUM7WUFDSixHQUFHLElBQUk7WUFDUCxzREFBc0Q7WUFDdEQsYUFBYSxFQUFFLElBQUksQ0FBQyxVQUFVO1NBQy9CLENBQUMsQ0FBQztRQUNILElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQztRQUU1QixJQUFBLDBDQUF5QixFQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztJQUN4QyxDQUFDOztBQWpCSCx3Q0FrQkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjZGsgfSBmcm9tICdwcm9qZW4nO1xuaW1wb3J0IHsgQ2RrSnNpaVByb2plY3RPcHRpb25zIH0gZnJvbSAnLi9jZGstanNpaS1vcHRpb25zJztcbmltcG9ydCB7IGNvbmZpZ3VyZUNvbW1vbkNvbXBvbmVudHMsIHdpdGhDb21tb25PcHRpb25zRGVmYXVsdHMgfSBmcm9tICcuL2NvbW1vbi1vcHRpb25zJztcblxuLyoqXG4gKiBDcmVhdGUgYSBDZGsgSnNpaSBKc2lpIHByb2plY3RcbiAqXG4gKiBAcGppZCBjZGstanNpaS1wcm9qXG4gKi9cbmV4cG9ydCBjbGFzcyBDZGtKc2lpUHJvamVjdCBleHRlbmRzIGNkay5Kc2lpUHJvamVjdCB7XG4gIHB1YmxpYyByZWFkb25seSBwcml2YXRlOiBib29sZWFuO1xuXG4gIGNvbnN0cnVjdG9yKG9wdGlvbnM6IENka0pzaWlQcm9qZWN0T3B0aW9ucykge1xuICAgIGNvbnN0IG9wdHMgPSB3aXRoQ29tbW9uT3B0aW9uc0RlZmF1bHRzKHtcbiAgICAgIC4uLm9wdGlvbnMsXG4gICAgICAvLyBhbHNvIGFjY2VwdCB0aGUgZGVwcmVjYXRlZCByZXBvc2l0b3J5VXJsIG9wdGlvblxuICAgICAgcmVwb3NpdG9yeTogb3B0aW9ucy5yZXBvc2l0b3J5ID8/IG9wdGlvbnMucmVwb3NpdG9yeVVybCxcbiAgICB9KTtcbiAgICBzdXBlcih7XG4gICAgICAuLi5vcHRzLFxuICAgICAgLy8gdXBzdHJlYW0gSnNpaVByb2plY3QgdXNlcyBhIGRpZmZlcmVudCBuYW1lIGZvciB0aGlzXG4gICAgICByZXBvc2l0b3J5VXJsOiBvcHRzLnJlcG9zaXRvcnksXG4gICAgfSk7XG4gICAgdGhpcy5wcml2YXRlID0gb3B0cy5wcml2YXRlO1xuXG4gICAgY29uZmlndXJlQ29tbW9uQ29tcG9uZW50cyh0aGlzLCBvcHRzKTtcbiAgfVxufVxuIl19

package/lib/rosetta.js

@@ -48,5 +48,5 @@ class Rosetta extends projen_1.Component {
 }
 exports.Rosetta = Rosetta;
 _a = JSII_RTTI_SYMBOL_1;
-Rosetta[_a] = { fqn: "cdklabs-projen-project-types.Rosetta", version: "0.1.217" };
+Rosetta[_a] = { fqn: "cdklabs-projen-project-types.Rosetta", version: "0.1.219" };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm9zZXR0YS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9yb3NldHRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsbUNBQW9EO0FBa0JwRDs7Ozs7R0FLRztBQUNILE1BQWEsT0FBUSxTQUFRLGtCQUFTO0lBQ3BDLFlBQVksT0FBd0IsRUFBRSxVQUEwQixFQUFFO1FBQ2hFLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUVmLE1BQU0sTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLElBQUksSUFBSSxDQUFDO1FBRXRDLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNaLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLHVHQUF1RyxDQUFDLENBQUM7UUFDL0gsQ0FBQztRQUVELGFBQWE7UUFDYixNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxnQkFBZ0IsT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUMsQ0FBQyxjQUFjLENBQUM7UUFDeEYsT0FBTyxDQUFDLFVBQVUsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUUvQixNQUFNLFdBQVcsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLGlCQUFpQixFQUFFO1lBQ3JELFdBQVcsRUFBRSxzQkFBc0I7WUFDbkMsSUFBSSxFQUFFLHNDQUFzQyxNQUFNLENBQUMsQ0FBQyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsSUFBSSxFQUFFO1NBQzlFLENBQUMsQ0FBQztRQUNILE9BQU8sQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQzNDLE9BQU8sQ0FBQyxZQUFZLENBQUMsaUJBQWlCLENBQUMsQ0FBQztRQUN4QyxJQUFJLG1CQUFVLENBQUMsT0FBTyxFQUFFLDRCQUE0QixFQUFFO1lBQ3BELFFBQVEsRUFBRTtnQkFDUixxREFBcUQ7Z0JBQ3JELHlDQUF5QztnQkFDekMsVUFBVTtnQkFDVixVQUFVO2dCQUNWLHVCQUF1QjtnQkFDdkIsRUFBRTtnQkFDRiwrQkFBK0I7Z0JBQy9CLCtDQUErQztnQkFDL0MsdUJBQXVCO2dCQUN2QixFQUFFO2dCQUNGLGNBQWM7Z0JBQ2QsS0FBSztnQkFDTCxHQUFHO2FBQ0osQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDO1NBQ2IsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxDQUFDLFlBQVksQ0FBQyw4QkFBOEIsQ0FBQyxDQUFDO0lBQ3ZELENBQUM7O0FBdENILDBCQXVDQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgU2FtcGxlRmlsZSwgY2RrIH0gZnJvbSAncHJvamVuJztcblxuZXhwb3J0IGludGVyZmFjZSBSb3NldHRhT3B0aW9ucyB7XG4gIC8qKlxuICAgKiBFbmFibGUgb3IgZGlzYWJsZSBzdHJpY3QgbW9kZS5cbiAgICpcbiAgICogQGRlZmF1bHQgdHJ1ZVxuICAgKi9cbiAgcmVhZG9ubHkgc3RyaWN0PzogYm9vbGVhbjtcblxuICAvKipcbiAgICogU2V0IGFuIGV4cGxpY2l0IHZlcnNpb24gb2Ygcm9zZXR0YS5cbiAgICpcbiAgICogQGRlZmF1bHQgLSBubyB2ZXJzaW9uIGlzIHNldCwgdXNlIGF1dG9tYXRpYyBkZXRlY3Rpb25cbiAgICovXG4gIHJlYWRvbmx5IHZlcnNpb24/OiBzdHJpbmc7XG59XG5cbi8qKlxuICogVGhlIFJvc2V0dGEgY29tcG9uZW50IGFkZHMgYnVpbHRpbiByb3NldHRhIHN1cHBvcnRcbiAqIGZvciBhIGNvbnN0cnVjdCBsaWJyYXJ5LiBTaW5jZSBDb25zdHJ1Y3RIdWIgd2lsbCBydW5cbiAqIHJvc2V0dGEgZm9yIHJlYWwsIHRoaXMganVzdCBhZGRzIGEgY2hlY2sgdG8gdGhlIGJ1aWxkIHRvXG4gKiBlbnN1cmUgdGhhdCByb3NldHRhIHdpbGwgcnVuIHN1Y2Nlc3NmdWxseVxuICovXG5leHBvcnQgY2xhc3MgUm9zZXR0YSBleHRlbmRzIENvbXBvbmVudCB7XG4gIGNvbnN0cnVjdG9yKHByb2plY3Q6IGNkay5Kc2lpUHJvamVjdCwgb3B0aW9uczogUm9zZXR0YU9wdGlvbnMgPSB7fSkge1xuICAgIHN1cGVyKHByb2plY3QpO1xuXG4gICAgY29uc3Qgc3RyaWN0ID0gb3B0aW9ucy5zdHJpY3QgPz8gdHJ1ZTtcblxuICAgIGlmICghc3RyaWN0KSB7XG4gICAgICBwcm9qZWN0LmxvZ2dlci53YXJuKCdSb3NldHRhIGlzIE5PVCBvcGVyYXRpbmcgaW4gc3RyaWN0IG1vZGUuIFdlIGFyZSBnb2luZyB0byBlbmZvcmNlIHRoaXMgc29vbi5cXG5QbGVhc2UgZml4IGFueSBleGFtcGxlcy4nKTtcbiAgICB9XG5cbiAgICAvLyBBZGQgRGV2RGVwXG4gICAgY29uc3Qgcm9zZXR0YURlcCA9IG9wdGlvbnMudmVyc2lvbiA/IGBqc2lpLXJvc2V0dGFAJHtvcHRpb25zLnZlcnNpb259YCA6ICdqc2lpLXJvc2V0dGEnO1xuICAgIHByb2plY3QuYWRkRGV2RGVwcyhyb3NldHRhRGVwKTtcblxuICAgIGNvbnN0IHJvc2V0dGFUYXNrID0gcHJvamVjdC5hZGRUYXNrKCdyb3NldHRhOmV4dHJhY3QnLCB7XG4gICAgICBkZXNjcmlwdGlvbjogJ1Rlc3Qgcm9zZXR0YSBleHRyYWN0JyxcbiAgICAgIGV4ZWM6IGB5YXJuIC0tc2lsZW50IGpzaWktcm9zZXR0YSBleHRyYWN0ICR7c3RyaWN0ID8gJy0tc3RyaWN0JyA6ICcnfWAudHJpbSgpLFxuICAgIH0pO1xuICAgIHByb2plY3QucG9zdENvbXBpbGVUYXNrLnNwYXduKHJvc2V0dGFUYXNrKTtcbiAgICBwcm9qZWN0LmFkZEdpdElnbm9yZSgnLmpzaWkudGFibC5qc29uJyk7XG4gICAgbmV3IFNhbXBsZUZpbGUocHJvamVjdCwgJ3Jvc2V0dGEvZGVmYXVsdC50cy1maXh0dXJlJywge1xuICAgICAgY29udGVudHM6IFtcbiAgICAgICAgJy8vIEZpeHR1cmUgd2l0aCBwYWNrYWdlcyBpbXBvcnRlZCwgYnV0IG5vdGhpbmcgZWxzZScsXG4gICAgICAgIFwiaW1wb3J0IHsgQ29uc3RydWN0IH0gZnJvbSAnY29uc3RydWN0cyc7XCIsXG4gICAgICAgICdpbXBvcnQgeycsXG4gICAgICAgICcgIFN0YWNrLCcsXG4gICAgICAgIFwifSBmcm9tICdhd3MtY2RrLWxpYic7XCIsXG4gICAgICAgICcnLFxuICAgICAgICAnY2xhc3MgRml4dHVyZSBleHRlbmRzIFN0YWNrIHsnLFxuICAgICAgICAnICBjb25zdHJ1Y3RvcihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nKSB7JyxcbiAgICAgICAgJyAgICBzdXBlcihzY29wZSwgaWQpOycsXG4gICAgICAgICcnLFxuICAgICAgICAnICAgIC8vLyBoZXJlJyxcbiAgICAgICAgJyAgfScsXG4gICAgICAgICd9JyxcbiAgICAgIF0uam9pbignXFxuJyksXG4gICAgfSk7XG4gICAgcHJvamVjdC5hZGRHaXRJZ25vcmUoJyEvcm9zZXR0YS9kZWZhdWx0LnRzLWZpeHR1cmUnKTtcbiAgfVxufVxuIl19

package/lib/yarn/monorepo-release.js

@@ -239,7 +239,7 @@ class MonorepoRelease extends projen_1.Component {
 }
 exports.MonorepoRelease = MonorepoRelease;
 _a = JSII_RTTI_SYMBOL_1;
-MonorepoRelease[_a] = { fqn: "cdklabs-projen-project-types.yarn.MonorepoRelease", version: "0.1.217" };
+MonorepoRelease[_a] = { fqn: "cdklabs-projen-project-types.yarn.MonorepoRelease", version: "0.1.219" };
 function slugify(x) {
     return x.replace(/[^a-zA-Z0-9_-]/g, '-').replace(/^[0-9-]+/, '');
 }

package/lib/yarn/monorepo.js

@@ -189,7 +189,7 @@ class Monorepo extends projen_1.typescript.TypeScriptProject {
 }
 exports.Monorepo = Monorepo;
 _a = JSII_RTTI_SYMBOL_1;
-Monorepo[_a] = { fqn: "cdklabs-projen-project-types.yarn.Monorepo", version: "0.1.217" };
+Monorepo[_a] = { fqn: "cdklabs-projen-project-types.yarn.Monorepo", version: "0.1.219" };
 function getObjFromFile(project, file) {
     return project.tryFindObjectFile(file)?.obj;
 }
@@ -224,5 +224,5 @@ class CdkLabsMonorepo extends Monorepo {
 }
 exports.CdkLabsMonorepo = CdkLabsMonorepo;
 _b = JSII_RTTI_SYMBOL_1;
-CdkLabsMonorepo[_b] = { fqn: "cdklabs-projen-project-types.yarn.CdkLabsMonorepo", version: "0.1.217" };
+CdkLabsMonorepo[_b] = { fqn: "cdklabs-projen-project-types.yarn.CdkLabsMonorepo", version: "0.1.219" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monorepo.js","sourceRoot":"","sources":["../../src/yarn/monorepo.ts"],"names":[],"mappings":"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","sourcesContent":["import { JsonFile, Project, javascript, typescript, github } from 'projen';\nimport { MonorepoOptions } from './monorepo-options';\nimport { MonorepoRelease } from './monorepo-release';\nimport { Nx } from './nx';\nimport { TypeScriptWorkspace } from './typescript-workspace';\n\n/**\n * A monorepo using yarn workspaces.\n */\nexport class Monorepo extends typescript.TypeScriptProject {\n  public readonly monorepoRelease?: MonorepoRelease;\n\n  /**\n   * The URL where the actual code for the package lives.\n   */\n  public readonly repositoryUrl?: string;\n\n  private projects = new Array<TypeScriptWorkspace>();\n  private postInstallDependencies = new Array<() => boolean>();\n\n  constructor(options: MonorepoOptions) {\n    super({\n      ...options,\n      packageManager: javascript.NodePackageManager.YARN_CLASSIC,\n      sampleCode: false,\n      jest: false,\n      eslint: false,\n      release: false,\n    });\n\n    this.repositoryUrl = options.repository;\n\n    /**\n     * Prettier formatting\n     */\n    if (options.prettier) {\n      this.addDevDeps('eslint-config-prettier', 'eslint-plugin-prettier');\n      new JsonFile(this, '.eslintrc.json', {\n        allowComments: true,\n        obj: {\n          plugins: ['@typescript-eslint', 'prettier'],\n          parser: '@typescript-eslint/parser',\n          parserOptions: {\n            ecmaVersion: 2018,\n            sourceType: 'module',\n            project: './tsconfig.dev.json',\n          },\n          ignorePatterns: ['!.projenrc.ts'],\n          extends: ['plugin:prettier/recommended'],\n        },\n      });\n      this.tasks.addTask('fmt', { exec: 'eslint --ext .ts --fix --no-error-on-unmatched-pattern projenrc .projenrc.ts' });\n\n      this.vscode?.extensions.addRecommendations('esbenp.prettier-vscode', 'dbaeumer.vscode-eslint');\n      this.vscode?.settings.addSetting('editor.defaultFormatter', 'esbenp.prettier-vscode');\n      this.vscode?.settings.addSetting('eslint.format.enable', true);\n      this.vscode?.settings.addSettings({ 'editor.defaultFormatter': 'dbaeumer.vscode-eslint' }, [\n        'javascript',\n        'typescript',\n      ]);\n    }\n\n    /**\n     * Create a VSCode Workspace\n     */\n    if (options.vscodeWorkspace) {\n      const workspaceFile = `${this.name}.code-workspace`;\n      new JsonFile(this, workspaceFile, {\n        allowComments: true,\n        obj: () => ({\n          folders: this.projects\n            .sort((p1, p2) => p1.name.localeCompare(p2.name))\n            .map((p) => ({ path: p.workspaceDirectory })),\n          settings: () => getObjFromFile(this, '.vscode/settings.json'),\n          extensions: () => getObjFromFile(this, '.vscode/extensions.json'),\n        }),\n      });\n    }\n\n    /**\n     * Tasks\n     */\n    // build task\n    this.tasks.removeTask('build');\n    const fmtTask = this.tasks.tryFind('fmt');\n    const buildTask = this.tasks.addTask('build');\n    if (this.defaultTask) {\n      buildTask.spawn(this.defaultTask);\n    }\n    if (fmtTask) {\n      buildTask.spawn(fmtTask);\n    }\n    buildTask.exec('yarn workspaces run build');\n\n    // Run in all workspaces tasks\n    this.tasks.tryFind('compile')?.reset('yarn workspaces run compile');\n    this.tasks.tryFind('package')?.reset('yarn workspaces run package');\n    this.tasks.tryFind('test')?.reset('yarn workspaces run test');\n    this.addTask('run', {\n      exec: 'yarn workspaces run',\n      receiveArgs: true,\n    });\n\n    // Upgrade all packages\n    this.tasks.removeTask('upgrade');\n    this.tasks.addTask('upgrade', {\n      env: { CI: '0' },\n      description: 'Upgrade dependencies in all workspaces',\n      steps: [\n        // It is not safe anymore to have 'npm-check-updates' in a Yarn 1 dependency tree, so run it in a separate\n        // tree by using npx.\n        { exec: 'npx npm-check-updates@16 --dep=dev,optional,peer,prod,bundle --upgrade --target=minor' },\n        { exec: 'yarn workspaces run check-for-updates' },\n        { exec: 'yarn install --check-files' },\n        { exec: 'yarn upgrade' },\n        { spawn: 'default' },\n        { spawn: 'post-upgrade' },\n      ],\n    });\n\n    // Clean up tasks not required at top-level\n    this.tasks.removeTask('eject');\n    this.tasks.removeTask('watch');\n    this.tasks.removeTask('pre-compile');\n    this.tasks.removeTask('post-compile');\n\n    // Nx\n    if (options.nx) {\n      new Nx(this, {\n        defaultBase: options.defaultReleaseBranch,\n      });\n    }\n\n    // Release Workflow\n    if (options.release) {\n      this.monorepoRelease = new MonorepoRelease(this, {\n        workflowRunsOn: options.workflowRunsOn,\n        ...options.releaseOptions,\n      });\n    }\n  }\n\n  public register(project: TypeScriptWorkspace) {\n    this.projects.push(project);\n  }\n\n  public synth() {\n    this.finalEscapeHatches();\n    super.synth();\n  }\n\n  /**\n   * Allows a sub project to request installation of dependency at the Monorepo root\n   * They must provide a function that is executed after dependencies have been installed\n   * If this function returns true, the install command is run for a second time after all sub project requests have run.\n   * This is used to resolve dependency versions from `*` to a concrete version constraint.\n   */\n  public requestInstallDependencies(resolver: IDependencyResolver) {\n    this.postInstallDependencies.push(resolver.resolveDepsAndWritePackageJson);\n  }\n\n  /**\n   * Code that needs to run just before synth, but after all other code\n   */\n  private finalEscapeHatches() {\n    // Get the ObjectFile\n    this.package.addField('private', true);\n    this.package.addField('workspaces', {\n      packages: this.projects.map((p) => p.workspaceDirectory),\n      ...this.renderNoHoist(),\n    });\n\n    this.tsconfig?.file.addOverride('include', []);\n    this.tsconfigDev?.file.addOverride('include', ['.projenrc.ts', 'projenrc/**/*.ts']);\n    for (const tsconfig of [this.tsconfig, this.tsconfigDev]) {\n      tsconfig?.file.addOverride(\n        'references',\n        this.projects.map((p) => ({ path: p.workspaceDirectory })),\n      );\n    }\n\n    this.package.addField('jest', {\n      projects: this.projects.map((p) => `<rootDir>/${p.workspaceDirectory}`),\n    });\n  }\n\n  /**\n   * Render the 'nohoist' directive\n   *\n   * Bundled dependencies must be nohoist'ed, otherwise NPM silently won't bundle them.\n   *\n   * Renders an object that should be mixed into the `workspaces` object.\n   */\n  private renderNoHoist(): any {\n    const nohoist = this.projects.flatMap(p => p.bundledDeps.flatMap(dep => [\n      `${p.name}/${dep}`,\n      `${p.name}/${dep}/**`,\n    ]));\n    return nohoist.length > 0 ? { nohoist } : undefined;\n  }\n\n  /**\n   * Hooks into the install dependencies cycle\n   */\n  public postSynthesize() {\n    if (this.postInstallDependencies.length) {\n      const nodePkg: any = this.package;\n      nodePkg.installDependencies();\n\n      const completedRequests = this.postInstallDependencies.map((request) => request());\n      if (completedRequests.some(Boolean)) {\n        nodePkg.installDependencies();\n      }\n\n      this.postInstallDependencies = [];\n    }\n  }\n}\n\nexport interface IDependencyResolver {\n  resolveDepsAndWritePackageJson(): boolean;\n}\n\nfunction getObjFromFile(project: Project, file: string): object {\n  return (project.tryFindObjectFile(file) as any)?.obj;\n}\n\n/**\n * Options for CdkLabsMonorepo\n */\nexport interface CdkLabsMonorepoOptions extends MonorepoOptions {}\n\n/**\n * Opinionated implementation of yarn.Monorepo\n * @pjid cdklabs-yarn-monorepo\n */\nexport class CdkLabsMonorepo extends Monorepo {\n  constructor(options: CdkLabsMonorepoOptions) {\n    super({\n      projenrcTs: true,\n\n      autoApproveUpgrades: true,\n      autoApproveOptions: {\n        allowedUsernames: ['github-bot', 'cdklabs-automation', 'dependabot[bot]'],\n        secret: 'GITHUB_TOKEN',\n      },\n      ...options,\n      githubOptions: {\n        ...options.githubOptions,\n        mergify: false,\n      },\n      // Deviation from upstream projen: upstream projen defaults to minNodeVersion, but we have too many workflows\n      // that use tools that want a recent Node version, so default to a reasonable floating version.\n      workflowNodeVersion: options.workflowNodeVersion ?? 'lts/*',\n    });\n\n    new github.MergeQueue(this, {\n      autoQueueOptions: {\n        projenCredentials: github.GithubCredentials.fromPersonalAccessToken({ secret: 'PROJEN_GITHUB_TOKEN' }),\n      },\n    });\n  }\n}\n"]}

package/lib/yarn/typescript-workspace-release.js

@@ -104,5 +104,5 @@ class WorkspaceRelease extends projen_1.Component {
 }
 exports.WorkspaceRelease = WorkspaceRelease;
 _a = JSII_RTTI_SYMBOL_1;
-WorkspaceRelease[_a] = { fqn: "cdklabs-projen-project-types.yarn.WorkspaceRelease", version: "0.1.217" };
+WorkspaceRelease[_a] = { fqn: "cdklabs-projen-project-types.yarn.WorkspaceRelease", version: "0.1.219" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript-workspace-release.js","sourceRoot":"","sources":["../../src/yarn/typescript-workspace-release.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'node:path';\nimport { Component, ReleasableCommits, Task, Version, VersionBranchOptions, release } from 'projen';\nimport { GatherVersions, VersionMatch } from './gather-versions.task';\nimport { TypeScriptWorkspace } from './typescript-workspace';\n\nexport interface WorkspaceReleaseOptions {\n  readonly private: boolean;\n\n  /** @default 'lts/*' */\n  readonly workflowNodeVersion?: string;\n  readonly publishToNpm?: boolean;\n  readonly releasableCommits?: ReleasableCommits;\n  readonly nextVersionCommand?: string;\n  readonly versionBranchOptions: VersionBranchOptions;\n}\n\nexport class WorkspaceRelease extends Component {\n  public readonly publisher?: release.Publisher;\n  public readonly version?: Version;\n  public readonly workspace: TypeScriptWorkspace;\n\n  public constructor(project: TypeScriptWorkspace, options: WorkspaceReleaseOptions) {\n    super(project);\n    this.workspace = project;\n\n    // The root package is release-aware. Either we create a proper\n    // 'yarn release' task here, or we create a fake one that just does\n    // a 'build' (will be run in dependency order by the parent release task).\n    if (!options.private) {\n      this.version = new Version(this.workspace, {\n        versionInputFile: 'package.json', // this is where \"version\" is set after bump\n        artifactsDirectory: project.artifactsDirectory,\n        versionrcOptions: {\n          path: '.', // In a monorepo, we want standard-version to only consider the directory of the workspace\n        },\n        // This mixes the package name into the tag name,\n        // so that we can give packages individual versions.\n        // Tags end up looking like this: @scope/package@v1.2.3\n        tagPrefix: `${project.name}@`,\n\n        // In a monorepo, only consider changes relevant to the subproject\n        // Path is relative to the subproject outdir, so '.' is what we want here\n        releasableCommits: options.releasableCommits ?? ReleasableCommits.everyCommit('.'),\n\n        nextVersionCommand: options.nextVersionCommand,\n      });\n\n      this.publisher = new release.Publisher(this.workspace, {\n        artifactName: project.artifactsDirectory,\n        condition: 'needs.release.outputs.latest_commit == github.sha',\n        buildJobId: 'release',\n        workflowNodeVersion: options.workflowNodeVersion ?? 'lts/*',\n      });\n\n      this.publisher.publishToGitHubReleases({\n        changelogFile: path.posix.join(project.artifactsDirectory, this.version.changelogFileName),\n        versionFile: path.posix.join(project.artifactsDirectory, this.version.versionFileName),\n        releaseTagFile: path.posix.join(project.artifactsDirectory, this.version.releaseTagFileName),\n      });\n\n      // GitHub Releases comes for free with a `Release` component, NPM must be added explicitly\n      if (options.publishToNpm ?? true) {\n        this.publisher.publishToNpm({\n          registry: project.package.npmRegistry,\n          npmTokenSecret: project.package.npmTokenSecret,\n        });\n      }\n    }\n\n    // This tasks sets all local dependencies to their current version\n    // In the monorepo we call this task in topological order.\n    // Therefor it is guaranteed that any local packages a package depends on,\n    // already have been bumped.\n    const gatherVersions = project.addTask('gather-versions', {\n      steps: [new GatherVersions(project, VersionMatch.MAJOR)],\n    });\n\n    const bumpTask = this.obtainBumpTask();\n    bumpTask.prependSpawn(gatherVersions);\n    // The bumpTask needs to be executed with environment variables that control\n    // version information. These are not part of the upstream task itself yet,\n    // since they are part of the invocation there. We also need to make them part\n    // of the invocation here.\n    if (this.version) {\n      if (options.versionBranchOptions?.tagPrefix) {\n        throw new Error('Do not set versionBranchOptions.tagPrefix; it is configured another way');\n      }\n      for (const [key, value] of Object.entries(this.version.envForBranch({\n        ...options.versionBranchOptions,\n      }))) {\n        bumpTask.env(key, value);\n      }\n    }\n\n\n    // After we have unbumped package versions back to 0.0.0,\n    // we can run the gather-versions task again which will now replace the to-be-release versions with 0.0.0\n    this.obtainUnbumpTask().spawn(gatherVersions);\n  }\n\n  /**\n   * Get the bump version task\n   *\n   * If this is a private package, it won't have a bump task yet.\n   * So instead we create an empty one that can be called from the monorepo root\n   * and serve as a container for other steps that need to occur as part of the release\n   */\n  private obtainBumpTask(): Task {\n    return (\n      this.workspace.tasks.tryFind('bump') ??\n      this.workspace.addTask('bump', {\n        description: 'Bumps versions of local dependencies',\n      })\n    );\n  }\n\n  /**\n   * Get the unbump version task\n   *.\n   * If this is a private package, it won't have a bump task yet\n   * So instead we create an empty one that can be called from the monorepo root\n   * and serve as a container for other steps that need to occur as part of the release\n   */\n  private obtainUnbumpTask(): Task {\n    return (\n      this.workspace.tasks.tryFind('unbump') ??\n      this.workspace.addTask('unbump', {\n        description: 'Resets versions of local dependencies to 0.0.0',\n      })\n    );\n  }\n}\n"]}

package/lib/yarn/typescript-workspace.js

@@ -184,7 +184,7 @@ class TypeScriptWorkspace extends projen_1.typescript.TypeScriptProject {
 }
 exports.TypeScriptWorkspace = TypeScriptWorkspace;
 _a = JSII_RTTI_SYMBOL_1;
-TypeScriptWorkspace[_a] = { fqn: "cdklabs-projen-project-types.yarn.TypeScriptWorkspace", version: "0.1.217" };
+TypeScriptWorkspace[_a] = { fqn: "cdklabs-projen-project-types.yarn.TypeScriptWorkspace", version: "0.1.219" };
 function packageNames(xs) {
     if (!xs) {
         return undefined;

package/package.json

@@ -54,7 +54,7 @@
     "jsii-pacmak": "^1.106.0",
     "jsii-reflect": "^1.106.0",
     "jsii-rosetta": "~5.5",
-    "projen": "^0.91.6",
+    "projen": "^0.91.9",
     "ts-jest": "^29",
     "ts-node": "^10.9.2",
     "typescript": "~5.5"
@@ -74,7 +74,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.217",
+  "version": "0.1.219",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [