@cdktn/provider-project 0.7.24

package/lib/package-info.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFja2FnZS1pbmZvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3BhY2thZ2UtaW5mby50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7OztHQUdHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIEhhc2hpQ29ycCwgSW5jLlxuICogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1QTC0yLjBcbiAqL1xuXG5pbXBvcnQgeyBjZGsgfSBmcm9tIFwicHJvamVuXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGFja2FnZUluZm8ge1xuICBucG06IHtcbiAgICBuYW1lOiBzdHJpbmc7XG4gIH07XG4gIHB5dGhvbjogTm9uTnVsbGFibGU8Y2RrLkpzaWlQcm9qZWN0T3B0aW9uc1tcInB5dGhvblwiXT47XG4gIHB1Ymxpc2hUb051Z2V0OiBOb25OdWxsYWJsZTxjZGsuSnNpaVByb2plY3RPcHRpb25zW1wicHVibGlzaFRvTnVnZXRcIl0+O1xuICBwdWJsaXNoVG9NYXZlbjogTm9uTnVsbGFibGU8Y2RrLkpzaWlQcm9qZWN0T3B0aW9uc1tcInB1Ymxpc2hUb01hdmVuXCJdPjtcbiAgcHVibGlzaFRvR286IGNkay5Kc2lpUHJvamVjdE9wdGlvbnNbXCJwdWJsaXNoVG9Hb1wiXTtcbn1cbiJdfQ==

package/lib/provider-upgrade.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { javascript } from "projen";
+interface ProviderUpgradeOptions {
+    checkForUpgradesScriptPath: string;
+    workflowRunsOn: string[];
+    nodeHeapSize: string;
+}
+/**
+ * Checks for new versions of the given provider and creates a PR with an upgrade change if there are changes.
+ */
+export declare class ProviderUpgrade {
+    constructor(project: javascript.NodeProject, options: ProviderUpgradeOptions);
+}
+export {};

