@cdktn/provider-project 0.7.24

package/lib/index.js

@@ -0,0 +1,447 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdktnProviderProject = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/* eslint-disable @typescript-eslint/no-require-imports */
+const assert = require("assert");
+const change_case_1 = require("change-case");
+const projen_1 = require("projen");
+const javascript_1 = require("projen/lib/javascript");
+const alert_open_prs_1 = require("./alert-open-prs");
+const auto_approve_1 = require("./auto-approve");
+const auto_close_community_issues_1 = require("./auto-close-community-issues");
+const automerge_1 = require("./automerge");
+const cdktf_config_1 = require("./cdktf-config");
+const copyright_headers_1 = require("./copyright-headers");
+const customized_license_1 = require("./customized-license");
+const dependabot_1 = require("./dependabot");
+const deprecate_packages_1 = require("./deprecate-packages");
+const force_release_1 = require("./force-release");
+const github_issues_1 = require("./github-issues");
+const lock_issues_1 = require("./lock-issues");
+const provider_upgrade_1 = require("./provider-upgrade");
+const check_for_upgrades_1 = require("./scripts/check-for-upgrades");
+const should_release_1 = require("./scripts/should-release");
+const random_cron_1 = require("./util/random-cron");
+// ensure new projects start with 1.0.0 so that every following breaking change leads to an increased major version
+const MIN_MAJOR_VERSION = 1;
+const getMavenName = (providerName) => {
+    return ["null", "random"].includes(providerName)
+        ? `${providerName}_provider`
+        : providerName.replace(/-/gi, "_");
+};
+const githubActionPinnedVersions = {
+    "actions/checkout": "11bd71901bbe5b1630ceea73d27597364c9af683", // v4.2.2
+    "actions/download-artifact": "95815c38cf2ff2164869cbab79da8d1f422bc89e", // v4.2.1
+    "actions/github-script": "60a0d83039c74a4aee543508d2ffcb1c3799cdea", // v7.0.1
+    "actions/setup-dotnet": "67a3573c9a986a3f9c594539f4ab511d57bb3ce9", // v4.3.1
+    "actions/setup-go": "0aaccfd150d50ccaeb58ebd88d36e91967a5f35b", // v5.4.0
+    "actions/setup-java": "3a4f6e1af504cf6a31855fa899c6aa5355ba6c12", // v4.7.0
+    "actions/setup-node": "cdca7365b2dadb8aad0a33bc7601856ffabcc48e", // v4.3.0
+    "actions/setup-python": "42375524e23c412d93fb67b49958b491fce71c38", // v5.4.0
+    "actions/stale": "5bef64f19d7facfb25b37b414482c7164d639639", // v9.1.0
+    "actions/upload-artifact": "ea165f8d65b6e75b540449e92b4886f43607fa02", // v4.6.2
+    "amannn/action-semantic-pull-request": "0723387faaf9b38adef4775cd42cfd5155ed6017", // v5.5.3
+    "dessant/lock-threads": "1bf7ec25051fe7c00bdd17e6a7cf3d7bfb7dc771", // v5.0.1
+    "hashicorp/setup-copywrite": "32638da2d4e81d56a0764aa1547882fc4d209636", // v1.1.3
+    "hashicorp/setup-terraform": "b9cd54a3c349d3f38e8881555d616ced269862dd", // v3.1.2
+    "imjohnbo/issue-bot": "572eed14422c4d6ca37e870f97e7da209422f5bd", // v3.4.4
+    "peter-evans/create-pull-request": "271a8d0340265f705b14b6d32b9829c1cb33d45e", // v7.0.8
+    "slackapi/slack-github-action": "485a9d42d3a73031f12ec201c457e2162c45d02d", // v2.0.0
+};
+class CdktnProviderProject extends projen_1.cdk.JsiiProject {
+    constructor(options) {
+        const { terraformProvider, workflowContainerImage, cdktfVersion, constructsVersion, minNodeVersion, jsiiVersion, typescriptVersion, isDeprecated, deprecationDate, 
+        // TODO: Confirm default Author Name
+        authorName = "CDK Terrain Maintainers", authorAddress = "https://cdktn.io", namespace = "cdktn", githubNamespace = "cdktn-io", mavenEndpoint = "https://central.sonatype.com", // TODO
+        nugetOrg = "Io.Cdktn", // TODO
+        mavenOrg = "Io.Cdktn", // TODO
+         } = options;
+        const [fqproviderName, providerVersion] = terraformProvider.split("@");
+        const providerName = fqproviderName.split("/").pop();
+        assert(providerName, `${terraformProvider} doesn't seem to be valid`);
+        assert(!providerName.endsWith("-go"), "providerName may not end with '-go' as this can conflict with repos for go packages");
+        const nugetName = `${nugetOrg}.${(0, change_case_1.pascalCase)(namespace)}.Providers.${(0, change_case_1.pascalCase)(providerName)}`;
+        const mavenGroupId = options.mavenGroupId ?? `com.${mavenOrg}`;
+        const mavenName = `${mavenGroupId}.${namespace}.providers.${getMavenName(providerName)}`;
+        const repository = `${githubNamespace}/${namespace}-provider-${providerName.replace(/-/g, "")}`;
+        const repositoryUrl = `github.com/${repository}`;
+        const packageInfo = {
+            npm: {
+                name: `@${namespace}/provider-${providerName}`,
+            },
+            python: {
+                // distName: `${githubNamespace}-${namespace}-provider-${providerName.replace(
+                distName: `${namespace}-provider-${providerName.replace(/-/gi, "_")}`,
+                // module: `${githubNamespace}_${namespace}_provider_${providerName.replace(
+                module: `${namespace}_provider_${providerName.replace(/-/gi, "_")}`,
+            },
+            publishToNuget: {
+                dotNetNamespace: nugetName,
+                packageId: nugetName,
+            },
+            publishToMaven: {
+                javaPackage: mavenName,
+                mavenGroupId: mavenGroupId,
+                mavenArtifactId: `${namespace}-provider-${providerName}`,
+                mavenEndpoint,
+            },
+            publishToGo: {
+                moduleName: `${repositoryUrl}-go`,
+                gitUserEmail: "github-team-cdk-terrain@cdktn.io",
+                gitUserName: "team-cdk-terrain",
+                packageName: providerName.replace(/-/g, ""),
+                // In order to use the copywrite action, we need to rebuild the full pre-publish steps workflow unfortunately
+                // If someone knows a better way to do this mutation with minimal custom code, please do so
+                prePublishSteps: [
+                    {
+                        name: "Checkout",
+                        uses: "actions/checkout",
+                        with: {
+                            path: ".repo",
+                        },
+                    },
+                    {
+                        name: "Install Dependencies",
+                        run: "cd .repo && yarn install --check-files --frozen-lockfile",
+                    },
+                    {
+                        name: "Extract build artifact",
+                        run: "tar --strip-components=1 -xzvf dist/js/*.tgz -C .repo",
+                    },
+                    {
+                        name: "Move build artifact out of the way",
+                        run: "mv dist dist.old",
+                    },
+                    {
+                        name: "Create go artifact",
+                        run: "cd .repo && npx projen package:go",
+                    },
+                    {
+                        name: "Setup Copywrite tool",
+                        uses: "hashicorp/setup-copywrite",
+                    },
+                    {
+                        name: "Copy copywrite hcl file",
+                        run: "cp .repo/.copywrite.hcl .repo/dist/go/.copywrite.hcl",
+                    },
+                    {
+                        name: "Add headers using Copywrite tool",
+                        run: "cd .repo/dist/go && copywrite headers",
+                    },
+                    {
+                        name: "Remove copywrite hcl file",
+                        run: "rm -f .repo/dist/go/.copywrite.hcl",
+                    },
+                    {
+                        name: "Remove some text from the README that doesn't apply to Go",
+                        run: [
+                            "sed -i 's/# CDKTF prebuilt bindings for/# CDKTF Go bindings for/' .repo/dist/go/*/README.md",
+                            // @see https://stackoverflow.com/a/49511949
+                            // eslint-disable-next-line prettier/prettier
+                            // prettier-ignore
+                            `sed -i -e '/## ${isDeprecated ? "Deprecated" : "Available"} Packages/,/### Go/!b' -e '/### Go/!d;p; s/### Go/## Go Package/' -e 'd' .repo/dist/go/*/README.md`,
+                            // sed -e is black magic and for whatever reason the string replace doesn't work so let's try it again:
+                            // eslint-disable-next-line prettier/prettier
+                            // prettier-ignore
+                            `sed -i 's/### Go/## ${isDeprecated ? "Deprecated" : "Go"} Package/' .repo/dist/go/*/README.md`,
+                            // Just straight up delete these full lines and everything in between them:
+                            "sed -i -e '/API.typescript.md/,/You can also visit a hosted version/!b' -e 'd' .repo/dist/go/*/README.md",
+                            `sed -i 's|Find auto-generated docs for this provider here:|Find auto-generated docs for this provider [here](https://${repositoryUrl}/blob/main/docs/API.go.md).|' .repo/dist/go/*/README.md`,
+                            // Just straight up delete these full lines and everything in between them:
+                            "sed -i -e '/### Provider Version/,/The provider version can be adjusted/!b' -e 'd' .repo/dist/go/*/README.md",
+                        ].join("\n"),
+                    },
+                    {
+                        name: "Copy the README file to the parent directory",
+                        run: "cp .repo/dist/go/*/README.md .repo/dist/go/README.md",
+                    },
+                    {
+                        name: "Collect go Artifact",
+                        run: "mv .repo/dist dist",
+                    },
+                ],
+            },
+        };
+        const workflowRunsOn = options.useCustomGithubRunner
+            ? ["custom-linux-medium"] // 8 core, 32 GB
+            : ["ubuntu-latest"]; // 7 GB
+        super({
+            ...options,
+            authorAddress,
+            authorName,
+            minNodeVersion,
+            workflowContainerImage,
+            workflowRunsOn,
+            licensed: false, // we do supply our own license file with a custom header
+            releaseToNpm: true,
+            name: packageInfo.npm.name,
+            description: `Prebuilt ${providerName} Provider for Terraform CDK (cdktf)`,
+            keywords: ["cdktf", "terraform", "cdk", "provider", providerName],
+            sampleCode: false,
+            jest: false,
+            authorOrganization: true,
+            defaultReleaseBranch: "main",
+            repository: `https://github.com/${repository}.git`,
+            mergify: false,
+            eslint: false,
+            depsUpgrade: !isDeprecated,
+            depsUpgradeOptions: {
+                workflowOptions: {
+                    labels: ["automerge", "auto-approve", "dependencies"],
+                    schedule: javascript_1.UpgradeDependenciesSchedule.WEEKLY,
+                },
+            },
+            python: packageInfo.python,
+            // TODO: Re-enable if requested and when available
+            // publishToNuget: packageInfo.publishToNuget,
+            // publishToMaven: packageInfo.publishToMaven,
+            publishToGo: packageInfo.publishToGo,
+            releaseFailureIssue: true,
+            peerDependencyOptions: {
+                pinnedDevDependency: false,
+            },
+            workflowGitIdentity: {
+                name: "team-cdk-terrain",
+                email: "github-team-cdk-terrain@cdktn.io",
+            },
+            minMajorVersion: MIN_MAJOR_VERSION,
+            stale: true,
+            staleOptions: {
+                issues: {
+                    staleLabel: "stale",
+                    daysBeforeStale: 45,
+                    staleMessage: "45 days have passed since this issue was opened, and I assume other publishes have succeeded in the meantime. " +
+                        "If no one removes the `stale` label or comments, I'm going to auto-close this issue in 14 days.",
+                    daysBeforeClose: 14,
+                    closeMessage: "2 months have passed, so I'm closing this issue with the assumption that other publishes have succeeded in the meantime.",
+                },
+                pullRequest: {
+                    staleLabel: "stale",
+                    daysBeforeStale: 1,
+                    staleMessage: `Closing this PR, if it has not merged there is most likely a CI or CDKTF issue preventing it from merging. If this has been a manual PR, please reopen it and add the \`no-auto-close\` label to prevent this from happening again.`,
+                    daysBeforeClose: 0,
+                    exemptLabels: ["no-auto-close"],
+                },
+            },
+            pullRequestTemplate: false,
+            docgen: false,
+        });
+        this.addDevDeps("dot-prop@^5.2.0", "@actions/core@^1.1.0", "@action-validator/core", "@action-validator/cli");
+        // Default memory is 7GB: https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#supported-runners-and-hardware-resources
+        // Custom Runners we use have 32GB of memory
+        // The below numbers set heap limits that are ~1gb and ~0.5gb less, respectively, than the total available memory
+        const maxOldSpaceSize = options.useCustomGithubRunner ? "31744" : "6656";
+        // Golang needs more memory to build
+        this.tasks.addEnvironment("NODE_OPTIONS", `--max-old-space-size=${maxOldSpaceSize}`);
+        this.tasks.addEnvironment("CHECKPOINT_DISABLE", "1");
+        const validateTask = this.addTask("validate-workflows", {
+            exec: `find ./.github/workflows -type f -name "*.yml" -print0 | xargs -0 -n 1 npx action-validator`,
+        });
+        validateTask.description =
+            "Lint the YAML files generated by Projen to define GitHub Actions and Workflows, checking them against published JSON schemas";
+        this.postCompileTask.spawn(validateTask);
+        this.package.addPackageResolutions("@types/yargs@17.0.13");
+        const setSafeDirectory = {
+            name: "Set git config safe.directory",
+            run: "git config --global --add safe.directory $(pwd)",
+        };
+        this.buildWorkflow.preBuildSteps.push(setSafeDirectory);
+        this.release.defaultBranch.workflow.jobs.release.steps.splice(1, 0, setSafeDirectory);
+        // always publish a new GitHub release, even when publishing to a particular package manager fails
+        const releaseWorkflow = this.tryFindObjectFile(".github/workflows/release.yml");
+        releaseWorkflow?.addOverride("jobs.release_github.needs", "release");
+        // ensure we don't fail if the release file is not present
+        const checkExistingTagStep = this.release.defaultBranch.workflow.jobs.release.steps.find((s) => "id" in s && s.id === "check_tag_exists");
+        const oldExistingTagRun = checkExistingTagStep.run;
+        prettyAssertEqual(oldExistingTagRun.split("\n")[0], "TAG=$(cat dist/releasetag.txt)", "release step changed, please check if the workaround still works!");
+        checkExistingTagStep.run = `if [ ! -f dist/releasetag.txt ]; then (echo "exists=true" >> $GITHUB_OUTPUT) && exit 0; fi\n${oldExistingTagRun}`;
+        if (!isDeprecated) {
+            const { upgrade, pr } = this.upgradeWorkflow.workflows[0].jobs;
+            upgrade.steps.splice(1, 0, setSafeDirectory);
+            pr.steps.splice(1, 0, setSafeDirectory);
+        }
+        // // TODO: Re-enable when Maven requested and infra available
+        // // Fix maven issue (https://github.com/cdklabs/publib/pull/777)
+        // github.GitHub.of(this)?.tryFindWorkflow("release")?.file?.patch(
+        //   JsonPatch.add(
+        //     "/jobs/release_maven/steps/10/env/MAVEN_OPTS",
+        //     // See https://stackoverflow.com/questions/70153962/nexus-staging-maven-plugin-maven-deploy-failed-an-api-incompatibility-was-enco
+        //     "--add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.text=ALL-UNNAMED --add-opens=java.desktop/java.awt.font=ALL-UNNAMED"
+        //   )
+        // );
+        this.pinGithubActionVersions(githubActionPinnedVersions);
+        new cdktf_config_1.CdktfConfig(this, {
+            terraformProvider,
+            providerName,
+            fqproviderName,
+            providerVersion,
+            cdktfVersion,
+            constructsVersion,
+            jsiiVersion,
+            typescriptVersion,
+            packageInfo,
+            githubNamespace,
+            deprecationDate,
+            isDeprecated: !!isDeprecated,
+        });
+        new customized_license_1.CustomizedLicense(this, options.creationYear, options.licensee);
+        new github_issues_1.GithubIssues(this, { providerName });
+        new auto_approve_1.AutoApprove(this);
+        new auto_close_community_issues_1.AutoCloseCommunityIssues(this, { providerName });
+        new automerge_1.Automerge(this);
+        new lock_issues_1.LockIssues(this);
+        if (!isDeprecated) {
+            const upgradeScript = new check_for_upgrades_1.CheckForUpgradesScriptFile(this, {
+                providerVersion,
+                fqproviderName,
+            });
+            new provider_upgrade_1.ProviderUpgrade(this, {
+                checkForUpgradesScriptPath: upgradeScript.path,
+                workflowRunsOn,
+                nodeHeapSize: maxOldSpaceSize,
+            });
+            new alert_open_prs_1.AlertOpenPrs(this, {
+                slackWebhookUrl: "${{ secrets.ALERT_PRS_SLACK_WEBHOOK_URL }}",
+                repository,
+            });
+            new dependabot_1.Dependabot(this);
+        }
+        new projen_1.TextFile(this, ".github/CODEOWNERS", {
+            lines: [
+                "# These owners will be the default owners for everything in ",
+                "# the repo. Unless a later match takes precedence, ",
+                "# they will be requested for review when someone opens a ",
+                "# pull request.",
+                "*       @cdktn-io/team-cdk-terrain",
+            ],
+        });
+        if (!isDeprecated) {
+            new should_release_1.ShouldReleaseScriptFile(this, {});
+            const releaseTask = this.tasks.tryFind("release");
+            this.removeTask("release");
+            this.addTask("release", {
+                description: releaseTask.description,
+                steps: releaseTask.steps,
+                env: releaseTask._env,
+                condition: "node ./scripts/should-release.js",
+            });
+            this.addTask("unconditional-release", {
+                description: releaseTask.description,
+                steps: releaseTask.steps,
+                env: releaseTask._env,
+            });
+            const releaseJobSteps = (this.github?.tryFindWorkflow("release")).jobs.release.steps;
+            const gitRemoteJob = releaseJobSteps.find((it) => it.id === "git_remote");
+            prettyAssertEqual(gitRemoteJob.run, 'echo "latest_commit=$(git ls-remote origin -h ${{ github.ref }} | cut -f1)" >> $GITHUB_OUTPUT\ncat $GITHUB_OUTPUT', "git_remote step in release workflow did not match expected string, please check if the workaround still works!");
+            const previousCommand = gitRemoteJob.run.replace("\n", " && ");
+            const cancelCommand = 'echo "latest_commit=release_cancelled" >> $GITHUB_OUTPUT'; // this cancels the release via a non-matching SHA;
+            gitRemoteJob.run = `node ./scripts/should-release.js && (${previousCommand}) || ${cancelCommand}`;
+            gitRemoteJob.name +=
+                " or cancel via faking a SHA if release was cancelled";
+        }
+        const staleWorkflow = this.tryFindObjectFile(".github/workflows/stale.yml");
+        staleWorkflow?.addOverride("on.schedule", [
+            {
+                cron: (0, random_cron_1.generateRandomCron)({ project: this, maxHour: 4, hourOffset: 1 }),
+            },
+        ]);
+        const upgradeWorkflow = this.tryFindObjectFile(".github/workflows/upgrade-main.yml");
+        upgradeWorkflow?.addOverride("on.schedule", [
+            {
+                cron: (0, random_cron_1.generateRandomCron)({
+                    project: this,
+                    maxHour: 0,
+                    hourOffset: 1,
+                    schedule: random_cron_1.Schedule.Weekly,
+                }),
+            },
+        ]);
+        // Submodule documentation generation
+        this.gitignore.exclude("API.md"); // ignore the old file, we now generate it in the docs folder
+        this.addDevDeps("jsii-docgen@^10.2.3");
+        if (jsiiVersion) {
+            // NOTE: the below is making a broad assumption that you're passing a range like "~5.3.0" to jsiiVersion
+            // If you use that field to pass a very specific version (e.g. "5.3.11") then this might break
+            this.addDevDeps(`jsii-rosetta@${jsiiVersion}`);
+        }
+        else {
+            this.addDevDeps(`jsii-rosetta`);
+        }
+        const docgen = this.addTask("docgen", {
+            description: "Generate documentation for the project",
+            steps: [
+                {
+                    exec: [
+                        "rm -rf docs",
+                        "rm -f API.md",
+                        "mkdir docs",
+                        // TODO: Re-enable java / csharp
+                        // "jsii-docgen --split-by-submodule -l typescript -l python -l java -l csharp -l go",
+                        "jsii-docgen --split-by-submodule -l typescript -l python -l go",
+                        // There is no nice way to tell jsii-docgen to generate docs into a folder so I went this route
+                        "mv *.*.md docs",
+                        // Some part of the documentation are too long, we need to truncate them to ~10MB
+                        "cd docs",
+                        "ls ./ | xargs sed -i '150000,$ d' $1",
+                    ].join(" && "),
+                },
+            ],
+        });
+        this.postCompileTask.spawn(docgen);
+        this.gitignore.include(`/docs/*.md`);
+        this.annotateGenerated(`/docs/*.md`);
+        // Setting the version in package.json so the golang docs have the correct version
+        const unconditionalBump = this.addTask("unconditional-bump", {
+            description: "Set the version in package.json to the current version",
+            steps: [
+                {
+                    name: "Clear the changelog so that it doesn't get published twice",
+                    exec: "rm -f $CHANGELOG",
+                },
+                { builtin: "release/bump-version" },
+            ],
+            env: {
+                OUTFILE: "package.json",
+                CHANGELOG: "dist/changelog.md",
+                BUMPFILE: "dist/version.txt",
+                RELEASETAG: "dist/releasetag.txt",
+                RELEASE_TAG_PREFIX: "",
+                MIN_MAJOR: String(MIN_MAJOR_VERSION),
+            },
+        });
+        this.preCompileTask.spawn(unconditionalBump);
+        // To bump correctly we need to have the completely cloned repo
+        this.buildWorkflow.workflow.file.addOverride("jobs.build.steps.0.with.fetch-depth", 0);
+        // Undo the changes after compilation
+        this.buildWorkflow?.addPostBuildSteps({
+            name: "Revert package.json version bump",
+            run: "git checkout package.json",
+        });
+        new copyright_headers_1.CopyrightHeaders(this);
+        new deprecate_packages_1.DeprecatePackages(this, {
+            providerName,
+            packageInfo,
+            isDeprecated: !!isDeprecated,
+        });
+        if (!isDeprecated) {
+            new force_release_1.ForceRelease(this, { workflowRunsOn });
+        }
+    }
+    pinGithubActionVersions(pinnedVersions) {
+        // Use pinned versions of github actions
+        Object.entries(pinnedVersions).forEach(([name, sha]) => {
+            this.github?.actions.set(name, `${name}@${sha}`);
+        });
+    }
+}
+exports.CdktnProviderProject = CdktnProviderProject;
+_a = JSII_RTTI_SYMBOL_1;
+CdktnProviderProject[_a] = { fqn: "@cdktn/provider-project.CdktnProviderProject", version: "0.7.24" };
+function prettyAssertEqual(subject, expected, message) {
+    if (subject !== expected) {
+        throw new Error(`${message ?? "Assertion failed"}: expected ${JSON.stringify(expected)} but got ${JSON.stringify(subject)}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-require-imports */\nimport assert = require(\"assert\");\nimport { pascalCase } from \"change-case\";\nimport { TextFile, cdk } from \"projen\";\nimport { JobStep } from \"projen/lib/github/workflows-model\";\nimport { UpgradeDependenciesSchedule } from \"projen/lib/javascript\";\nimport { AlertOpenPrs } from \"./alert-open-prs\";\nimport { AutoApprove } from \"./auto-approve\";\nimport { AutoCloseCommunityIssues } from \"./auto-close-community-issues\";\nimport { Automerge } from \"./automerge\";\nimport { CdktfConfig } from \"./cdktf-config\";\nimport { CopyrightHeaders } from \"./copyright-headers\";\nimport { CustomizedLicense } from \"./customized-license\";\nimport { Dependabot } from \"./dependabot\";\nimport { DeprecatePackages } from \"./deprecate-packages\";\nimport { ForceRelease } from \"./force-release\";\nimport { GithubIssues } from \"./github-issues\";\nimport { LockIssues } from \"./lock-issues\";\nimport { PackageInfo } from \"./package-info\";\nimport { ProviderUpgrade } from \"./provider-upgrade\";\nimport { CheckForUpgradesScriptFile } from \"./scripts/check-for-upgrades\";\nimport { ShouldReleaseScriptFile } from \"./scripts/should-release\";\nimport { generateRandomCron, Schedule } from \"./util/random-cron\";\n\n// ensure new projects start with 1.0.0 so that every following breaking change leads to an increased major version\nconst MIN_MAJOR_VERSION = 1;\n\nexport interface CdktnProviderProjectOptions extends cdk.JsiiProjectOptions {\n  readonly useCustomGithubRunner?: boolean;\n  readonly terraformProvider: string;\n  readonly cdktfVersion: string;\n  readonly constructsVersion: string;\n  readonly forceMajorVersion?: number;\n  /**\n   * defaults to \"cdktn\"\n   */\n  readonly namespace?: string;\n  /**\n   * defaults to \"cdktn-io\"\n   * previously was \"cdktf\". Used for GitHub org name and package scoping\n   */\n  readonly githubNamespace?: string;\n  readonly mavenEndpoint?: string;\n  /**\n   * defaults to \"Io.Cdktn\"\n   */\n  readonly nugetOrg?: string;\n  /**\n   * defaults to \"cdktn\"\n   */\n  readonly mavenOrg?: string;\n  /**\n   * defaults to \"io.${mavenOrg}\"\n   */\n  readonly mavenGroupId?: string;\n  /**\n   * The year of the creation of the repository, for copyright purposes.\n   * Will fall back to the current year if not specified.\n   */\n  readonly creationYear?: number;\n  /**\n   * Whether or not this prebuilt provider is deprecated.\n   * If true, no new versions will be published.\n   */\n  readonly isDeprecated?: boolean;\n  /**\n   * An optional date when the project should be considered deprecated, to be used in the README text.\n   * If no date is provided, then the date of the build will be used by default.\n   */\n  readonly deprecationDate?: string;\n  /**\n   * defaults to \"HashiCorp, Inc.\"\n   */\n  readonly licensee?: string;\n}\n\nconst getMavenName = (providerName: string): string => {\n  return [\"null\", \"random\"].includes(providerName)\n    ? `${providerName}_provider`\n    : providerName.replace(/-/gi, \"_\");\n};\n\nconst githubActionPinnedVersions = {\n  \"actions/checkout\": \"11bd71901bbe5b1630ceea73d27597364c9af683\", // v4.2.2\n  \"actions/download-artifact\": \"95815c38cf2ff2164869cbab79da8d1f422bc89e\", // v4.2.1\n  \"actions/github-script\": \"60a0d83039c74a4aee543508d2ffcb1c3799cdea\", // v7.0.1\n  \"actions/setup-dotnet\": \"67a3573c9a986a3f9c594539f4ab511d57bb3ce9\", // v4.3.1\n  \"actions/setup-go\": \"0aaccfd150d50ccaeb58ebd88d36e91967a5f35b\", // v5.4.0\n  \"actions/setup-java\": \"3a4f6e1af504cf6a31855fa899c6aa5355ba6c12\", // v4.7.0\n  \"actions/setup-node\": \"cdca7365b2dadb8aad0a33bc7601856ffabcc48e\", // v4.3.0\n  \"actions/setup-python\": \"42375524e23c412d93fb67b49958b491fce71c38\", // v5.4.0\n  \"actions/stale\": \"5bef64f19d7facfb25b37b414482c7164d639639\", // v9.1.0\n  \"actions/upload-artifact\": \"ea165f8d65b6e75b540449e92b4886f43607fa02\", // v4.6.2\n  \"amannn/action-semantic-pull-request\":\n    \"0723387faaf9b38adef4775cd42cfd5155ed6017\", // v5.5.3\n  \"dessant/lock-threads\": \"1bf7ec25051fe7c00bdd17e6a7cf3d7bfb7dc771\", // v5.0.1\n  \"hashicorp/setup-copywrite\": \"32638da2d4e81d56a0764aa1547882fc4d209636\", // v1.1.3\n  \"hashicorp/setup-terraform\": \"b9cd54a3c349d3f38e8881555d616ced269862dd\", // v3.1.2\n  \"imjohnbo/issue-bot\": \"572eed14422c4d6ca37e870f97e7da209422f5bd\", // v3.4.4\n  \"peter-evans/create-pull-request\": \"271a8d0340265f705b14b6d32b9829c1cb33d45e\", // v7.0.8\n  \"slackapi/slack-github-action\": \"485a9d42d3a73031f12ec201c457e2162c45d02d\", // v2.0.0\n};\n\nexport class CdktnProviderProject extends cdk.JsiiProject {\n  constructor(options: CdktnProviderProjectOptions) {\n    const {\n      terraformProvider,\n      workflowContainerImage,\n      cdktfVersion,\n      constructsVersion,\n      minNodeVersion,\n      jsiiVersion,\n      typescriptVersion,\n      isDeprecated,\n      deprecationDate,\n      // TODO: Confirm default Author Name\n      authorName = \"CDK Terrain Maintainers\",\n      authorAddress = \"https://cdktn.io\",\n      namespace = \"cdktn\",\n      githubNamespace = \"cdktn-io\",\n      mavenEndpoint = \"https://central.sonatype.com\", // TODO\n      nugetOrg = \"Io.Cdktn\", // TODO\n      mavenOrg = \"Io.Cdktn\", // TODO\n    } = options;\n\n    const [fqproviderName, providerVersion] = terraformProvider.split(\"@\");\n    const providerName = fqproviderName.split(\"/\").pop();\n    assert(providerName, `${terraformProvider} doesn't seem to be valid`);\n    assert(\n      !providerName.endsWith(\"-go\"),\n      \"providerName may not end with '-go' as this can conflict with repos for go packages\"\n    );\n\n    const nugetName = `${nugetOrg}.${pascalCase(\n      namespace\n    )}.Providers.${pascalCase(providerName)}`;\n    const mavenGroupId = options.mavenGroupId ?? `com.${mavenOrg}`;\n    const mavenName = `${mavenGroupId}.${namespace}.providers.${getMavenName(\n      providerName\n    )}`;\n    const repository = `${githubNamespace}/${namespace}-provider-${providerName.replace(\n      /-/g,\n      \"\"\n    )}`;\n    const repositoryUrl = `github.com/${repository}`;\n\n    const packageInfo: PackageInfo = {\n      npm: {\n        name: `@${namespace}/provider-${providerName}`,\n      },\n      python: {\n        // distName: `${githubNamespace}-${namespace}-provider-${providerName.replace(\n        distName: `${namespace}-provider-${providerName.replace(/-/gi, \"_\")}`,\n        // module: `${githubNamespace}_${namespace}_provider_${providerName.replace(\n        module: `${namespace}_provider_${providerName.replace(/-/gi, \"_\")}`,\n      },\n      publishToNuget: {\n        dotNetNamespace: nugetName,\n        packageId: nugetName,\n      },\n      publishToMaven: {\n        javaPackage: mavenName,\n        mavenGroupId: mavenGroupId,\n        mavenArtifactId: `${namespace}-provider-${providerName}`,\n        mavenEndpoint,\n      },\n      publishToGo: {\n        moduleName: `${repositoryUrl}-go`,\n        gitUserEmail: \"github-team-cdk-terrain@cdktn.io\",\n        gitUserName: \"team-cdk-terrain\",\n        packageName: providerName.replace(/-/g, \"\"),\n        // In order to use the copywrite action, we need to rebuild the full pre-publish steps workflow unfortunately\n        // If someone knows a better way to do this mutation with minimal custom code, please do so\n        prePublishSteps: [\n          {\n            name: \"Checkout\",\n            uses: \"actions/checkout\",\n            with: {\n              path: \".repo\",\n            },\n          },\n          {\n            name: \"Install Dependencies\",\n            run: \"cd .repo && yarn install --check-files --frozen-lockfile\",\n          },\n          {\n            name: \"Extract build artifact\",\n            run: \"tar --strip-components=1 -xzvf dist/js/*.tgz -C .repo\",\n          },\n          {\n            name: \"Move build artifact out of the way\",\n            run: \"mv dist dist.old\",\n          },\n          {\n            name: \"Create go artifact\",\n            run: \"cd .repo && npx projen package:go\",\n          },\n          {\n            name: \"Setup Copywrite tool\",\n            uses: \"hashicorp/setup-copywrite\",\n          },\n          {\n            name: \"Copy copywrite hcl file\",\n            run: \"cp .repo/.copywrite.hcl .repo/dist/go/.copywrite.hcl\",\n          },\n          {\n            name: \"Add headers using Copywrite tool\",\n            run: \"cd .repo/dist/go && copywrite headers\",\n          },\n          {\n            name: \"Remove copywrite hcl file\",\n            run: \"rm -f .repo/dist/go/.copywrite.hcl\",\n          },\n          {\n            name: \"Remove some text from the README that doesn't apply to Go\",\n            run: [\n              \"sed -i 's/# CDKTF prebuilt bindings for/# CDKTF Go bindings for/' .repo/dist/go/*/README.md\",\n              // @see https://stackoverflow.com/a/49511949\n              // eslint-disable-next-line prettier/prettier\n              // prettier-ignore\n              `sed -i -e '/## ${isDeprecated ? \"Deprecated\" : \"Available\"} Packages/,/### Go/!b' -e '/### Go/!d;p; s/### Go/## Go Package/' -e 'd' .repo/dist/go/*/README.md`,\n              // sed -e is black magic and for whatever reason the string replace doesn't work so let's try it again:\n              // eslint-disable-next-line prettier/prettier\n              // prettier-ignore\n              `sed -i 's/### Go/## ${isDeprecated ? \"Deprecated\" : \"Go\"} Package/' .repo/dist/go/*/README.md`,\n              // Just straight up delete these full lines and everything in between them:\n              \"sed -i -e '/API.typescript.md/,/You can also visit a hosted version/!b' -e 'd' .repo/dist/go/*/README.md\",\n              `sed -i 's|Find auto-generated docs for this provider here:|Find auto-generated docs for this provider [here](https://${repositoryUrl}/blob/main/docs/API.go.md).|' .repo/dist/go/*/README.md`,\n              // Just straight up delete these full lines and everything in between them:\n              \"sed -i -e '/### Provider Version/,/The provider version can be adjusted/!b' -e 'd' .repo/dist/go/*/README.md\",\n            ].join(\"\\n\"),\n          },\n          {\n            name: \"Copy the README file to the parent directory\",\n            run: \"cp .repo/dist/go/*/README.md .repo/dist/go/README.md\",\n          },\n          {\n            name: \"Collect go Artifact\",\n            run: \"mv .repo/dist dist\",\n          },\n        ],\n      },\n    };\n\n    const workflowRunsOn = options.useCustomGithubRunner\n      ? [\"custom-linux-medium\"] // 8 core, 32 GB\n      : [\"ubuntu-latest\"]; // 7 GB\n\n    super({\n      ...options,\n      authorAddress,\n      authorName,\n      minNodeVersion,\n      workflowContainerImage,\n      workflowRunsOn,\n      licensed: false, // we do supply our own license file with a custom header\n      releaseToNpm: true,\n      name: packageInfo.npm.name,\n      description: `Prebuilt ${providerName} Provider for Terraform CDK (cdktf)`,\n      keywords: [\"cdktf\", \"terraform\", \"cdk\", \"provider\", providerName],\n      sampleCode: false,\n      jest: false,\n      authorOrganization: true,\n      defaultReleaseBranch: \"main\",\n      repository: `https://github.com/${repository}.git`,\n      mergify: false,\n      eslint: false,\n      depsUpgrade: !isDeprecated,\n      depsUpgradeOptions: {\n        workflowOptions: {\n          labels: [\"automerge\", \"auto-approve\", \"dependencies\"],\n          schedule: UpgradeDependenciesSchedule.WEEKLY,\n        },\n      },\n      python: packageInfo.python,\n      // TODO: Re-enable if requested and when available\n      // publishToNuget: packageInfo.publishToNuget,\n      // publishToMaven: packageInfo.publishToMaven,\n      publishToGo: packageInfo.publishToGo,\n      releaseFailureIssue: true,\n      peerDependencyOptions: {\n        pinnedDevDependency: false,\n      },\n      workflowGitIdentity: {\n        name: \"team-cdk-terrain\",\n        email: \"github-team-cdk-terrain@cdktn.io\",\n      },\n      minMajorVersion: MIN_MAJOR_VERSION,\n      stale: true,\n      staleOptions: {\n        issues: {\n          staleLabel: \"stale\",\n          daysBeforeStale: 45,\n          staleMessage:\n            \"45 days have passed since this issue was opened, and I assume other publishes have succeeded in the meantime. \" +\n            \"If no one removes the `stale` label or comments, I'm going to auto-close this issue in 14 days.\",\n          daysBeforeClose: 14,\n          closeMessage:\n            \"2 months have passed, so I'm closing this issue with the assumption that other publishes have succeeded in the meantime.\",\n        },\n        pullRequest: {\n          staleLabel: \"stale\",\n          daysBeforeStale: 1,\n          staleMessage: `Closing this PR, if it has not merged there is most likely a CI or CDKTF issue preventing it from merging. If this has been a manual PR, please reopen it and add the \\`no-auto-close\\` label to prevent this from happening again.`,\n          daysBeforeClose: 0,\n          exemptLabels: [\"no-auto-close\"],\n        },\n      },\n      pullRequestTemplate: false,\n      docgen: false,\n    });\n\n    this.addDevDeps(\n      \"dot-prop@^5.2.0\",\n      \"@actions/core@^1.1.0\",\n      \"@action-validator/core\",\n      \"@action-validator/cli\"\n    );\n\n    // Default memory is 7GB: https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners#supported-runners-and-hardware-resources\n    // Custom Runners we use have 32GB of memory\n    // The below numbers set heap limits that are ~1gb and ~0.5gb less, respectively, than the total available memory\n    const maxOldSpaceSize = options.useCustomGithubRunner ? \"31744\" : \"6656\";\n\n    // Golang needs more memory to build\n    this.tasks.addEnvironment(\n      \"NODE_OPTIONS\",\n      `--max-old-space-size=${maxOldSpaceSize}`\n    );\n\n    this.tasks.addEnvironment(\"CHECKPOINT_DISABLE\", \"1\");\n\n    const validateTask = this.addTask(\"validate-workflows\", {\n      exec: `find ./.github/workflows -type f -name \"*.yml\" -print0 | xargs -0 -n 1 npx action-validator`,\n    });\n    validateTask.description =\n      \"Lint the YAML files generated by Projen to define GitHub Actions and Workflows, checking them against published JSON schemas\";\n    this.postCompileTask.spawn(validateTask);\n\n    this.package.addPackageResolutions(\"@types/yargs@17.0.13\");\n\n    const setSafeDirectory = {\n      name: \"Set git config safe.directory\",\n      run: \"git config --global --add safe.directory $(pwd)\",\n    };\n\n    ((this.buildWorkflow as any).preBuildSteps as JobStep[]).push(\n      setSafeDirectory\n    );\n    (this.release as any).defaultBranch.workflow.jobs.release.steps.splice(\n      1,\n      0,\n      setSafeDirectory\n    );\n\n    // always publish a new GitHub release, even when publishing to a particular package manager fails\n    const releaseWorkflow = this.tryFindObjectFile(\n      \".github/workflows/release.yml\"\n    );\n    releaseWorkflow?.addOverride(\"jobs.release_github.needs\", \"release\");\n\n    // ensure we don't fail if the release file is not present\n    const checkExistingTagStep = (\n      this.release as any\n    ).defaultBranch.workflow.jobs.release.steps.find(\n      (s: object) => \"id\" in s && s.id === \"check_tag_exists\"\n    );\n    const oldExistingTagRun: string = checkExistingTagStep.run;\n    prettyAssertEqual(\n      oldExistingTagRun.split(\"\\n\")[0],\n      \"TAG=$(cat dist/releasetag.txt)\",\n      \"release step changed, please check if the workaround still works!\"\n    );\n    checkExistingTagStep.run = `if [ ! -f dist/releasetag.txt ]; then (echo \"exists=true\" >> $GITHUB_OUTPUT) && exit 0; fi\\n${oldExistingTagRun}`;\n\n    if (!isDeprecated) {\n      const { upgrade, pr } = (this.upgradeWorkflow as any).workflows[0].jobs;\n      upgrade.steps.splice(1, 0, setSafeDirectory);\n      pr.steps.splice(1, 0, setSafeDirectory);\n    }\n\n    // // TODO: Re-enable when Maven requested and infra available\n    // // Fix maven issue (https://github.com/cdklabs/publib/pull/777)\n    // github.GitHub.of(this)?.tryFindWorkflow(\"release\")?.file?.patch(\n    //   JsonPatch.add(\n    //     \"/jobs/release_maven/steps/10/env/MAVEN_OPTS\",\n    //     // See https://stackoverflow.com/questions/70153962/nexus-staging-maven-plugin-maven-deploy-failed-an-api-incompatibility-was-enco\n    //     \"--add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.text=ALL-UNNAMED --add-opens=java.desktop/java.awt.font=ALL-UNNAMED\"\n    //   )\n    // );\n\n    this.pinGithubActionVersions(githubActionPinnedVersions);\n\n    new CdktfConfig(this, {\n      terraformProvider,\n      providerName,\n      fqproviderName,\n      providerVersion,\n      cdktfVersion,\n      constructsVersion,\n      jsiiVersion,\n      typescriptVersion,\n      packageInfo,\n      githubNamespace,\n      deprecationDate,\n      isDeprecated: !!isDeprecated,\n    });\n    new CustomizedLicense(this, options.creationYear, options.licensee);\n    new GithubIssues(this, { providerName });\n    new AutoApprove(this);\n    new AutoCloseCommunityIssues(this, { providerName });\n    new Automerge(this);\n    new LockIssues(this);\n\n    if (!isDeprecated) {\n      const upgradeScript = new CheckForUpgradesScriptFile(this, {\n        providerVersion,\n        fqproviderName,\n      });\n      new ProviderUpgrade(this, {\n        checkForUpgradesScriptPath: upgradeScript.path,\n        workflowRunsOn,\n        nodeHeapSize: maxOldSpaceSize,\n      });\n      new AlertOpenPrs(this, {\n        slackWebhookUrl: \"${{ secrets.ALERT_PRS_SLACK_WEBHOOK_URL }}\",\n        repository,\n      });\n      new Dependabot(this);\n    }\n\n    new TextFile(this, \".github/CODEOWNERS\", {\n      lines: [\n        \"# These owners will be the default owners for everything in \",\n        \"# the repo. Unless a later match takes precedence, \",\n        \"# they will be requested for review when someone opens a \",\n        \"# pull request.\",\n        \"*       @cdktn-io/team-cdk-terrain\",\n      ],\n    });\n\n    if (!isDeprecated) {\n      new ShouldReleaseScriptFile(this, {});\n\n      const releaseTask = this.tasks.tryFind(\"release\")!;\n      this.removeTask(\"release\");\n      this.addTask(\"release\", {\n        description: releaseTask.description,\n        steps: releaseTask.steps,\n        env: (releaseTask as any)._env,\n        condition: \"node ./scripts/should-release.js\",\n      });\n      this.addTask(\"unconditional-release\", {\n        description: releaseTask.description,\n        steps: releaseTask.steps,\n        env: (releaseTask as any)._env,\n      });\n\n      const releaseJobSteps: any[] = (\n        this.github?.tryFindWorkflow(\"release\") as any\n      ).jobs.release.steps;\n      const gitRemoteJob = releaseJobSteps.find((it) => it.id === \"git_remote\");\n      prettyAssertEqual(\n        gitRemoteJob.run,\n        'echo \"latest_commit=$(git ls-remote origin -h ${{ github.ref }} | cut -f1)\" >> $GITHUB_OUTPUT\\ncat $GITHUB_OUTPUT',\n        \"git_remote step in release workflow did not match expected string, please check if the workaround still works!\"\n      );\n      const previousCommand = gitRemoteJob.run.replace(\"\\n\", \" && \");\n\n      const cancelCommand =\n        'echo \"latest_commit=release_cancelled\" >> $GITHUB_OUTPUT'; // this cancels the release via a non-matching SHA;\n      gitRemoteJob.run = `node ./scripts/should-release.js && (${previousCommand}) || ${cancelCommand}`;\n      gitRemoteJob.name +=\n        \" or cancel via faking a SHA if release was cancelled\";\n    }\n\n    const staleWorkflow = this.tryFindObjectFile(\".github/workflows/stale.yml\");\n    staleWorkflow?.addOverride(\"on.schedule\", [\n      {\n        cron: generateRandomCron({ project: this, maxHour: 4, hourOffset: 1 }),\n      },\n    ]);\n\n    const upgradeWorkflow = this.tryFindObjectFile(\n      \".github/workflows/upgrade-main.yml\"\n    );\n    upgradeWorkflow?.addOverride(\"on.schedule\", [\n      {\n        cron: generateRandomCron({\n          project: this,\n          maxHour: 0,\n          hourOffset: 1,\n          schedule: Schedule.Weekly,\n        }),\n      },\n    ]);\n\n    // Submodule documentation generation\n    this.gitignore.exclude(\"API.md\"); // ignore the old file, we now generate it in the docs folder\n    this.addDevDeps(\"jsii-docgen@^10.2.3\");\n    if (jsiiVersion) {\n      // NOTE: the below is making a broad assumption that you're passing a range like \"~5.3.0\" to jsiiVersion\n      // If you use that field to pass a very specific version (e.g. \"5.3.11\") then this might break\n      this.addDevDeps(`jsii-rosetta@${jsiiVersion}`);\n    } else {\n      this.addDevDeps(`jsii-rosetta`);\n    }\n\n    const docgen = this.addTask(\"docgen\", {\n      description: \"Generate documentation for the project\",\n      steps: [\n        {\n          exec: [\n            \"rm -rf docs\",\n            \"rm -f API.md\",\n            \"mkdir docs\",\n            // TODO: Re-enable java / csharp\n            // \"jsii-docgen --split-by-submodule -l typescript -l python -l java -l csharp -l go\",\n            \"jsii-docgen --split-by-submodule -l typescript -l python -l go\",\n            // There is no nice way to tell jsii-docgen to generate docs into a folder so I went this route\n            \"mv *.*.md docs\",\n            // Some part of the documentation are too long, we need to truncate them to ~10MB\n            \"cd docs\",\n            \"ls ./ | xargs sed -i '150000,$ d' $1\",\n          ].join(\" && \"),\n        },\n      ],\n    });\n    this.postCompileTask.spawn(docgen);\n    this.gitignore.include(`/docs/*.md`);\n    this.annotateGenerated(`/docs/*.md`);\n\n    // Setting the version in package.json so the golang docs have the correct version\n    const unconditionalBump = this.addTask(\"unconditional-bump\", {\n      description: \"Set the version in package.json to the current version\",\n      steps: [\n        {\n          name: \"Clear the changelog so that it doesn't get published twice\",\n          exec: \"rm -f $CHANGELOG\",\n        },\n        { builtin: \"release/bump-version\" },\n      ],\n      env: {\n        OUTFILE: \"package.json\",\n        CHANGELOG: \"dist/changelog.md\",\n        BUMPFILE: \"dist/version.txt\",\n        RELEASETAG: \"dist/releasetag.txt\",\n        RELEASE_TAG_PREFIX: \"\",\n        MIN_MAJOR: String(MIN_MAJOR_VERSION),\n      },\n    });\n    this.preCompileTask.spawn(unconditionalBump);\n    // To bump correctly we need to have the completely cloned repo\n    (this.buildWorkflow as any).workflow.file.addOverride(\n      \"jobs.build.steps.0.with.fetch-depth\",\n      0\n    );\n    // Undo the changes after compilation\n    this.buildWorkflow?.addPostBuildSteps({\n      name: \"Revert package.json version bump\",\n      run: \"git checkout package.json\",\n    });\n\n    new CopyrightHeaders(this);\n    new DeprecatePackages(this, {\n      providerName,\n      packageInfo,\n      isDeprecated: !!isDeprecated,\n    });\n    if (!isDeprecated) {\n      new ForceRelease(this, { workflowRunsOn });\n    }\n  }\n\n  private pinGithubActionVersions(pinnedVersions: Record<string, string>) {\n    // Use pinned versions of github actions\n    Object.entries(pinnedVersions).forEach(([name, sha]) => {\n      this.github?.actions.set(name, `${name}@${sha}`);\n    });\n  }\n}\n\nfunction prettyAssertEqual<T>(subject: T, expected: T, message?: string): void {\n  if (subject !== expected) {\n    throw new Error(\n      `${message ?? \"Assertion failed\"}: expected ${JSON.stringify(\n        expected\n      )} but got ${JSON.stringify(subject)}`\n    );\n  }\n}\n"]}

package/lib/lock-issues.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { javascript } from "projen";
+/**
+ * Automatically locks issues and PRs after 7 days. Note that 90% of the issues and PRs
+ * on these repos are automated builds and notifications, so locking these threads is
+ * generally not expected to cause issues.
+ */
+export declare class LockIssues {
+    constructor(project: javascript.NodeProject);
+}

package/lib/lock-issues.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockIssues = void 0;
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+const random_cron_1 = require("./util/random-cron");
+/**
+ * Automatically locks issues and PRs after 7 days. Note that 90% of the issues and PRs
+ * on these repos are automated builds and notifications, so locking these threads is
+ * generally not expected to cause issues.
+ */
+class LockIssues {
+    constructor(project) {
+        const workflow = project.github?.addWorkflow("lock");
+        if (!workflow)
+            throw new Error("no workflow defined");
+        workflow.on({
+            // run daily sometime between midnight and 6am UTC
+            schedule: [{ cron: (0, random_cron_1.generateRandomCron)({ project, maxHour: 6 }) }],
+        });
+        workflow.addJob("lock", {
+            runsOn: ["ubuntu-latest"],
+            permissions: {
+                pullRequests: workflows_model_1.JobPermission.WRITE,
+                issues: workflows_model_1.JobPermission.WRITE,
+            },
+            steps: [
+                {
+                    uses: "dessant/lock-threads",
+                    with: {
+                        "issue-comment": `I'm going to lock this issue because it has been closed for at least 7 days.
+              This helps our maintainers find and focus on the active issues.
+              If you've found a problem that seems similar to this, please 
+              [open a new issue](https://github.com/cdktn-io/cdktn-provider-project/issues/new) 
+              so we can investigate further.`.replace(/\s+/g, " "),
+                        "issue-inactive-days": 7,
+                        "pr-comment": `I'm going to lock this pull request because it has been closed for at least 7 days.
+              This helps our maintainers find and focus on the active issues.
+              If you've found a problem that seems related to this change, please 
+              [open a new issue](https://github.com/cdktn-io/cdktn-provider-project/issues/new) 
+              so we can investigate further.`.replace(/\s+/g, " "),
+                        "pr-inactive-days": 7,
+                    },
+                },
+            ],
+            continueOnError: true, // this job fails quite frequently due to rate limit issues but it's really not a big deal if it does
+        });
+    }
+}
+exports.LockIssues = LockIssues;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/package-info.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { cdk } from "projen";
+export interface PackageInfo {
+    npm: {
+        name: string;
+    };
+    python: NonNullable<cdk.JsiiProjectOptions["python"]>;
+    publishToNuget: NonNullable<cdk.JsiiProjectOptions["publishToNuget"]>;
+    publishToMaven: NonNullable<cdk.JsiiProjectOptions["publishToMaven"]>;
+    publishToGo: cdk.JsiiProjectOptions["publishToGo"];
+}