@cdktn/provider-project 0.7.24

package/lib/alert-open-prs.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertOpenPrs = void 0;
+const github_1 = require("projen/lib/github");
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+const random_cron_1 = require("./util/random-cron");
+const DEFAULT_MAX_HOURS_OPEN = 2;
+class AlertOpenPrs {
+    constructor(project, options) {
+        const { maxHoursOpen = DEFAULT_MAX_HOURS_OPEN, slackWebhookUrl, repository, } = options;
+        const workflow = new github_1.GithubWorkflow(project.github, "alert-open-prs");
+        workflow.on({
+            // run on weekdays sometime during working hours (8am-4pm UTC)
+            schedule: [
+                {
+                    cron: (0, random_cron_1.generateRandomCron)({
+                        project,
+                        maxHour: 8,
+                        hourOffset: 8,
+                        schedule: random_cron_1.Schedule.Weekdays,
+                    }),
+                },
+            ],
+        });
+        workflow.addJob("check-open-prs", {
+            runsOn: ["ubuntu-latest"],
+            permissions: {
+                pullRequests: workflows_model_1.JobPermission.READ,
+            },
+            env: {},
+            steps: [
+                {
+                    name: "Find old PRs",
+                    id: "old_prs",
+                    run: [
+                        `PR_LINKS=$(gh pr list --state open --repo="${repository}" --search "created:<$(date -d '-${maxHoursOpen}hours' +%FT%TZ)" --json url --jq "map(.url)" )`,
+                        `if [ "$PR_LINKS" == "[]" ]; then`,
+                        `  echo "No PRs open for more than ${maxHoursOpen} hour(s)"`,
+                        `else`,
+                        `  echo "pr_links=$PR_LINKS" >> $GITHUB_OUTPUT`,
+                        `fi`,
+                    ].join("\n"),
+                    env: { GH_TOKEN: "${{ github.token }}" },
+                },
+                {
+                    name: "Alert Slack on old PRs",
+                    if: "${{ steps.old_prs.outputs.pr_links }}",
+                    uses: "slackapi/slack-github-action",
+                    with: {
+                        webhook: slackWebhookUrl,
+                        "webhook-type": "webhook-trigger",
+                        payload: JSON.stringify({
+                            pr_links: "${{ join(fromJSON(steps.old_prs.outputs.pr_links), ', ') }}",
+                        }),
+                    },
+                },
+            ],
+            continueOnError: true, // this job fails sometimes due to Slack timeouts (503s and 504s) but it's really not a big deal if it does
+        });
+    }
+}
+exports.AlertOpenPrs = AlertOpenPrs;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxlcnQtb3Blbi1wcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvYWxlcnQtb3Blbi1wcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7R0FHRzs7O0FBR0gsOENBQW1EO0FBQ25ELHVFQUFrRTtBQUNsRSxvREFBa0U7QUFFbEUsTUFBTSxzQkFBc0IsR0FBRyxDQUFDLENBQUM7QUFRakMsTUFBYSxZQUFZO0lBQ3ZCLFlBQVksT0FBd0IsRUFBRSxPQUE0QjtRQUNoRSxNQUFNLEVBQ0osWUFBWSxHQUFHLHNCQUFzQixFQUNyQyxlQUFlLEVBQ2YsVUFBVSxHQUNYLEdBQUcsT0FBTyxDQUFDO1FBRVosTUFBTSxRQUFRLEdBQUcsSUFBSSx1QkFBYyxDQUFDLE9BQU8sQ0FBQyxNQUFPLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQztRQUN2RSxRQUFRLENBQUMsRUFBRSxDQUFDO1lBQ1YsOERBQThEO1lBQzlELFFBQVEsRUFBRTtnQkFDUjtvQkFDRSxJQUFJLEVBQUUsSUFBQSxnQ0FBa0IsRUFBQzt3QkFDdkIsT0FBTzt3QkFDUCxPQUFPLEVBQUUsQ0FBQzt3QkFDVixVQUFVLEVBQUUsQ0FBQzt3QkFDYixRQUFRLEVBQUUsc0JBQVEsQ0FBQyxRQUFRO3FCQUM1QixDQUFDO2lCQUNIO2FBQ0Y7U0FDRixDQUFDLENBQUM7UUFDSCxRQUFRLENBQUMsTUFBTSxDQUFDLGdCQUFnQixFQUFFO1lBQ2hDLE1BQU0sRUFBRSxDQUFDLGVBQWUsQ0FBQztZQUN6QixXQUFXLEVBQUU7Z0JBQ1gsWUFBWSxFQUFFLCtCQUFhLENBQUMsSUFBSTthQUNqQztZQUNELEdBQUcsRUFBRSxFQUFFO1lBQ1AsS0FBSyxFQUFFO2dCQUNMO29CQUNFLElBQUksRUFBRSxjQUFjO29CQUNwQixFQUFFLEVBQUUsU0FBUztvQkFDYixHQUFHLEVBQUU7d0JBQ0gsOENBQThDLFVBQVUsb0NBQW9DLFlBQVksZ0RBQWdEO3dCQUN4SixrQ0FBa0M7d0JBQ2xDLHFDQUFxQyxZQUFZLFdBQVc7d0JBQzVELE1BQU07d0JBQ04sK0NBQStDO3dCQUMvQyxJQUFJO3FCQUNMLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztvQkFDWixHQUFHLEVBQUUsRUFBRSxRQUFRLEVBQUUscUJBQXFCLEVBQUU7aUJBQ3pDO2dCQUNEO29CQUNFLElBQUksRUFBRSx3QkFBd0I7b0JBQzlCLEVBQUUsRUFBRSx1Q0FBdUM7b0JBQzNDLElBQUksRUFBRSw4QkFBOEI7b0JBQ3BDLElBQUksRUFBRTt3QkFDSixPQUFPLEVBQUUsZUFBZTt3QkFDeEIsY0FBYyxFQUFFLGlCQUFpQjt3QkFDakMsT0FBTyxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUM7NEJBQ3RCLFFBQVEsRUFDTiw2REFBNkQ7eUJBQ2hFLENBQUM7cUJBQ0g7aUJBQ0Y7YUFDRjtZQUNELGVBQWUsRUFBRSxJQUFJLEVBQUUsMkdBQTJHO1NBQ25JLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRjtBQTNERCxvQ0EyREMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoYykgSGFzaGlDb3JwLCBJbmMuXG4gKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTVBMLTIuMFxuICovXG5cbmltcG9ydCB7IGNkayB9IGZyb20gXCJwcm9qZW5cIjtcbmltcG9ydCB7IEdpdGh1YldvcmtmbG93IH0gZnJvbSBcInByb2plbi9saWIvZ2l0aHViXCI7XG5pbXBvcnQgeyBKb2JQZXJtaXNzaW9uIH0gZnJvbSBcInByb2plbi9saWIvZ2l0aHViL3dvcmtmbG93cy1tb2RlbFwiO1xuaW1wb3J0IHsgZ2VuZXJhdGVSYW5kb21Dcm9uLCBTY2hlZHVsZSB9IGZyb20gXCIuL3V0aWwvcmFuZG9tLWNyb25cIjtcblxuY29uc3QgREVGQVVMVF9NQVhfSE9VUlNfT1BFTiA9IDI7XG5cbmludGVyZmFjZSBBbGVydE9wZW5QcnNPcHRpb25zIHtcbiAgbWF4SG91cnNPcGVuPzogbnVtYmVyO1xuICBzbGFja1dlYmhvb2tVcmw6IHN0cmluZztcbiAgcmVwb3NpdG9yeTogc3RyaW5nO1xufVxuXG5leHBvcnQgY2xhc3MgQWxlcnRPcGVuUHJzIHtcbiAgY29uc3RydWN0b3IocHJvamVjdDogY2RrLkpzaWlQcm9qZWN0LCBvcHRpb25zOiBBbGVydE9wZW5QcnNPcHRpb25zKSB7XG4gICAgY29uc3Qge1xuICAgICAgbWF4SG91cnNPcGVuID0gREVGQVVMVF9NQVhfSE9VUlNfT1BFTixcbiAgICAgIHNsYWNrV2ViaG9va1VybCxcbiAgICAgIHJlcG9zaXRvcnksXG4gICAgfSA9IG9wdGlvbnM7XG5cbiAgICBjb25zdCB3b3JrZmxvdyA9IG5ldyBHaXRodWJXb3JrZmxvdyhwcm9qZWN0LmdpdGh1YiEsIFwiYWxlcnQtb3Blbi1wcnNcIik7XG4gICAgd29ya2Zsb3cub24oe1xuICAgICAgLy8gcnVuIG9uIHdlZWtkYXlzIHNvbWV0aW1lIGR1cmluZyB3b3JraW5nIGhvdXJzICg4YW0tNHBtIFVUQylcbiAgICAgIHNjaGVkdWxlOiBbXG4gICAgICAgIHtcbiAgICAgICAgICBjcm9uOiBnZW5lcmF0ZVJhbmRvbUNyb24oe1xuICAgICAgICAgICAgcHJvamVjdCxcbiAgICAgICAgICAgIG1heEhvdXI6IDgsXG4gICAgICAgICAgICBob3VyT2Zmc2V0OiA4LFxuICAgICAgICAgICAgc2NoZWR1bGU6IFNjaGVkdWxlLldlZWtkYXlzLFxuICAgICAgICAgIH0pLFxuICAgICAgICB9LFxuICAgICAgXSxcbiAgICB9KTtcbiAgICB3b3JrZmxvdy5hZGRKb2IoXCJjaGVjay1vcGVuLXByc1wiLCB7XG4gICAgICBydW5zT246IFtcInVidW50dS1sYXRlc3RcIl0sXG4gICAgICBwZXJtaXNzaW9uczoge1xuICAgICAgICBwdWxsUmVxdWVzdHM6IEpvYlBlcm1pc3Npb24uUkVBRCxcbiAgICAgIH0sXG4gICAgICBlbnY6IHt9LFxuICAgICAgc3RlcHM6IFtcbiAgICAgICAge1xuICAgICAgICAgIG5hbWU6IFwiRmluZCBvbGQgUFJzXCIsXG4gICAgICAgICAgaWQ6IFwib2xkX3Byc1wiLFxuICAgICAgICAgIHJ1bjogW1xuICAgICAgICAgICAgYFBSX0xJTktTPSQoZ2ggcHIgbGlzdCAtLXN0YXRlIG9wZW4gLS1yZXBvPVwiJHtyZXBvc2l0b3J5fVwiIC0tc2VhcmNoIFwiY3JlYXRlZDo8JChkYXRlIC1kICctJHttYXhIb3Vyc09wZW59aG91cnMnICslRlQlVFopXCIgLS1qc29uIHVybCAtLWpxIFwibWFwKC51cmwpXCIgKWAsXG4gICAgICAgICAgICBgaWYgWyBcIiRQUl9MSU5LU1wiID09IFwiW11cIiBdOyB0aGVuYCxcbiAgICAgICAgICAgIGAgIGVjaG8gXCJObyBQUnMgb3BlbiBmb3IgbW9yZSB0aGFuICR7bWF4SG91cnNPcGVufSBob3VyKHMpXCJgLFxuICAgICAgICAgICAgYGVsc2VgLFxuICAgICAgICAgICAgYCAgZWNobyBcInByX2xpbmtzPSRQUl9MSU5LU1wiID4+ICRHSVRIVUJfT1VUUFVUYCxcbiAgICAgICAgICAgIGBmaWAsXG4gICAgICAgICAgXS5qb2luKFwiXFxuXCIpLFxuICAgICAgICAgIGVudjogeyBHSF9UT0tFTjogXCIke3sgZ2l0aHViLnRva2VuIH19XCIgfSxcbiAgICAgICAgfSxcbiAgICAgICAge1xuICAgICAgICAgIG5hbWU6IFwiQWxlcnQgU2xhY2sgb24gb2xkIFBSc1wiLFxuICAgICAgICAgIGlmOiBcIiR7eyBzdGVwcy5vbGRfcHJzLm91dHB1dHMucHJfbGlua3MgfX1cIixcbiAgICAgICAgICB1c2VzOiBcInNsYWNrYXBpL3NsYWNrLWdpdGh1Yi1hY3Rpb25cIixcbiAgICAgICAgICB3aXRoOiB7XG4gICAgICAgICAgICB3ZWJob29rOiBzbGFja1dlYmhvb2tVcmwsXG4gICAgICAgICAgICBcIndlYmhvb2stdHlwZVwiOiBcIndlYmhvb2stdHJpZ2dlclwiLFxuICAgICAgICAgICAgcGF5bG9hZDogSlNPTi5zdHJpbmdpZnkoe1xuICAgICAgICAgICAgICBwcl9saW5rczpcbiAgICAgICAgICAgICAgICBcIiR7eyBqb2luKGZyb21KU09OKHN0ZXBzLm9sZF9wcnMub3V0cHV0cy5wcl9saW5rcyksICcsICcpIH19XCIsXG4gICAgICAgICAgICB9KSxcbiAgICAgICAgICB9LFxuICAgICAgICB9LFxuICAgICAgXSxcbiAgICAgIGNvbnRpbnVlT25FcnJvcjogdHJ1ZSwgLy8gdGhpcyBqb2IgZmFpbHMgc29tZXRpbWVzIGR1ZSB0byBTbGFjayB0aW1lb3V0cyAoNTAzcyBhbmQgNTA0cykgYnV0IGl0J3MgcmVhbGx5IG5vdCBhIGJpZyBkZWFsIGlmIGl0IGRvZXNcbiAgICB9KTtcbiAgfVxufVxuIl19