package/lib/provider-upgrade.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderUpgrade = void 0;
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+const random_cron_1 = require("./util/random-cron");
+/**
+ * Checks for new versions of the given provider and creates a PR with an upgrade change if there are changes.
+ */
+class ProviderUpgrade {
+    constructor(project, options) {
+        project.addTask("check-if-new-provider-version", {
+            exec: `node ./${options.checkForUpgradesScriptPath}`,
+        });
+        const workflow = project.github?.addWorkflow("provider-upgrade");
+        if (!workflow)
+            throw new Error("no workflow defined");
+        workflow.on({
+            schedule: [
+                {
+                    cron: (0, random_cron_1.generateRandomCron)({
+                        project,
+                        maxHour: 0,
+                        hourOffset: 3,
+                    }),
+                },
+            ], // Run every day sometime between 3 and 4am
+            workflowDispatch: {}, // allow manual triggering
+        });
+        const newerVersionAvailable = "${{ steps.check_version.outputs.new_version == 'available' }}";
+        const currentVersion = "${{ steps.current_version.outputs.value }}";
+        const newVersion = "${{ steps.new_version.outputs.value }}";
+        const semanticType = "${{ steps.release.outputs.type }}";
+        const steps = [
+            {
+                name: "Checkout",
+                uses: "actions/checkout",
+            },
+            {
+                name: "Setup Terraform",
+                uses: "hashicorp/setup-terraform",
+                with: {
+                    terraform_wrapper: false,
+                },
+            },
+            {
+                name: "Setup Node.js",
+                uses: "actions/setup-node",
+                with: {
+                    "node-version": project.minNodeVersion,
+                },
+            },
+            {
+                name: "Setup Copywrite tool",
+                uses: "hashicorp/setup-copywrite",
+            },
+            { run: "yarn install" },
+            {
+                id: "check_version",
+                run: "yarn check-if-new-provider-version",
+            },
+            {
+                name: "get provider current version",
+                if: newerVersionAvailable,
+                id: "current_version",
+                run: `echo "value=$(jq -r '.cdktf.provider.version' package.json)" >> $GITHUB_OUTPUT`,
+            },
+            {
+                run: "yarn fetch",
+                if: newerVersionAvailable,
+                env: {
+                    CHECKPOINT_DISABLE: "1",
+                    GH_TOKEN: "${{ secrets.GITHUB_TOKEN }}",
+                },
+            },
+            {
+                // Because yarn fetch nukes the contents of /src, we've lost our auto-generated copyright headers
+                name: "Add headers using Copywrite tool",
+                if: newerVersionAvailable,
+                run: "copywrite headers",
+            },
+            {
+                name: "get provider updated version",
+                if: newerVersionAvailable,
+                id: "new_version",
+                run: `echo "value=$(jq -r '. | to_entries[] | .value' src/version.json)" >> $GITHUB_OUTPUT`,
+            },
+            {
+                name: "Determine if this is a minor or patch release",
+                if: newerVersionAvailable,
+                id: "release",
+                env: {
+                    CURRENT_VERSION: currentVersion,
+                    NEW_VERSION: newVersion,
+                },
+                run: [
+                    `CURRENT_VERSION_MINOR=$(cut -d "." -f 2 <<< "$CURRENT_VERSION")`,
+                    `NEW_VERSION_MINOR=$(cut -d "." -f 2 <<< "$NEW_VERSION")`,
+                    `[[ "$CURRENT_VERSION_MINOR" != "$NEW_VERSION_MINOR" ]] && IS_MINOR_RELEASE=true || IS_MINOR_RELEASE=false`,
+                    `[[ "$IS_MINOR_RELEASE" == "true" ]] && SEMANTIC_TYPE=feat || SEMANTIC_TYPE=fix`,
+                    `echo "is_minor=$IS_MINOR_RELEASE" >> $GITHUB_OUTPUT`,
+                    `echo "type=$SEMANTIC_TYPE" >> $GITHUB_OUTPUT`,
+                ].join("\n"),
+            },
+            // submit a PR
+            {
+                name: "Create Pull Request",
+                if: newerVersionAvailable,
+                uses: "peter-evans/create-pull-request",
+                with: {
+                    branch: "auto/provider-upgrade",
+                    "commit-message": `${semanticType}: upgrade provider from \`${currentVersion}\` to version \`${newVersion}\``,
+                    title: `${semanticType}: upgrade provider from \`${currentVersion}\` to version \`${newVersion}\``,
+                    body: `This PR upgrades the underlying Terraform provider to version ${newVersion}`,
+                    labels: "automerge,auto-approve",
+                    token: "${{ secrets.GH_TOKEN }}",
+                    "delete-branch": true,
+                    committer: "team-cdk-terrain <github-team-cdk-terrain@cdktn.io",
+                    author: "Team CDK Terrain <github-team-cdk-terrain@cdktn.io",
+                    signoff: true,
+                },
+            },
+        ];
+        workflow.addJobs({
+            upgrade: {
+                runsOn: options.workflowRunsOn,
+                env: {
+                    NODE_OPTIONS: `--max-old-space-size=${options.nodeHeapSize}`,
+                },
+                steps,
+                permissions: {
+                    pullRequests: workflows_model_1.JobPermission.WRITE,
+                    issues: workflows_model_1.JobPermission.WRITE,
+                    contents: workflows_model_1.JobPermission.WRITE,
+                    statuses: workflows_model_1.JobPermission.WRITE,
+                },
+            },
+        });
+    }
+}
+exports.ProviderUpgrade = ProviderUpgrade;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider-upgrade.js","sourceRoot":"","sources":["../src/provider-upgrade.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\n\nimport { javascript } from \"projen\";\nimport { JobPermission, JobStep } from \"projen/lib/github/workflows-model\";\nimport { generateRandomCron } from \"./util/random-cron\";\n\ninterface ProviderUpgradeOptions {\n  checkForUpgradesScriptPath: string;\n  workflowRunsOn: string[];\n  nodeHeapSize: string;\n}\n/**\n * Checks for new versions of the given provider and creates a PR with an upgrade change if there are changes.\n */\nexport class ProviderUpgrade {\n  constructor(\n    project: javascript.NodeProject,\n    options: ProviderUpgradeOptions\n  ) {\n    project.addTask(\"check-if-new-provider-version\", {\n      exec: `node ./${options.checkForUpgradesScriptPath}`,\n    });\n\n    const workflow = project.github?.addWorkflow(\"provider-upgrade\");\n\n    if (!workflow) throw new Error(\"no workflow defined\");\n\n    workflow.on({\n      schedule: [\n        {\n          cron: generateRandomCron({\n            project,\n            maxHour: 0,\n            hourOffset: 3,\n          }),\n        },\n      ], // Run every day sometime between 3 and 4am\n      workflowDispatch: {}, // allow manual triggering\n    });\n\n    const newerVersionAvailable =\n      \"${{ steps.check_version.outputs.new_version == 'available' }}\";\n    const currentVersion = \"${{ steps.current_version.outputs.value }}\";\n    const newVersion = \"${{ steps.new_version.outputs.value }}\";\n    const semanticType = \"${{ steps.release.outputs.type }}\";\n\n    const steps: JobStep[] = [\n      {\n        name: \"Checkout\",\n        uses: \"actions/checkout\",\n      },\n      {\n        name: \"Setup Terraform\",\n        uses: \"hashicorp/setup-terraform\",\n        with: {\n          terraform_wrapper: false,\n        },\n      },\n      {\n        name: \"Setup Node.js\",\n        uses: \"actions/setup-node\",\n        with: {\n          \"node-version\": project.minNodeVersion,\n        },\n      },\n      {\n        name: \"Setup Copywrite tool\",\n        uses: \"hashicorp/setup-copywrite\",\n      },\n      { run: \"yarn install\" },\n      {\n        id: \"check_version\",\n        run: \"yarn check-if-new-provider-version\",\n      },\n      {\n        name: \"get provider current version\",\n        if: newerVersionAvailable,\n        id: \"current_version\",\n        run: `echo \"value=$(jq -r '.cdktf.provider.version' package.json)\" >> $GITHUB_OUTPUT`,\n      },\n      {\n        run: \"yarn fetch\",\n        if: newerVersionAvailable,\n        env: {\n          CHECKPOINT_DISABLE: \"1\",\n          GH_TOKEN: \"${{ secrets.GITHUB_TOKEN }}\",\n        },\n      },\n      {\n        // Because yarn fetch nukes the contents of /src, we've lost our auto-generated copyright headers\n        name: \"Add headers using Copywrite tool\",\n        if: newerVersionAvailable,\n        run: \"copywrite headers\",\n      },\n      {\n        name: \"get provider updated version\",\n        if: newerVersionAvailable,\n        id: \"new_version\",\n        run: `echo \"value=$(jq -r '. | to_entries[] | .value' src/version.json)\" >> $GITHUB_OUTPUT`,\n      },\n      {\n        name: \"Determine if this is a minor or patch release\",\n        if: newerVersionAvailable,\n        id: \"release\",\n        env: {\n          CURRENT_VERSION: currentVersion,\n          NEW_VERSION: newVersion,\n        },\n        run: [\n          `CURRENT_VERSION_MINOR=$(cut -d \".\" -f 2 <<< \"$CURRENT_VERSION\")`,\n          `NEW_VERSION_MINOR=$(cut -d \".\" -f 2 <<< \"$NEW_VERSION\")`,\n          `[[ \"$CURRENT_VERSION_MINOR\" != \"$NEW_VERSION_MINOR\" ]] && IS_MINOR_RELEASE=true || IS_MINOR_RELEASE=false`,\n          `[[ \"$IS_MINOR_RELEASE\" == \"true\" ]] && SEMANTIC_TYPE=feat || SEMANTIC_TYPE=fix`,\n          `echo \"is_minor=$IS_MINOR_RELEASE\" >> $GITHUB_OUTPUT`,\n          `echo \"type=$SEMANTIC_TYPE\" >> $GITHUB_OUTPUT`,\n        ].join(\"\\n\"),\n      },\n      // submit a PR\n      {\n        name: \"Create Pull Request\",\n        if: newerVersionAvailable,\n        uses: \"peter-evans/create-pull-request\",\n        with: {\n          branch: \"auto/provider-upgrade\",\n          \"commit-message\": `${semanticType}: upgrade provider from \\`${currentVersion}\\` to version \\`${newVersion}\\``,\n          title: `${semanticType}: upgrade provider from \\`${currentVersion}\\` to version \\`${newVersion}\\``,\n          body: `This PR upgrades the underlying Terraform provider to version ${newVersion}`,\n          labels: \"automerge,auto-approve\",\n          token: \"${{ secrets.GH_TOKEN }}\",\n          \"delete-branch\": true,\n          committer: \"team-cdk-terrain <github-team-cdk-terrain@cdktn.io\",\n          author: \"Team CDK Terrain <github-team-cdk-terrain@cdktn.io\",\n          signoff: true,\n        },\n      },\n    ];\n\n    workflow.addJobs({\n      upgrade: {\n        runsOn: options.workflowRunsOn,\n        env: {\n          NODE_OPTIONS: `--max-old-space-size=${options.nodeHeapSize}`,\n        },\n        steps,\n        permissions: {\n          pullRequests: JobPermission.WRITE,\n          issues: JobPermission.WRITE,\n          contents: JobPermission.WRITE,\n          statuses: JobPermission.WRITE,\n        },\n      },\n    });\n  }\n}\n"]}