package/lib/auto-approve.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { javascript } from "projen";
+/**
+ * Approves PRs with the "auto-approve" label
+ */
+export declare class AutoApprove {
+    constructor(project: javascript.NodeProject);
+}

package/lib/auto-approve.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoApprove = void 0;
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+/**
+ * Approves PRs with the "auto-approve" label
+ */
+class AutoApprove {
+    constructor(project) {
+        const workflow = project.github?.addWorkflow("auto-approve");
+        if (!workflow)
+            throw new Error("no workflow defined");
+        workflow.on({
+            pullRequestTarget: {
+                types: ["opened", "labeled", "ready_for_review", "reopened"],
+            },
+        });
+        workflow.concurrency = {
+            group: "${{ github.workflow }}-${{ github.head_ref }}",
+        };
+        const maintainerStatuses = `fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]')`;
+        workflow.addJobs({
+            approve: {
+                runsOn: ["ubuntu-latest"],
+                if: "contains(github.event.pull_request.labels.*.name, 'auto-approve') && github.event.pull_request.draft == false",
+                steps: [
+                    {
+                        name: "Checkout PR",
+                        uses: "actions/checkout",
+                        with: {
+                            ref: "${{ env.GIT_REF }}",
+                            repository: "${{ env.GIT_REPO }}",
+                        },
+                    },
+                    {
+                        name: "Auto-approve PRs by other users as team-cdk-terrain",
+                        if: `github.event.pull_request.user.login != 'team-cdk-terrain' && (contains(${maintainerStatuses}, github.event.pull_request.author_association) || github.actor == 'dependabot[bot]')`,
+                        run: "gh pr review $PR_ID --approve",
+                        env: {
+                            GH_TOKEN: "${{ secrets.PROJEN_GITHUB_TOKEN }}",
+                        },
+                    },
+                    {
+                        name: "Auto-approve PRs by team-cdk-terrain as github-actions[bot]",
+                        if: "github.event.pull_request.user.login == 'team-cdk-terrain'",
+                        run: "gh pr review $PR_ID --approve",
+                        env: {
+                            GH_TOKEN: "${{ secrets.GITHUB_TOKEN }}",
+                        },
+                    },
+                ],
+                permissions: {
+                    contents: workflows_model_1.JobPermission.READ,
+                    pullRequests: workflows_model_1.JobPermission.WRITE,
+                },
+                env: {
+                    GIT_REF: "${{ github.event.pull_request.head.ref }}",
+                    GIT_REPO: "${{ github.event.pull_request.head.repo.full_name }}",
+                    PR_ID: "${{ github.event.pull_request.number }}",
+                },
+            },
+        });
+    }
+}
+exports.AutoApprove = AutoApprove;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0by1hcHByb3ZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2F1dG8tYXBwcm92ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7OztHQUdHOzs7QUFHSCx1RUFBa0U7QUFFbEU7O0dBRUc7QUFDSCxNQUFhLFdBQVc7SUFDdEIsWUFBWSxPQUErQjtRQUN6QyxNQUFNLFFBQVEsR0FBRyxPQUFPLENBQUMsTUFBTSxFQUFFLFdBQVcsQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUU3RCxJQUFJLENBQUMsUUFBUTtZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMscUJBQXFCLENBQUMsQ0FBQztRQUV0RCxRQUFRLENBQUMsRUFBRSxDQUFDO1lBQ1YsaUJBQWlCLEVBQUU7Z0JBQ2pCLEtBQUssRUFBRSxDQUFDLFFBQVEsRUFBRSxTQUFTLEVBQUUsa0JBQWtCLEVBQUUsVUFBVSxDQUFDO2FBQzdEO1NBQ0YsQ0FBQyxDQUFDO1FBRUYsUUFBUSxDQUFDLFdBQW1CLEdBQUc7WUFDOUIsS0FBSyxFQUFFLCtDQUErQztTQUN2RCxDQUFDO1FBRUYsTUFBTSxrQkFBa0IsR0FBRyxpREFBaUQsQ0FBQztRQUM3RSxRQUFRLENBQUMsT0FBTyxDQUFDO1lBQ2YsT0FBTyxFQUFFO2dCQUNQLE1BQU0sRUFBRSxDQUFDLGVBQWUsQ0FBQztnQkFDekIsRUFBRSxFQUFFLCtHQUErRztnQkFDbkgsS0FBSyxFQUFFO29CQUNMO3dCQUNFLElBQUksRUFBRSxhQUFhO3dCQUNuQixJQUFJLEVBQUUsa0JBQWtCO3dCQUN4QixJQUFJLEVBQUU7NEJBQ0osR0FBRyxFQUFFLG9CQUFvQjs0QkFDekIsVUFBVSxFQUFFLHFCQUFxQjt5QkFDbEM7cUJBQ0Y7b0JBQ0Q7d0JBQ0UsSUFBSSxFQUFFLHFEQUFxRDt3QkFDM0QsRUFBRSxFQUFFLDJFQUEyRSxrQkFBa0IsdUZBQXVGO3dCQUN4TCxHQUFHLEVBQUUsK0JBQStCO3dCQUNwQyxHQUFHLEVBQUU7NEJBQ0gsUUFBUSxFQUFFLG9DQUFvQzt5QkFDL0M7cUJBQ0Y7b0JBQ0Q7d0JBQ0UsSUFBSSxFQUFFLDZEQUE2RDt3QkFDbkUsRUFBRSxFQUFFLDREQUE0RDt3QkFDaEUsR0FBRyxFQUFFLCtCQUErQjt3QkFDcEMsR0FBRyxFQUFFOzRCQUNILFFBQVEsRUFBRSw2QkFBNkI7eUJBQ3hDO3FCQUNGO2lCQUNGO2dCQUNELFdBQVcsRUFBRTtvQkFDWCxRQUFRLEVBQUUsK0JBQWEsQ0FBQyxJQUFJO29CQUM1QixZQUFZLEVBQUUsK0JBQWEsQ0FBQyxLQUFLO2lCQUNsQztnQkFDRCxHQUFHLEVBQUU7b0JBQ0gsT0FBTyxFQUFFLDJDQUEyQztvQkFDcEQsUUFBUSxFQUFFLHNEQUFzRDtvQkFDaEUsS0FBSyxFQUFFLHlDQUF5QztpQkFDakQ7YUFDRjtTQUNGLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRjtBQTNERCxrQ0EyREMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoYykgSGFzaGlDb3JwLCBJbmMuXG4gKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTVBMLTIuMFxuICovXG5cbmltcG9ydCB7IGphdmFzY3JpcHQgfSBmcm9tIFwicHJvamVuXCI7XG5pbXBvcnQgeyBKb2JQZXJtaXNzaW9uIH0gZnJvbSBcInByb2plbi9saWIvZ2l0aHViL3dvcmtmbG93cy1tb2RlbFwiO1xuXG4vKipcbiAqIEFwcHJvdmVzIFBScyB3aXRoIHRoZSBcImF1dG8tYXBwcm92ZVwiIGxhYmVsXG4gKi9cbmV4cG9ydCBjbGFzcyBBdXRvQXBwcm92ZSB7XG4gIGNvbnN0cnVjdG9yKHByb2plY3Q6IGphdmFzY3JpcHQuTm9kZVByb2plY3QpIHtcbiAgICBjb25zdCB3b3JrZmxvdyA9IHByb2plY3QuZ2l0aHViPy5hZGRXb3JrZmxvdyhcImF1dG8tYXBwcm92ZVwiKTtcblxuICAgIGlmICghd29ya2Zsb3cpIHRocm93IG5ldyBFcnJvcihcIm5vIHdvcmtmbG93IGRlZmluZWRcIik7XG5cbiAgICB3b3JrZmxvdy5vbih7XG4gICAgICBwdWxsUmVxdWVzdFRhcmdldDoge1xuICAgICAgICB0eXBlczogW1wib3BlbmVkXCIsIFwibGFiZWxlZFwiLCBcInJlYWR5X2Zvcl9yZXZpZXdcIiwgXCJyZW9wZW5lZFwiXSxcbiAgICAgIH0sXG4gICAgfSk7XG5cbiAgICAod29ya2Zsb3cuY29uY3VycmVuY3kgYXMgYW55KSA9IHtcbiAgICAgIGdyb3VwOiBcIiR7eyBnaXRodWIud29ya2Zsb3cgfX0tJHt7IGdpdGh1Yi5oZWFkX3JlZiB9fVwiLFxuICAgIH07XG5cbiAgICBjb25zdCBtYWludGFpbmVyU3RhdHVzZXMgPSBgZnJvbUpTT04oJ1tcIk9XTkVSXCIsIFwiTUVNQkVSXCIsIFwiQ09MTEFCT1JBVE9SXCJdJylgO1xuICAgIHdvcmtmbG93LmFkZEpvYnMoe1xuICAgICAgYXBwcm92ZToge1xuICAgICAgICBydW5zT246IFtcInVidW50dS1sYXRlc3RcIl0sXG4gICAgICAgIGlmOiBcImNvbnRhaW5zKGdpdGh1Yi5ldmVudC5wdWxsX3JlcXVlc3QubGFiZWxzLioubmFtZSwgJ2F1dG8tYXBwcm92ZScpICYmIGdpdGh1Yi5ldmVudC5wdWxsX3JlcXVlc3QuZHJhZnQgPT0gZmFsc2VcIixcbiAgICAgICAgc3RlcHM6IFtcbiAgICAgICAgICB7XG4gICAgICAgICAgICBuYW1lOiBcIkNoZWNrb3V0IFBSXCIsXG4gICAgICAgICAgICB1c2VzOiBcImFjdGlvbnMvY2hlY2tvdXRcIixcbiAgICAgICAgICAgIHdpdGg6IHtcbiAgICAgICAgICAgICAgcmVmOiBcIiR7eyBlbnYuR0lUX1JFRiB9fVwiLFxuICAgICAgICAgICAgICByZXBvc2l0b3J5OiBcIiR7eyBlbnYuR0lUX1JFUE8gfX1cIixcbiAgICAgICAgICAgIH0sXG4gICAgICAgICAgfSxcbiAgICAgICAgICB7XG4gICAgICAgICAgICBuYW1lOiBcIkF1dG8tYXBwcm92ZSBQUnMgYnkgb3RoZXIgdXNlcnMgYXMgdGVhbS1jZGstdGVycmFpblwiLFxuICAgICAgICAgICAgaWY6IGBnaXRodWIuZXZlbnQucHVsbF9yZXF1ZXN0LnVzZXIubG9naW4gIT0gJ3RlYW0tY2RrLXRlcnJhaW4nICYmIChjb250YWlucygke21haW50YWluZXJTdGF0dXNlc30sIGdpdGh1Yi5ldmVudC5wdWxsX3JlcXVlc3QuYXV0aG9yX2Fzc29jaWF0aW9uKSB8fCBnaXRodWIuYWN0b3IgPT0gJ2RlcGVuZGFib3RbYm90XScpYCxcbiAgICAgICAgICAgIHJ1bjogXCJnaCBwciByZXZpZXcgJFBSX0lEIC0tYXBwcm92ZVwiLFxuICAgICAgICAgICAgZW52OiB7XG4gICAgICAgICAgICAgIEdIX1RPS0VOOiBcIiR7eyBzZWNyZXRzLlBST0pFTl9HSVRIVUJfVE9LRU4gfX1cIixcbiAgICAgICAgICAgIH0sXG4gICAgICAgICAgfSxcbiAgICAgICAgICB7XG4gICAgICAgICAgICBuYW1lOiBcIkF1dG8tYXBwcm92ZSBQUnMgYnkgdGVhbS1jZGstdGVycmFpbiBhcyBnaXRodWItYWN0aW9uc1tib3RdXCIsXG4gICAgICAgICAgICBpZjogXCJnaXRodWIuZXZlbnQucHVsbF9yZXF1ZXN0LnVzZXIubG9naW4gPT0gJ3RlYW0tY2RrLXRlcnJhaW4nXCIsXG4gICAgICAgICAgICBydW46IFwiZ2ggcHIgcmV2aWV3ICRQUl9JRCAtLWFwcHJvdmVcIixcbiAgICAgICAgICAgIGVudjoge1xuICAgICAgICAgICAgICBHSF9UT0tFTjogXCIke3sgc2VjcmV0cy5HSVRIVUJfVE9LRU4gfX1cIixcbiAgICAgICAgICAgIH0sXG4gICAgICAgICAgfSxcbiAgICAgICAgXSxcbiAgICAgICAgcGVybWlzc2lvbnM6IHtcbiAgICAgICAgICBjb250ZW50czogSm9iUGVybWlzc2lvbi5SRUFELFxuICAgICAgICAgIHB1bGxSZXF1ZXN0czogSm9iUGVybWlzc2lvbi5XUklURSxcbiAgICAgICAgfSxcbiAgICAgICAgZW52OiB7XG4gICAgICAgICAgR0lUX1JFRjogXCIke3sgZ2l0aHViLmV2ZW50LnB1bGxfcmVxdWVzdC5oZWFkLnJlZiB9fVwiLFxuICAgICAgICAgIEdJVF9SRVBPOiBcIiR7eyBnaXRodWIuZXZlbnQucHVsbF9yZXF1ZXN0LmhlYWQucmVwby5mdWxsX25hbWUgfX1cIixcbiAgICAgICAgICBQUl9JRDogXCIke3sgZ2l0aHViLmV2ZW50LnB1bGxfcmVxdWVzdC5udW1iZXIgfX1cIixcbiAgICAgICAgfSxcbiAgICAgIH0sXG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==

package/lib/auto-close-community-issues.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { javascript } from "projen";
+interface AutoCloseCommunityIssuesOptions {
+    providerName: string;
+}
+/**
+ * Automatically closes issues and PRs by non-collaborators since this isn't the right place for them.
+ */
+export declare class AutoCloseCommunityIssues {
+    constructor(project: javascript.NodeProject, options: AutoCloseCommunityIssuesOptions);
+}
+export {};

package/lib/auto-close-community-issues.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoCloseCommunityIssues = void 0;
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+/**
+ * Automatically closes issues and PRs by non-collaborators since this isn't the right place for them.
+ */
+class AutoCloseCommunityIssues {
+    constructor(project, options) {
+        const { providerName } = options;
+        const issueWorkflow = project.github?.addWorkflow("auto-close-community-issues");
+        const prWorkflow = project.github?.addWorkflow("auto-close-community-prs");
+        if (!issueWorkflow)
+            throw new Error("no workflow defined");
+        if (!prWorkflow)
+            throw new Error("no workflow defined");
+        issueWorkflow.on({
+            issues: {
+                types: ["opened"],
+            },
+        });
+        prWorkflow.on({
+            pullRequestTarget: {
+                types: ["opened"],
+            },
+        });
+        const maintainerStatuses = `fromJSON('["OWNER", "MEMBER", "COLLABORATOR", "CONTRIBUTOR"]')`;
+        const comment = `Hi there! 👋 We appreciate your interest, but this is probably not the right place. 
+      All the code in this repository is auto-generated using 
+      [cdktn-provider-project](https://github.com/cdktn-io/cdktn-provider-project) and 
+      [cdktn-repository-manager](https://github.com/cdktn-io/cdktn-repository-manager) from the source 
+      [Terraform provider](https://github.com/terraform-providers/terraform-provider-${providerName}). 
+      If there are problems, they should be addressed in one of those 3 repositories, not here, 
+      as any changes here will just get overwritten the next time there is an update upstream. 
+      Please open a new issue or PR in one of those repos. In the meantime, I'll auto-close this. 
+      Thanks!`.replace(/\s+/g, " ");
+        issueWorkflow.addJob("autoclose", {
+            runsOn: ["ubuntu-latest"],
+            permissions: {
+                contents: workflows_model_1.JobPermission.READ,
+                issues: workflows_model_1.JobPermission.WRITE,
+            },
+            if: `github.event.issue.user.login != 'team-cdk-terrain' && !contains(${maintainerStatuses}, github.event.issue.author_association)`,
+            steps: [
+                {
+                    name: "Checkout",
+                    uses: "actions/checkout",
+                },
+                {
+                    name: "Auto-close issues by non-collaborators",
+                    env: {
+                        GH_TOKEN: "${{ secrets.GITHUB_TOKEN }}",
+                    },
+                    run: 'gh issue close ${{ github.event.issue.number }} --reason "not planned" --comment "' +
+                        comment +
+                        '"',
+                },
+                {
+                    name: "Add labels",
+                    env: {
+                        GH_TOKEN: "${{ secrets.GITHUB_TOKEN }}",
+                    },
+                    run: 'gh issue edit ${{ github.event.issue.number }} --add-label "invalid,wontfix"',
+                },
+            ],
+        });
+        prWorkflow.addJob("autoclose", {
+            runsOn: ["ubuntu-latest"],
+            permissions: {
+                contents: workflows_model_1.JobPermission.READ,
+                pullRequests: workflows_model_1.JobPermission.WRITE,
+            },
+            if: `github.event.pull_request.user.login != 'team-cdk-terrain' && github.actor != 'dependabot[bot]' && !contains(${maintainerStatuses}, github.event.pull_request.author_association)`,
+            steps: [
+                {
+                    name: "Checkout",
+                    uses: "actions/checkout",
+                },
+                {
+                    name: "Auto-close PRs by non-collaborators",
+                    env: {
+                        GH_TOKEN: "${{ secrets.GITHUB_TOKEN }}",
+                    },
+                    run: 'gh pr close ${{ github.event.pull_request.number }} --comment "' +
+                        comment +
+                        '"',
+                },
+                {
+                    name: "Add labels",
+                    env: {
+                        GH_TOKEN: "${{ secrets.GITHUB_TOKEN }}",
+                    },
+                    run: 'gh pr edit ${{ github.event.pull_request.number }} --add-label "invalid,wontfix"',
+                },
+            ],
+        });
+    }
+}
+exports.AutoCloseCommunityIssues = AutoCloseCommunityIssues;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auto-close-community-issues.js","sourceRoot":"","sources":["../src/auto-close-community-issues.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAGH,uEAAkE;AAKlE;;GAEG;AACH,MAAa,wBAAwB;IACnC,YACE,OAA+B,EAC/B,OAAwC;QAExC,MAAM,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC;QACjC,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,EAAE,WAAW,CAC/C,6BAA6B,CAC9B,CAAC;QACF,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,WAAW,CAAC,0BAA0B,CAAC,CAAC;QAE3E,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QAC3D,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QAExD,aAAa,CAAC,EAAE,CAAC;YACf,MAAM,EAAE;gBACN,KAAK,EAAE,CAAC,QAAQ,CAAC;aAClB;SACF,CAAC,CAAC;QACH,UAAU,CAAC,EAAE,CAAC;YACZ,iBAAiB,EAAE;gBACjB,KAAK,EAAE,CAAC,QAAQ,CAAC;aAClB;SACF,CAAC,CAAC;QAEH,MAAM,kBAAkB,GAAG,gEAAgE,CAAC;QAC5F,MAAM,OAAO,GACX;;;;uFAIiF,YAAY;;;;cAIrF,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAEhC,aAAa,CAAC,MAAM,CAAC,WAAW,EAAE;YAChC,MAAM,EAAE,CAAC,eAAe,CAAC;YACzB,WAAW,EAAE;gBACX,QAAQ,EAAE,+BAAa,CAAC,IAAI;gBAC5B,MAAM,EAAE,+BAAa,CAAC,KAAK;aAC5B;YACD,EAAE,EAAE,oEAAoE,kBAAkB,0CAA0C;YACpI,KAAK,EAAE;gBACL;oBACE,IAAI,EAAE,UAAU;oBAChB,IAAI,EAAE,kBAAkB;iBACzB;gBACD;oBACE,IAAI,EAAE,wCAAwC;oBAC9C,GAAG,EAAE;wBACH,QAAQ,EAAE,6BAA6B;qBACxC;oBACD,GAAG,EACD,oFAAoF;wBACpF,OAAO;wBACP,GAAG;iBACN;gBACD;oBACE,IAAI,EAAE,YAAY;oBAClB,GAAG,EAAE;wBACH,QAAQ,EAAE,6BAA6B;qBACxC;oBACD,GAAG,EAAE,8EAA8E;iBACpF;aACF;SACF,CAAC,CAAC;QAEH,UAAU,CAAC,MAAM,CAAC,WAAW,EAAE;YAC7B,MAAM,EAAE,CAAC,eAAe,CAAC;YACzB,WAAW,EAAE;gBACX,QAAQ,EAAE,+BAAa,CAAC,IAAI;gBAC5B,YAAY,EAAE,+BAAa,CAAC,KAAK;aAClC;YACD,EAAE,EAAE,gHAAgH,kBAAkB,iDAAiD;YACvL,KAAK,EAAE;gBACL;oBACE,IAAI,EAAE,UAAU;oBAChB,IAAI,EAAE,kBAAkB;iBACzB;gBACD;oBACE,IAAI,EAAE,qCAAqC;oBAC3C,GAAG,EAAE;wBACH,QAAQ,EAAE,6BAA6B;qBACxC;oBACD,GAAG,EACD,iEAAiE;wBACjE,OAAO;wBACP,GAAG;iBACN;gBACD;oBACE,IAAI,EAAE,YAAY;oBAClB,GAAG,EAAE;wBACH,QAAQ,EAAE,6BAA6B;qBACxC;oBACD,GAAG,EAAE,kFAAkF;iBACxF;aACF;SACF,CAAC,CAAC;IACL,CAAC;CACF;AArGD,4DAqGC","sourcesContent":["/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\n\nimport { javascript } from \"projen\";\nimport { JobPermission } from \"projen/lib/github/workflows-model\";\n\ninterface AutoCloseCommunityIssuesOptions {\n  providerName: string;\n}\n/**\n * Automatically closes issues and PRs by non-collaborators since this isn't the right place for them.\n */\nexport class AutoCloseCommunityIssues {\n  constructor(\n    project: javascript.NodeProject,\n    options: AutoCloseCommunityIssuesOptions\n  ) {\n    const { providerName } = options;\n    const issueWorkflow = project.github?.addWorkflow(\n      \"auto-close-community-issues\"\n    );\n    const prWorkflow = project.github?.addWorkflow(\"auto-close-community-prs\");\n\n    if (!issueWorkflow) throw new Error(\"no workflow defined\");\n    if (!prWorkflow) throw new Error(\"no workflow defined\");\n\n    issueWorkflow.on({\n      issues: {\n        types: [\"opened\"],\n      },\n    });\n    prWorkflow.on({\n      pullRequestTarget: {\n        types: [\"opened\"],\n      },\n    });\n\n    const maintainerStatuses = `fromJSON('[\"OWNER\", \"MEMBER\", \"COLLABORATOR\", \"CONTRIBUTOR\"]')`;\n    const comment =\n      `Hi there! 👋 We appreciate your interest, but this is probably not the right place. \n      All the code in this repository is auto-generated using \n      [cdktn-provider-project](https://github.com/cdktn-io/cdktn-provider-project) and \n      [cdktn-repository-manager](https://github.com/cdktn-io/cdktn-repository-manager) from the source \n      [Terraform provider](https://github.com/terraform-providers/terraform-provider-${providerName}). \n      If there are problems, they should be addressed in one of those 3 repositories, not here, \n      as any changes here will just get overwritten the next time there is an update upstream. \n      Please open a new issue or PR in one of those repos. In the meantime, I'll auto-close this. \n      Thanks!`.replace(/\\s+/g, \" \");\n\n    issueWorkflow.addJob(\"autoclose\", {\n      runsOn: [\"ubuntu-latest\"],\n      permissions: {\n        contents: JobPermission.READ,\n        issues: JobPermission.WRITE,\n      },\n      if: `github.event.issue.user.login != 'team-cdk-terrain' && !contains(${maintainerStatuses}, github.event.issue.author_association)`,\n      steps: [\n        {\n          name: \"Checkout\",\n          uses: \"actions/checkout\",\n        },\n        {\n          name: \"Auto-close issues by non-collaborators\",\n          env: {\n            GH_TOKEN: \"${{ secrets.GITHUB_TOKEN }}\",\n          },\n          run:\n            'gh issue close ${{ github.event.issue.number }} --reason \"not planned\" --comment \"' +\n            comment +\n            '\"',\n        },\n        {\n          name: \"Add labels\",\n          env: {\n            GH_TOKEN: \"${{ secrets.GITHUB_TOKEN }}\",\n          },\n          run: 'gh issue edit ${{ github.event.issue.number }} --add-label \"invalid,wontfix\"',\n        },\n      ],\n    });\n\n    prWorkflow.addJob(\"autoclose\", {\n      runsOn: [\"ubuntu-latest\"],\n      permissions: {\n        contents: JobPermission.READ,\n        pullRequests: JobPermission.WRITE,\n      },\n      if: `github.event.pull_request.user.login != 'team-cdk-terrain' && github.actor != 'dependabot[bot]' && !contains(${maintainerStatuses}, github.event.pull_request.author_association)`,\n      steps: [\n        {\n          name: \"Checkout\",\n          uses: \"actions/checkout\",\n        },\n        {\n          name: \"Auto-close PRs by non-collaborators\",\n          env: {\n            GH_TOKEN: \"${{ secrets.GITHUB_TOKEN }}\",\n          },\n          run:\n            'gh pr close ${{ github.event.pull_request.number }} --comment \"' +\n            comment +\n            '\"',\n        },\n        {\n          name: \"Add labels\",\n          env: {\n            GH_TOKEN: \"${{ secrets.GITHUB_TOKEN }}\",\n          },\n          run: 'gh pr edit ${{ github.event.pull_request.number }} --add-label \"invalid,wontfix\"',\n        },\n      ],\n    });\n  }\n}\n"]}