package/lib/readme.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { FileBase, FileBaseOptions, IResolver, Project } from "projen";
+import { PackageInfo } from "./package-info";
+export interface ReadmeFileOptions extends FileBaseOptions {
+    providerName: string;
+    fqproviderName: string;
+    providerVersion: string;
+    packageInfo: PackageInfo;
+    underlyingTerraformVersion: string;
+    cdktfVersion: string;
+    isDeprecated: boolean;
+    deprecationDate?: string;
+}
+export declare class ReadmeFile extends FileBase {
+    protected readonly options: ReadmeFileOptions;
+    constructor(project: Project, filePath: string, options: ReadmeFileOptions);
+    protected synthesizeContent(resolver: IResolver): string;
+}

package/lib/readme.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadmeFile = void 0;
+const projen_1 = require("projen");
+class ReadmeFile extends projen_1.FileBase {
+    constructor(project, filePath, options) {
+        super(project, filePath, options);
+        this.options = options;
+    }
+    synthesizeContent(resolver) {
+        const { providerName, fqproviderName, providerVersion, packageInfo, underlyingTerraformVersion, isDeprecated, deprecationDate, } = resolver.resolve(this.options);
+        const fqpnURL = fqproviderName.includes("/")
+            ? fqproviderName
+            : `hashicorp/${fqproviderName}`;
+        const versionURL = providerVersion
+            ? providerVersion.replace(/~>\s*/, "").concat(".0")
+            : "";
+        const registryUrl = `https://registry.terraform.io/providers/${fqpnURL}/${underlyingTerraformVersion !== "<unknown>"
+            ? underlyingTerraformVersion
+            : versionURL}`;
+        const cdktfVersion = this.options.cdktfVersion.replace("^", "");
+        const date = deprecationDate ??
+            new Date().toLocaleDateString("en-US", {
+                year: "numeric",
+                month: "long",
+                day: "numeric",
+            });
+        const deprecationMessage = `
+The CDK Terrain Team made the decision to stop publishing new versions of prebuilt [Terraform ${providerName} provider](${registryUrl}) bindings for [CDK for Terraform](https://cdk.tf) on ${date}. As such, this repository has been archived and is no longer supported in any way by HashiCorp. Previously-published versions of this prebuilt provider will still continue to be available on their respective package managers (e.g. npm, PyPi, Maven, NuGet), but these will not be compatible with new releases of \`cdktf\` past \`${cdktfVersion}\` and are no longer eligible for support.
+
+As a reminder, you can continue to use the \`${fqpnURL}\` provider in your CDK for Terraform (CDKTF) projects, even with newer versions of CDKTF, but you will need to generate the bindings locally. The easiest way to do so is to use the [\`provider add\` command](https://developer.hashicorp.com/terraform/cdktf/cli-reference/commands#provider-add), optionally with the \`--force-local\` flag enabled:
+
+\`cdktf provider add ${fqpnURL} --force-local\`
+
+For more information and additional examples, check out our documentation on [generating provider bindings manually](https://cdk.tf/imports).
+    `.trim();
+        const readme = `
+# CDKTF prebuilt bindings for ${fqpnURL} provider version ${underlyingTerraformVersion !== "<unknown>"
+            ? `${underlyingTerraformVersion}`
+            : `${providerVersion}`}
+
+${isDeprecated
+            ? deprecationMessage
+            : `This repo builds and publishes the [Terraform ${providerName} provider](${registryUrl}/docs) bindings for [CDK for Terraform](https://cdk.tf).`}
+
+## ${isDeprecated ? "Deprecated" : "Available"} Packages
+
+### NPM
+
+The npm package is available at [https://www.npmjs.com/package/${packageInfo.npm.name}](https://www.npmjs.com/package/${packageInfo.npm.name}).
+
+\`npm install ${packageInfo.npm.name}\`
+
+### PyPI
+
+The PyPI package is available at [https://pypi.org/project/${packageInfo.python.distName}](https://pypi.org/project/${packageInfo.python.distName}).
+
+\`pipenv install ${packageInfo.python.distName}\`
+
+### Nuget
+
+The Nuget package is available at [https://www.nuget.org/packages/${packageInfo.publishToNuget.packageId}](https://www.nuget.org/packages/${packageInfo.publishToNuget.packageId}).
+
+\`dotnet add package ${packageInfo.publishToNuget.packageId}\`
+
+### Maven
+
+The Maven package is available at [https://mvnrepository.com/artifact/${packageInfo.publishToMaven.mavenGroupId}/${packageInfo.publishToMaven.mavenArtifactId}](https://mvnrepository.com/artifact/${packageInfo.publishToMaven.mavenGroupId}/${packageInfo.publishToMaven.mavenArtifactId}).
+
+\`\`\`
+<dependency>
+    <groupId>${packageInfo.publishToMaven.mavenGroupId}</groupId>
+    <artifactId>${packageInfo.publishToMaven.mavenArtifactId}</artifactId>
+    <version>[REPLACE WITH DESIRED VERSION]</version>
+</dependency>
+\`\`\`
+
+### Go
+
+The go package is generated into the [\`${packageInfo.publishToGo?.moduleName}\`](https://${packageInfo.publishToGo?.moduleName}) package.
+
+\`go get ${packageInfo.publishToGo?.moduleName}/${packageInfo.publishToGo?.packageName}/<version>\`
+
+Where \`<version>\` is the version of the prebuilt provider you would like to use e.g. \`v11\`. The full module name can be found
+within the [go.mod](https://${packageInfo.publishToGo?.moduleName}/blob/main/${packageInfo.publishToGo?.packageName}/go.mod#L1) file.
+
+## Docs
+
+Find auto-generated docs for this provider here: 
+
+- [Typescript](./docs/API.typescript.md)
+- [Python](./docs/API.python.md)
+- [Java](./docs/API.java.md)
+- [C#](./docs/API.csharp.md)
+- [Go](./docs/API.go.md)
+
+You can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktn/provider-${providerName}).
+`;
+        return isDeprecated
+            ? readme
+            : readme +
+                `
+## Versioning
+
+This project is explicitly not tracking the Terraform ${providerName} provider version 1:1. In fact, it always tracks \`latest\` of \`${providerVersion}\` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).
+
+These are the upstream dependencies:
+
+- [CDK for Terraform](https://cdk.tf) - Last official release
+- [Terraform ${providerName} provider](${registryUrl})
+- [Terraform Engine](https://terraform.io)
+
+If there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.
+
+## Features / Issues / Bugs
+
+Please report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:
+
+- [Create bug report](https://cdk.tf/bug)
+- [Create feature request](https://cdk.tf/feature)
+
+## Contributing
+
+### Projen
+
+This is mostly based on [Projen](https://projen.io), which takes care of generating the entire repository.
+
+### cdktn-provider-project based on Projen
+
+There's a custom [project builder](https://github.com/cdktn-io/cdktn-provider-project) which encapsulate the common settings for all \`cdktf\` prebuilt providers.
+
+### Provider Version
+
+The provider version can be adjusted in [./.projenrc.js](./.projenrc.js).
+
+### Repository Management
+
+The repository is managed by [CDKTN Repository Manager](https://github.com/cdktn-io/cdktn-repository-manager/).
+`;
+    }
+}
+exports.ReadmeFile = ReadmeFile;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"readme.js","sourceRoot":"","sources":["../src/readme.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\n\nimport { FileBase, FileBaseOptions, IResolver, Project } from \"projen\";\nimport { PackageInfo } from \"./package-info\";\n\nexport interface ReadmeFileOptions extends FileBaseOptions {\n  providerName: string;\n  fqproviderName: string;\n  providerVersion: string;\n  packageInfo: PackageInfo;\n  underlyingTerraformVersion: string;\n  cdktfVersion: string;\n  isDeprecated: boolean;\n  deprecationDate?: string;\n}\n\nexport class ReadmeFile extends FileBase {\n  protected readonly options: ReadmeFileOptions;\n\n  constructor(project: Project, filePath: string, options: ReadmeFileOptions) {\n    super(project, filePath, options);\n    this.options = options;\n  }\n\n  protected synthesizeContent(resolver: IResolver) {\n    const {\n      providerName,\n      fqproviderName,\n      providerVersion,\n      packageInfo,\n      underlyingTerraformVersion,\n      isDeprecated,\n      deprecationDate,\n    } = resolver.resolve(this.options) as ReadmeFileOptions;\n\n    const fqpnURL = fqproviderName.includes(\"/\")\n      ? fqproviderName\n      : `hashicorp/${fqproviderName}`;\n    const versionURL = providerVersion\n      ? providerVersion.replace(/~>\\s*/, \"\").concat(\".0\")\n      : \"\";\n    const registryUrl = `https://registry.terraform.io/providers/${fqpnURL}/${\n      underlyingTerraformVersion !== \"<unknown>\"\n        ? underlyingTerraformVersion\n        : versionURL\n    }`;\n    const cdktfVersion = this.options.cdktfVersion.replace(\"^\", \"\");\n\n    const date =\n      deprecationDate ??\n      new Date().toLocaleDateString(\"en-US\", {\n        year: \"numeric\",\n        month: \"long\",\n        day: \"numeric\",\n      });\n    const deprecationMessage = `\nThe CDK Terrain Team made the decision to stop publishing new versions of prebuilt [Terraform ${providerName} provider](${registryUrl}) bindings for [CDK for Terraform](https://cdk.tf) on ${date}. As such, this repository has been archived and is no longer supported in any way by HashiCorp. Previously-published versions of this prebuilt provider will still continue to be available on their respective package managers (e.g. npm, PyPi, Maven, NuGet), but these will not be compatible with new releases of \\`cdktf\\` past \\`${cdktfVersion}\\` and are no longer eligible for support.\n\nAs a reminder, you can continue to use the \\`${fqpnURL}\\` provider in your CDK for Terraform (CDKTF) projects, even with newer versions of CDKTF, but you will need to generate the bindings locally. The easiest way to do so is to use the [\\`provider add\\` command](https://developer.hashicorp.com/terraform/cdktf/cli-reference/commands#provider-add), optionally with the \\`--force-local\\` flag enabled:\n\n\\`cdktf provider add ${fqpnURL} --force-local\\`\n\nFor more information and additional examples, check out our documentation on [generating provider bindings manually](https://cdk.tf/imports).\n    `.trim();\n\n    const readme = `\n# CDKTF prebuilt bindings for ${fqpnURL} provider version ${\n      underlyingTerraformVersion !== \"<unknown>\"\n        ? `${underlyingTerraformVersion}`\n        : `${providerVersion}`\n    }\n\n${\n  isDeprecated\n    ? deprecationMessage\n    : `This repo builds and publishes the [Terraform ${providerName} provider](${registryUrl}/docs) bindings for [CDK for Terraform](https://cdk.tf).`\n}\n\n## ${isDeprecated ? \"Deprecated\" : \"Available\"} Packages\n\n### NPM\n\nThe npm package is available at [https://www.npmjs.com/package/${\n      packageInfo.npm.name\n    }](https://www.npmjs.com/package/${packageInfo.npm.name}).\n\n\\`npm install ${packageInfo.npm.name}\\`\n\n### PyPI\n\nThe PyPI package is available at [https://pypi.org/project/${\n      packageInfo.python.distName\n    }](https://pypi.org/project/${packageInfo.python.distName}).\n\n\\`pipenv install ${packageInfo.python.distName}\\`\n\n### Nuget\n\nThe Nuget package is available at [https://www.nuget.org/packages/${\n      packageInfo.publishToNuget.packageId\n    }](https://www.nuget.org/packages/${packageInfo.publishToNuget.packageId}).\n\n\\`dotnet add package ${packageInfo.publishToNuget.packageId}\\`\n\n### Maven\n\nThe Maven package is available at [https://mvnrepository.com/artifact/${\n      packageInfo.publishToMaven.mavenGroupId\n    }/${\n      packageInfo.publishToMaven.mavenArtifactId\n    }](https://mvnrepository.com/artifact/${\n      packageInfo.publishToMaven.mavenGroupId\n    }/${packageInfo.publishToMaven.mavenArtifactId}).\n\n\\`\\`\\`\n<dependency>\n    <groupId>${packageInfo.publishToMaven.mavenGroupId}</groupId>\n    <artifactId>${packageInfo.publishToMaven.mavenArtifactId}</artifactId>\n    <version>[REPLACE WITH DESIRED VERSION]</version>\n</dependency>\n\\`\\`\\`\n\n### Go\n\nThe go package is generated into the [\\`${\n      packageInfo.publishToGo?.moduleName\n    }\\`](https://${packageInfo.publishToGo?.moduleName}) package.\n\n\\`go get ${packageInfo.publishToGo?.moduleName}/${\n      packageInfo.publishToGo?.packageName\n    }/<version>\\`\n\nWhere \\`<version>\\` is the version of the prebuilt provider you would like to use e.g. \\`v11\\`. The full module name can be found\nwithin the [go.mod](https://${packageInfo.publishToGo?.moduleName}/blob/main/${\n      packageInfo.publishToGo?.packageName\n    }/go.mod#L1) file.\n\n## Docs\n\nFind auto-generated docs for this provider here: \n\n- [Typescript](./docs/API.typescript.md)\n- [Python](./docs/API.python.md)\n- [Java](./docs/API.java.md)\n- [C#](./docs/API.csharp.md)\n- [Go](./docs/API.go.md)\n\nYou can also visit a hosted version of the documentation on [constructs.dev](https://constructs.dev/packages/@cdktn/provider-${providerName}).\n`;\n\n    return isDeprecated\n      ? readme\n      : readme +\n          `\n## Versioning\n\nThis project is explicitly not tracking the Terraform ${providerName} provider version 1:1. In fact, it always tracks \\`latest\\` of \\`${providerVersion}\\` with every release. If there are scenarios where you explicitly have to pin your provider version, you can do so by [generating the provider constructs manually](https://cdk.tf/imports).\n\nThese are the upstream dependencies:\n\n- [CDK for Terraform](https://cdk.tf) - Last official release\n- [Terraform ${providerName} provider](${registryUrl})\n- [Terraform Engine](https://terraform.io)\n\nIf there are breaking changes (backward incompatible) in any of the above, the major version of this project will be bumped.\n\n## Features / Issues / Bugs\n\nPlease report bugs and issues to the [CDK for Terraform](https://cdk.tf) project:\n\n- [Create bug report](https://cdk.tf/bug)\n- [Create feature request](https://cdk.tf/feature)\n\n## Contributing\n\n### Projen\n\nThis is mostly based on [Projen](https://projen.io), which takes care of generating the entire repository.\n\n### cdktn-provider-project based on Projen\n\nThere's a custom [project builder](https://github.com/cdktn-io/cdktn-provider-project) which encapsulate the common settings for all \\`cdktf\\` prebuilt providers.\n\n### Provider Version\n\nThe provider version can be adjusted in [./.projenrc.js](./.projenrc.js).\n\n### Repository Management\n\nThe repository is managed by [CDKTN Repository Manager](https://github.com/cdktn-io/cdktn-repository-manager/).\n`;\n  }\n}\n"]}

package/lib/scripts/check-for-upgrades.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { FileBase, FileBaseOptions, IResolver } from "projen";
+import { NodeProject } from "projen/lib/javascript";
+export interface CheckForUpgradesScriptFileOptions extends FileBaseOptions {
+    fqproviderName: string;
+    providerVersion: string;
+}
+export declare class CheckForUpgradesScriptFile extends FileBase {
+    protected readonly options: CheckForUpgradesScriptFileOptions;
+    constructor(project: NodeProject, options: CheckForUpgradesScriptFileOptions);
+    protected synthesizeContent(resolver: IResolver): string | undefined;
+}

package/lib/scripts/check-for-upgrades.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckForUpgradesScriptFile = void 0;
+const projen_1 = require("projen");
+class CheckForUpgradesScriptFile extends projen_1.FileBase {
+    constructor(project, options) {
+        super(project, "scripts/check-for-upgrades.js", options);
+        this.options = options;
+        project.addDevDeps("semver@^7.5.3");
+    }
+    synthesizeContent(resolver) {
+        let { providerVersion, fqproviderName } = resolver.resolve(this.options);
+        // aws -> hashicorp/aws (else the registry API call fails)
+        if (!fqproviderName.includes("/")) {
+            fqproviderName = `hashicorp/${fqproviderName}`;
+        }
+        return `
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+const semver = require("semver");
+const actions = require("@actions/core");
+
+// Code is inlined below, as this import requires us to add all dev dependencies of cdktf-cli as we're not
+// using the bundle. A better alternative would be to refactor this method to move to its own package, that
+// the cdktf-cli and others can use (we have the same "problem" with some other code in cdktf, cdktf-cli and
+// the @cdktn/provider-generator package, too)
+// const { versionMatchesConstraint } = require('cdktf-cli/lib/dependencies/version-constraints');
+
+// set by the projen file that generates this script
+const CONSTRAINT = "${providerVersion}";
+const FQ_PROVIDER_NAME = "${fqproviderName}";
+
+(async function main() {
+  if (await newerMatchingProviderVersionExists()) {
+    console.log(
+      \`Found newer Terraform provider version matching the current constraint: \${CONSTRAINT}\`
+    );
+    setGithubStepOutput("new_version", "available");
+  } else {
+    console.log("No changes detected.");
+    setGithubStepOutput("new_version", "unavailable");
+  }
+})();
+
+function setGithubStepOutput(name, value) {
+  actions.setOutput(name, value);
+}
+
+async function newerMatchingProviderVersionExists() {
+  const res = await fetch(
+    \`https://registry.terraform.io/v2/providers/\${FQ_PROVIDER_NAME}/provider-versions\`
+  );
+  const body = await res.json();
+
+  const currentVersion = await getCurrentProviderVersion();
+
+  const availableVersions = body.data.map((it) => it.attributes.version);
+  const versionsMatching = availableVersions.filter((v) =>
+    versionMatchesConstraint(v, CONSTRAINT)
+  );
+  if (versionsMatching.length <= 0) {
+    throw new Error(
+      \`Unexpected Error: Found no matching versions for constraint \${CONSTRAINT} in [\${availableVersions.join(
+        ", "
+      )}]\`
+    );
+  }
+
+  const versionsGreaterThanCurrent = versionsMatching.filter((v) =>
+    semver.gt(v, currentVersion)
+  );
+  if (versionsGreaterThanCurrent.length > 0) {
+    console.log(
+      \`One or more matching versions (\${CONSTRAINT}) are greater than the current version (\${currentVersion}): [\${versionsGreaterThanCurrent.join(
+        ", "
+      )}]\`
+    );
+    return true;
+  } else {
+    console.log(
+      \`Found no matching versions (\${CONSTRAINT}) greater than the current version (\${currentVersion}). Matching versions: [\${versionsMatching.join(
+        ", "
+      )}]\`
+    );
+  }
+  return false;
+}
+
+// e.g. cdktf 0.12.x -> 0.13.x but not 0.12.y -> 0.12.z
+async function cdktfVersionMajorChanged() {
+  throw new Error("todo implement");
+}
+
+async function getCurrentProviderVersion() {
+  const json = require("../src/version.json");
+  return json[\`registry.terraform.io/\${FQ_PROVIDER_NAME.toLowerCase()}\`];
+}
+
+// SEE NOTICE AT THE TOP WHY THIS IS INLINED CURRENTLY
+// copied from https://github.com/open-constructs/cdk-terrain/blob/df858ccf4ac71a168e3636f053c6743324c98332/packages/%40cdktf/cli-core/src/lib/dependencies/version-constraints.ts
+// and converted to JavaScript
+
+// constraints can be prefixed with "~>", ">", "<", "=", ">=", "<=" or "!="
+// no prefix means "="
+function parseConstraint(constraint) {
+  const cleaned = constraint.trim();
+
+  const operator = cleaned.match(/(~>|>=|<=|>|<|=|!=)/)?.[0] || "=";
+  const version = cleaned.replace(operator, "").trim();
+
+  return {
+    operator,
+    version,
+  };
+}
+
+function versionMatchesConstraint(version, constraint) {
+  // https://www.terraform.io/language/expressions/version-constraints
+  // version can contain multiple constraints split by ","
+
+  const constraints = constraint.split(",");
+  version = semver.coerce(version)?.version ?? version;
+
+  // each constraint needs to be satisfied
+  return constraints.every((c) => {
+    const parsed = parseConstraint(c);
+
+    const cleanedParsedVersion =
+      semver.coerce(parsed.version)?.version ?? parsed.version;
+
+    switch (parsed.operator) {
+      case "=":
+        return version === cleanedParsedVersion;
+      case "!=":
+        return version !== cleanedParsedVersion;
+      case "~>": {
+        // allows rightmost version component to increment
+
+        const parts = parsed.version.split(".");
+        const minorSpecified = parts.length === 2;
+        const majorIsZero = parts[0] === "0";
+
+        // ~>2.0 which allows 2.1 and 2.1.1 needs special handling as
+        // npm semver handles "~" differently for ~2.0 than for ~2 or ~2.1.0
+        // So we need to use "^" (e.g. ^2.0) for this case
+        // see: https://github.com/npm/node-semver/issues/11
+        const allowMinorAndPatchOnly = minorSpecified;
+
+        let range = allowMinorAndPatchOnly
+          ? \`^\${parsed.version}\`
+          : \`~\${parsed.version}\`;
+
+        // versions below 1.0 are treated a bit differently in NPM than in Terraform
+        // meaning that NPMs ^0.4 doesn't allow 0.55 while TFs ~>0.4 allows 0.55
+        if (majorIsZero && minorSpecified) {
+          range = \`>=\${parsed.version} <1.0.0\`;
+        }
+
+        return semver.satisfies(version, range);
+      }
+      case ">=":
+        return semver.gte(version, cleanedParsedVersion);
+      case "<=":
+        return semver.lte(version, cleanedParsedVersion);
+      case ">":
+        return semver.gt(version, cleanedParsedVersion);
+      case "<":
+        return semver.lt(version, cleanedParsedVersion);
+      default:
+        throw Errors.External(
+          \`Unknown constraint operator: \${parsed.operator} in version constraint \${constraint}\`
+        );
+    }
+  });
+}
+`;
+    }
+}
+exports.CheckForUpgradesScriptFile = CheckForUpgradesScriptFile;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"check-for-upgrades.js","sourceRoot":"","sources":["../../src/scripts/check-for-upgrades.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,mCAA8D;AAQ9D,MAAa,0BAA2B,SAAQ,iBAAQ;IAGtD,YACE,OAAoB,EACpB,OAA0C;QAE1C,KAAK,CAAC,OAAO,EAAE,+BAA+B,EAAE,OAAO,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QAEvB,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;IACtC,CAAC;IAES,iBAAiB,CAAC,QAAmB;QAC7C,IAAI,EAAE,eAAe,EAAE,cAAc,EAAE,GAAG,QAAQ,CAAC,OAAO,CACxD,IAAI,CAAC,OAAO,CACwB,CAAC;QAEvC,0DAA0D;QAC1D,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAClC,cAAc,GAAG,aAAa,cAAc,EAAE,CAAC;QACjD,CAAC;QAED,OAAO;;;;;;;;;;;;;;;sBAeW,eAAe;4BACT,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiJzC,CAAC;IACA,CAAC;CACF;AA1LD,gEA0LC","sourcesContent":["/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\n\nimport { FileBase, FileBaseOptions, IResolver } from \"projen\";\nimport { NodeProject } from \"projen/lib/javascript\";\n\nexport interface CheckForUpgradesScriptFileOptions extends FileBaseOptions {\n  fqproviderName: string;\n  providerVersion: string;\n}\n\nexport class CheckForUpgradesScriptFile extends FileBase {\n  protected readonly options: CheckForUpgradesScriptFileOptions;\n\n  constructor(\n    project: NodeProject,\n    options: CheckForUpgradesScriptFileOptions\n  ) {\n    super(project, \"scripts/check-for-upgrades.js\", options);\n    this.options = options;\n\n    project.addDevDeps(\"semver@^7.5.3\");\n  }\n\n  protected synthesizeContent(resolver: IResolver): string | undefined {\n    let { providerVersion, fqproviderName } = resolver.resolve(\n      this.options\n    ) as CheckForUpgradesScriptFileOptions;\n\n    // aws -> hashicorp/aws (else the registry API call fails)\n    if (!fqproviderName.includes(\"/\")) {\n      fqproviderName = `hashicorp/${fqproviderName}`;\n    }\n\n    return `\n/**\n * Copyright (c) HashiCorp, Inc.\n * SPDX-License-Identifier: MPL-2.0\n */\nconst semver = require(\"semver\");\nconst actions = require(\"@actions/core\");\n\n// Code is inlined below, as this import requires us to add all dev dependencies of cdktf-cli as we're not\n// using the bundle. A better alternative would be to refactor this method to move to its own package, that\n// the cdktf-cli and others can use (we have the same \"problem\" with some other code in cdktf, cdktf-cli and\n// the @cdktn/provider-generator package, too)\n// const { versionMatchesConstraint } = require('cdktf-cli/lib/dependencies/version-constraints');\n\n// set by the projen file that generates this script\nconst CONSTRAINT = \"${providerVersion}\";\nconst FQ_PROVIDER_NAME = \"${fqproviderName}\";\n\n(async function main() {\n  if (await newerMatchingProviderVersionExists()) {\n    console.log(\n      \\`Found newer Terraform provider version matching the current constraint: \\${CONSTRAINT}\\`\n    );\n    setGithubStepOutput(\"new_version\", \"available\");\n  } else {\n    console.log(\"No changes detected.\");\n    setGithubStepOutput(\"new_version\", \"unavailable\");\n  }\n})();\n\nfunction setGithubStepOutput(name, value) {\n  actions.setOutput(name, value);\n}\n\nasync function newerMatchingProviderVersionExists() {\n  const res = await fetch(\n    \\`https://registry.terraform.io/v2/providers/\\${FQ_PROVIDER_NAME}/provider-versions\\`\n  );\n  const body = await res.json();\n\n  const currentVersion = await getCurrentProviderVersion();\n\n  const availableVersions = body.data.map((it) => it.attributes.version);\n  const versionsMatching = availableVersions.filter((v) =>\n    versionMatchesConstraint(v, CONSTRAINT)\n  );\n  if (versionsMatching.length <= 0) {\n    throw new Error(\n      \\`Unexpected Error: Found no matching versions for constraint \\${CONSTRAINT} in [\\${availableVersions.join(\n        \", \"\n      )}]\\`\n    );\n  }\n\n  const versionsGreaterThanCurrent = versionsMatching.filter((v) =>\n    semver.gt(v, currentVersion)\n  );\n  if (versionsGreaterThanCurrent.length > 0) {\n    console.log(\n      \\`One or more matching versions (\\${CONSTRAINT}) are greater than the current version (\\${currentVersion}): [\\${versionsGreaterThanCurrent.join(\n        \", \"\n      )}]\\`\n    );\n    return true;\n  } else {\n    console.log(\n      \\`Found no matching versions (\\${CONSTRAINT}) greater than the current version (\\${currentVersion}). Matching versions: [\\${versionsMatching.join(\n        \", \"\n      )}]\\`\n    );\n  }\n  return false;\n}\n\n// e.g. cdktf 0.12.x -> 0.13.x but not 0.12.y -> 0.12.z\nasync function cdktfVersionMajorChanged() {\n  throw new Error(\"todo implement\");\n}\n\nasync function getCurrentProviderVersion() {\n  const json = require(\"../src/version.json\");\n  return json[\\`registry.terraform.io/\\${FQ_PROVIDER_NAME.toLowerCase()}\\`];\n}\n\n// SEE NOTICE AT THE TOP WHY THIS IS INLINED CURRENTLY\n// copied from https://github.com/open-constructs/cdk-terrain/blob/df858ccf4ac71a168e3636f053c6743324c98332/packages/%40cdktf/cli-core/src/lib/dependencies/version-constraints.ts\n// and converted to JavaScript\n\n// constraints can be prefixed with \"~>\", \">\", \"<\", \"=\", \">=\", \"<=\" or \"!=\"\n// no prefix means \"=\"\nfunction parseConstraint(constraint) {\n  const cleaned = constraint.trim();\n\n  const operator = cleaned.match(/(~>|>=|<=|>|<|=|!=)/)?.[0] || \"=\";\n  const version = cleaned.replace(operator, \"\").trim();\n\n  return {\n    operator,\n    version,\n  };\n}\n\nfunction versionMatchesConstraint(version, constraint) {\n  // https://www.terraform.io/language/expressions/version-constraints\n  // version can contain multiple constraints split by \",\"\n\n  const constraints = constraint.split(\",\");\n  version = semver.coerce(version)?.version ?? version;\n\n  // each constraint needs to be satisfied\n  return constraints.every((c) => {\n    const parsed = parseConstraint(c);\n\n    const cleanedParsedVersion =\n      semver.coerce(parsed.version)?.version ?? parsed.version;\n\n    switch (parsed.operator) {\n      case \"=\":\n        return version === cleanedParsedVersion;\n      case \"!=\":\n        return version !== cleanedParsedVersion;\n      case \"~>\": {\n        // allows rightmost version component to increment\n\n        const parts = parsed.version.split(\".\");\n        const minorSpecified = parts.length === 2;\n        const majorIsZero = parts[0] === \"0\";\n\n        // ~>2.0 which allows 2.1 and 2.1.1 needs special handling as\n        // npm semver handles \"~\" differently for ~2.0 than for ~2 or ~2.1.0\n        // So we need to use \"^\" (e.g. ^2.0) for this case\n        // see: https://github.com/npm/node-semver/issues/11\n        const allowMinorAndPatchOnly = minorSpecified;\n\n        let range = allowMinorAndPatchOnly\n          ? \\`^\\${parsed.version}\\`\n          : \\`~\\${parsed.version}\\`;\n\n        // versions below 1.0 are treated a bit differently in NPM than in Terraform\n        // meaning that NPMs ^0.4 doesn't allow 0.55 while TFs ~>0.4 allows 0.55\n        if (majorIsZero && minorSpecified) {\n          range = \\`>=\\${parsed.version} <1.0.0\\`;\n        }\n\n        return semver.satisfies(version, range);\n      }\n      case \">=\":\n        return semver.gte(version, cleanedParsedVersion);\n      case \"<=\":\n        return semver.lte(version, cleanedParsedVersion);\n      case \">\":\n        return semver.gt(version, cleanedParsedVersion);\n      case \"<\":\n        return semver.lt(version, cleanedParsedVersion);\n      default:\n        throw Errors.External(\n          \\`Unknown constraint operator: \\${parsed.operator} in version constraint \\${constraint}\\`\n        );\n    }\n  });\n}\n`;\n  }\n}\n"]}

package/lib/scripts/should-release.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+import { FileBase, FileBaseOptions } from "projen";
+import { NodeProject } from "projen/lib/javascript";
+export interface ShouldReleaseScriptFileOptions extends FileBaseOptions {
+}
+export declare class ShouldReleaseScriptFile extends FileBase {
+    protected readonly options: ShouldReleaseScriptFileOptions;
+    constructor(project: NodeProject, options: ShouldReleaseScriptFileOptions);
+    protected synthesizeContent(): string | undefined;
+}