package/lib/automerge.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { javascript } from "projen";
+/**
+ * Enables GitHub's built-in automerge for PRs with the "automerge" label
+ */
+export declare class Automerge {
+    constructor(project: javascript.NodeProject);
+}

package/lib/automerge.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Automerge = void 0;
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+/**
+ * Enables GitHub's built-in automerge for PRs with the "automerge" label
+ */
+class Automerge {
+    constructor(project) {
+        const workflow = project.github?.addWorkflow("automerge");
+        if (!workflow)
+            throw new Error("no workflow defined");
+        workflow.on({
+            pullRequestTarget: {
+                types: [
+                    "opened",
+                    "labeled",
+                    "ready_for_review",
+                    "reopened",
+                    "synchronize",
+                ],
+            },
+        });
+        workflow.concurrency = {
+            group: "${{ github.workflow }}-${{ github.head_ref }}",
+        };
+        const maintainerStatuses = `fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]')`;
+        workflow.addJobs({
+            automerge: {
+                runsOn: ["ubuntu-latest"],
+                if: "contains(github.event.pull_request.labels.*.name, 'automerge') && !contains(github.event.pull_request.labels.*.name, 'do-not-merge') && github.event.pull_request.draft == false",
+                steps: [
+                    {
+                        name: "Checkout",
+                        uses: "actions/checkout",
+                        with: {
+                            ref: "${{ env.GIT_REF }}",
+                            repository: "${{ env.GIT_REPO }}",
+                        },
+                    },
+                    {
+                        name: "Turn on automerge for this PR by a trusted user or bot",
+                        if: `github.event.pull_request.user.login == 'team-cdk-terrain' || contains(${maintainerStatuses}, github.event.pull_request.author_association) || github.actor == 'dependabot[bot]'`,
+                        run: "gh pr merge --auto --squash $PR_ID",
+                        env: {
+                            GH_TOKEN: "${{ secrets.PROJEN_GITHUB_TOKEN }}",
+                        },
+                    },
+                ],
+                permissions: {
+                    contents: workflows_model_1.JobPermission.READ,
+                },
+                env: {
+                    GIT_REF: "${{ github.event.pull_request.head.ref }}",
+                    GIT_REPO: "${{ github.event.pull_request.head.repo.full_name }}",
+                    PR_ID: "${{ github.event.pull_request.number }}",
+                },
+            },
+        });
+    }
+}
+exports.Automerge = Automerge;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cdktf-config.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { cdk } from "projen";
+import { PackageInfo } from "./package-info";
+interface CdktfConfigOptions {
+    terraformProvider: string;
+    providerName: string;
+    fqproviderName: string;
+    providerVersion: string;
+    cdktfVersion: string;
+    constructsVersion: string;
+    packageInfo: PackageInfo;
+    githubNamespace: string;
+    /**
+     * Whether or not this prebuilt provider is deprecated.
+     * If true, no new versions will be published.
+     */
+    isDeprecated: boolean;
+    /**
+     * An optional date when the project should be considered deprecated,
+     * to be used in the README text. If no date is provided, then the
+     * date of the build will be used by default.
+     */
+    deprecationDate?: string;
+    jsiiVersion?: string;
+    typescriptVersion?: string;
+}
+export declare class CdktfConfig {
+    constructor(project: cdk.JsiiProject, options: CdktfConfigOptions);
+}
+export {};

package/lib/cdktf-config.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdktfConfig = void 0;
+const path = require("path");
+const fs_extra_1 = require("fs-extra");
+const projen_1 = require("projen");
+const readme_1 = require("./readme");
+const CDKTF_JSON_FILE = "cdktf.json";
+class CdktfConfig {
+    constructor(project, options) {
+        const { terraformProvider, providerName, jsiiVersion, typescriptVersion, isDeprecated, } = options;
+        const cdktfVersion = options.cdktfVersion;
+        const constructsVersion = options.constructsVersion;
+        project.addPeerDeps(`cdktf@${cdktfVersion}`);
+        project.addPeerDeps(`constructs@${constructsVersion}`);
+        project.addDevDeps(`cdktf@${cdktfVersion}`);
+        project.addDevDeps(`cdktf-cli@${cdktfVersion}`);
+        project.addDevDeps(`constructs@${constructsVersion}`);
+        if (jsiiVersion) {
+            project.addDevDeps(`jsii@${jsiiVersion}`);
+        }
+        if (typescriptVersion) {
+            project.addDevDeps(`typescript@${typescriptVersion}`);
+        }
+        const fetchTask = project.addTask("fetch", {
+            exec: `mkdir -p src && rm -rf ./src/* && cdktf get && cp -R .gen/providers/${providerName}/* ./src/ && cp .gen/versions.json ./src/version.json`,
+            env: {
+                CHECKPOINT_DISABLE: "1",
+            },
+        });
+        // execute projen after fetch to ensure that updates to version.json are picked up in package.json
+        fetchTask.spawn(project.tasks.tryFind("default"));
+        project.setScript("commit", 'git add -A && git commit -am "Update provider" || echo "No changes to commit"');
+        // eslint-disable-next-line quotes
+        project.setScript("should-release", `! git diff --exit-code v$(cat version.json | jq -r '.version') ./src ./package.json`);
+        project.setScript("prebump", "yarn fetch && yarn compile && yarn run commit && yarn run should-release");
+        project.setScript("compile", "jsii --silence-warnings=reserved-word");
+        project.setScript("build-provider", "yarn fetch && yarn compile && yarn docgen");
+        project.setScript("test", "jest --passWithNoTests");
+        project.addFields({ publishConfig: { access: "public" } });
+        project.addFields({
+            "standard-version": {
+                types: [
+                    {
+                        type: "feat",
+                        section: "Features",
+                    },
+                    {
+                        type: "fix",
+                        section: "Bug Fixes",
+                    },
+                    {
+                        type: "chore",
+                        section: "Updates",
+                    },
+                    {
+                        type: "docs",
+                        hidden: true,
+                    },
+                    {
+                        type: "style",
+                        hidden: true,
+                    },
+                    {
+                        type: "refactor",
+                        hidden: true,
+                    },
+                    {
+                        type: "perf",
+                        hidden: true,
+                    },
+                    {
+                        type: "test",
+                        hidden: true,
+                    },
+                ],
+            },
+        });
+        // set provider name and version from version.json (if it exists yet)
+        const versionFile = path.resolve(project.outdir, "src/version.json");
+        let fullyQualifiedProviderName = "<unknown>";
+        let actualProviderVersion = "<unknown>";
+        if ((0, fs_extra_1.existsSync)(versionFile)) {
+            const map = JSON.parse((0, fs_extra_1.readFileSync)(versionFile, "utf8"));
+            if (Object.keys(map).length !== 1) {
+                throw new Error("version.json must have exactly one entry. specifying multiple providers is not supported");
+            }
+            const [fqpn, version] = Object.entries(map)[0];
+            fullyQualifiedProviderName = fqpn;
+            actualProviderVersion = version;
+        }
+        project.addFields({
+            cdktf: {
+                isDeprecated,
+                provider: {
+                    name: fullyQualifiedProviderName,
+                    version: actualProviderVersion,
+                },
+            },
+        });
+        if (project.npmignore) {
+            project.npmignore.exclude(CDKTF_JSON_FILE);
+            project.npmignore.exclude(".gen");
+            project.npmignore.exclude(".terraform");
+            project.npmignore.exclude("cdktf.json");
+            project.npmignore.exclude("API.md");
+            project.npmignore.exclude("docs");
+            project.npmignore.exclude("scripts");
+            project.npmignore.exclude(".projenrc.js");
+            project.npmignore.exclude(".copywrite.hcl");
+        }
+        project.gitignore.exclude(".gen");
+        project.gitignore.exclude(".terraform");
+        project.gitignore.exclude("package-lock.json");
+        new projen_1.JsonFile(project, CDKTF_JSON_FILE, {
+            obj: {
+                language: "typescript",
+                app: "echo noop",
+                sendCrashReports: false,
+                terraformProviders: [terraformProvider],
+            },
+        });
+        new readme_1.ReadmeFile(project, "README.md", {
+            ...options,
+            underlyingTerraformVersion: actualProviderVersion,
+        });
+    }
+}
+exports.CdktfConfig = CdktfConfig;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdktf-config.js","sourceRoot":"","sources":["../src/cdktf-config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\n\nimport * as path from \"path\";\nimport { readFileSync, existsSync } from \"fs-extra\";\nimport { JsonFile, cdk } from \"projen\";\nimport { PackageInfo } from \"./package-info\";\nimport { ReadmeFile } from \"./readme\";\n\nconst CDKTF_JSON_FILE = \"cdktf.json\";\n\ninterface CdktfConfigOptions {\n  terraformProvider: string;\n  providerName: string;\n  fqproviderName: string;\n  providerVersion: string;\n  cdktfVersion: string;\n  constructsVersion: string;\n  packageInfo: PackageInfo;\n  githubNamespace: string;\n  /**\n   * Whether or not this prebuilt provider is deprecated.\n   * If true, no new versions will be published.\n   */\n  isDeprecated: boolean;\n  /**\n   * An optional date when the project should be considered deprecated,\n   * to be used in the README text. If no date is provided, then the\n   * date of the build will be used by default.\n   */\n  deprecationDate?: string;\n  jsiiVersion?: string;\n  typescriptVersion?: string;\n}\n\nexport class CdktfConfig {\n  constructor(project: cdk.JsiiProject, options: CdktfConfigOptions) {\n    const {\n      terraformProvider,\n      providerName,\n      jsiiVersion,\n      typescriptVersion,\n      isDeprecated,\n    } = options;\n\n    const cdktfVersion = options.cdktfVersion;\n    const constructsVersion = options.constructsVersion;\n\n    project.addPeerDeps(`cdktf@${cdktfVersion}`);\n    project.addPeerDeps(`constructs@${constructsVersion}`);\n\n    project.addDevDeps(`cdktf@${cdktfVersion}`);\n    project.addDevDeps(`cdktf-cli@${cdktfVersion}`);\n    project.addDevDeps(`constructs@${constructsVersion}`);\n\n    if (jsiiVersion) {\n      project.addDevDeps(`jsii@${jsiiVersion}`);\n    }\n    if (typescriptVersion) {\n      project.addDevDeps(`typescript@${typescriptVersion}`);\n    }\n\n    const fetchTask = project.addTask(\"fetch\", {\n      exec: `mkdir -p src && rm -rf ./src/* && cdktf get && cp -R .gen/providers/${providerName}/* ./src/ && cp .gen/versions.json ./src/version.json`,\n      env: {\n        CHECKPOINT_DISABLE: \"1\",\n      },\n    });\n    // execute projen after fetch to ensure that updates to version.json are picked up in package.json\n    fetchTask.spawn(project.tasks.tryFind(\"default\")!);\n\n    project.setScript(\n      \"commit\",\n      'git add -A && git commit -am \"Update provider\" || echo \"No changes to commit\"'\n    );\n    // eslint-disable-next-line quotes\n    project.setScript(\n      \"should-release\",\n      `! git diff --exit-code v$(cat version.json | jq -r '.version') ./src ./package.json`\n    );\n    project.setScript(\n      \"prebump\",\n      \"yarn fetch && yarn compile && yarn run commit && yarn run should-release\"\n    );\n    project.setScript(\"compile\", \"jsii --silence-warnings=reserved-word\");\n\n    project.setScript(\n      \"build-provider\",\n      \"yarn fetch && yarn compile && yarn docgen\"\n    );\n    project.setScript(\"test\", \"jest --passWithNoTests\");\n    project.addFields({ publishConfig: { access: \"public\" } });\n    project.addFields({\n      \"standard-version\": {\n        types: [\n          {\n            type: \"feat\",\n            section: \"Features\",\n          },\n          {\n            type: \"fix\",\n            section: \"Bug Fixes\",\n          },\n          {\n            type: \"chore\",\n            section: \"Updates\",\n          },\n          {\n            type: \"docs\",\n            hidden: true,\n          },\n          {\n            type: \"style\",\n            hidden: true,\n          },\n          {\n            type: \"refactor\",\n            hidden: true,\n          },\n          {\n            type: \"perf\",\n            hidden: true,\n          },\n          {\n            type: \"test\",\n            hidden: true,\n          },\n        ],\n      },\n    });\n\n    // set provider name and version from version.json (if it exists yet)\n    const versionFile = path.resolve(project.outdir, \"src/version.json\");\n\n    let fullyQualifiedProviderName = \"<unknown>\";\n    let actualProviderVersion = \"<unknown>\";\n    if (existsSync(versionFile)) {\n      const map = JSON.parse(readFileSync(versionFile, \"utf8\"));\n      if (Object.keys(map).length !== 1) {\n        throw new Error(\n          \"version.json must have exactly one entry. specifying multiple providers is not supported\"\n        );\n      }\n      const [fqpn, version] = Object.entries(map)[0];\n      fullyQualifiedProviderName = fqpn;\n      actualProviderVersion = version as string;\n    }\n\n    project.addFields({\n      cdktf: {\n        isDeprecated,\n        provider: {\n          name: fullyQualifiedProviderName,\n          version: actualProviderVersion,\n        },\n      },\n    });\n\n    if (project.npmignore) {\n      project.npmignore.exclude(CDKTF_JSON_FILE);\n      project.npmignore.exclude(\".gen\");\n      project.npmignore.exclude(\".terraform\");\n      project.npmignore.exclude(\"cdktf.json\");\n      project.npmignore.exclude(\"API.md\");\n      project.npmignore.exclude(\"docs\");\n      project.npmignore.exclude(\"scripts\");\n      project.npmignore.exclude(\".projenrc.js\");\n      project.npmignore.exclude(\".copywrite.hcl\");\n    }\n    project.gitignore.exclude(\".gen\");\n    project.gitignore.exclude(\".terraform\");\n    project.gitignore.exclude(\"package-lock.json\");\n\n    new JsonFile(project, CDKTF_JSON_FILE, {\n      obj: {\n        language: \"typescript\",\n        app: \"echo noop\",\n        sendCrashReports: false,\n        terraformProviders: [terraformProvider],\n      },\n    });\n\n    new ReadmeFile(project, \"README.md\", {\n      ...options,\n      underlyingTerraformVersion: actualProviderVersion,\n    });\n  }\n}\n"]}

package/lib/copyright-headers.d.ts

@@ -0,0 +1,4 @@
+import { cdk } from "projen";
+export declare class CopyrightHeaders {
+    constructor(project: cdk.JsiiProject);
+}

package/lib/copyright-headers.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyrightHeaders = void 0;
+const projen_1 = require("projen");
+class CopyrightHeaders {
+    constructor(project) {
+        // Run copywrite tool to add copyright headers to all files
+        // This runs on individual repositories that use this Projen template
+        project.buildWorkflow?.addPostBuildSteps({
+            name: "Setup Copywrite tool",
+            uses: "hashicorp/setup-copywrite",
+        }, { name: "Add headers using Copywrite tool", run: "copywrite headers" });
+        // copywrite config for the individual pre-built providers
+        new projen_1.TextFile(project, ".copywrite.hcl", {
+            lines: `schema_version = 1
+
+project {
+  license        = "MPL-2.0"
+  copyright_year = 2021
+
+  # (OPTIONAL) A list of globs that should not have copyright/license headers.
+  # Supports doublestar glob patterns for more flexibility in defining which
+  # files or folders should be ignored
+  header_ignore = [
+    "**/node_modules/**",
+    "lib/**",
+    "dist/**",
+    "logs/**",
+    "build/**",
+    ".gen/**",
+    ".github/ISSUE_TEMPLATE/**",
+    ".terraform/**",
+    "docs/**",
+    "API.md",
+    ".mergify.yml",
+    "scripts/*.js"
+  ]
+}
+`.split("\n"),
+        });
+    }
+}
+exports.CopyrightHeaders = CopyrightHeaders;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29weXJpZ2h0LWhlYWRlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29weXJpZ2h0LWhlYWRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsbUNBQXVDO0FBRXZDLE1BQWEsZ0JBQWdCO0lBQzNCLFlBQVksT0FBd0I7UUFDbEMsMkRBQTJEO1FBQzNELHFFQUFxRTtRQUNyRSxPQUFPLENBQUMsYUFBYSxFQUFFLGlCQUFpQixDQUN0QztZQUNFLElBQUksRUFBRSxzQkFBc0I7WUFDNUIsSUFBSSxFQUFFLDJCQUEyQjtTQUNsQyxFQUNELEVBQUUsSUFBSSxFQUFFLGtDQUFrQyxFQUFFLEdBQUcsRUFBRSxtQkFBbUIsRUFBRSxDQUN2RSxDQUFDO1FBRUYsMERBQTBEO1FBQzFELElBQUksaUJBQVEsQ0FBQyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUU7WUFDdEMsS0FBSyxFQUFFOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0F3QlosQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDO1NBQ1IsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGO0FBekNELDRDQXlDQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNkaywgVGV4dEZpbGUgfSBmcm9tIFwicHJvamVuXCI7XG5cbmV4cG9ydCBjbGFzcyBDb3B5cmlnaHRIZWFkZXJzIHtcbiAgY29uc3RydWN0b3IocHJvamVjdDogY2RrLkpzaWlQcm9qZWN0KSB7XG4gICAgLy8gUnVuIGNvcHl3cml0ZSB0b29sIHRvIGFkZCBjb3B5cmlnaHQgaGVhZGVycyB0byBhbGwgZmlsZXNcbiAgICAvLyBUaGlzIHJ1bnMgb24gaW5kaXZpZHVhbCByZXBvc2l0b3JpZXMgdGhhdCB1c2UgdGhpcyBQcm9qZW4gdGVtcGxhdGVcbiAgICBwcm9qZWN0LmJ1aWxkV29ya2Zsb3c/LmFkZFBvc3RCdWlsZFN0ZXBzKFxuICAgICAge1xuICAgICAgICBuYW1lOiBcIlNldHVwIENvcHl3cml0ZSB0b29sXCIsXG4gICAgICAgIHVzZXM6IFwiaGFzaGljb3JwL3NldHVwLWNvcHl3cml0ZVwiLFxuICAgICAgfSxcbiAgICAgIHsgbmFtZTogXCJBZGQgaGVhZGVycyB1c2luZyBDb3B5d3JpdGUgdG9vbFwiLCBydW46IFwiY29weXdyaXRlIGhlYWRlcnNcIiB9XG4gICAgKTtcblxuICAgIC8vIGNvcHl3cml0ZSBjb25maWcgZm9yIHRoZSBpbmRpdmlkdWFsIHByZS1idWlsdCBwcm92aWRlcnNcbiAgICBuZXcgVGV4dEZpbGUocHJvamVjdCwgXCIuY29weXdyaXRlLmhjbFwiLCB7XG4gICAgICBsaW5lczogYHNjaGVtYV92ZXJzaW9uID0gMVxuXG5wcm9qZWN0IHtcbiAgbGljZW5zZSAgICAgICAgPSBcIk1QTC0yLjBcIlxuICBjb3B5cmlnaHRfeWVhciA9IDIwMjFcblxuICAjIChPUFRJT05BTCkgQSBsaXN0IG9mIGdsb2JzIHRoYXQgc2hvdWxkIG5vdCBoYXZlIGNvcHlyaWdodC9saWNlbnNlIGhlYWRlcnMuXG4gICMgU3VwcG9ydHMgZG91Ymxlc3RhciBnbG9iIHBhdHRlcm5zIGZvciBtb3JlIGZsZXhpYmlsaXR5IGluIGRlZmluaW5nIHdoaWNoXG4gICMgZmlsZXMgb3IgZm9sZGVycyBzaG91bGQgYmUgaWdub3JlZFxuICBoZWFkZXJfaWdub3JlID0gW1xuICAgIFwiKiovbm9kZV9tb2R1bGVzLyoqXCIsXG4gICAgXCJsaWIvKipcIixcbiAgICBcImRpc3QvKipcIixcbiAgICBcImxvZ3MvKipcIixcbiAgICBcImJ1aWxkLyoqXCIsXG4gICAgXCIuZ2VuLyoqXCIsXG4gICAgXCIuZ2l0aHViL0lTU1VFX1RFTVBMQVRFLyoqXCIsXG4gICAgXCIudGVycmFmb3JtLyoqXCIsXG4gICAgXCJkb2NzLyoqXCIsXG4gICAgXCJBUEkubWRcIixcbiAgICBcIi5tZXJnaWZ5LnltbFwiLFxuICAgIFwic2NyaXB0cy8qLmpzXCJcbiAgXVxufVxuYC5zcGxpdChcIlxcblwiKSxcbiAgICB9KTtcbiAgfVxufVxuIl19