@jttc/projen-project-types 1.0.0-beta.0 → 1.0.0-beta.10

package/lib/terraform/components/terraform-plan-github-workflow.js

@@ -0,0 +1,155 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerraformPlanGithubWorkflow = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_1 = require("projen");
+const github_1 = require("projen/lib/github");
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+/**
+ * GitHub workflow component for Terraform plan on Pull Requests.
+ * Creates a workflow that validates, plans Terraform changes and comments results on PRs.
+ *
+ * This component is designed for Terraform stack projects to show plan results
+ * in Pull Requests without actually applying changes.
+ */
+class TerraformPlanGithubWorkflow extends projen_1.Component {
+    constructor(project, options = {}) {
+        super(project);
+        // Get or create GitHub component - use root project for subprojects, current project otherwise
+        const targetProject = project.parent ? project.root : project;
+        let github = targetProject.components.find((c) => c.constructor.name === 'GitHub');
+        if (!github) {
+            github = new github_1.GitHub(targetProject);
+        }
+        const workflowName = options.workflowName ?? 'terraform-plan';
+        const terraformVersion = options.terraformVersion ?? '1.6.0';
+        const workingDirectory = options.workingDirectory ?? (project.parent ? project.outdir : '.');
+        const workflow = github.addWorkflow(workflowName);
+        workflow.on({
+            pullRequest: {
+                branches: ['main'],
+                paths: ['**.tf', '**.tfvars'],
+            },
+        });
+        // Add environment variable for working directory
+        workflow.addJob('terraform-plan', {
+            name: 'Terraform Plan',
+            runsOn: ['ubuntu-latest'],
+            env: {
+                tf_actions_working_dir: workingDirectory,
+            },
+            defaults: {
+                run: {
+                    workingDirectory: '${{ env.tf_actions_working_dir }}',
+                },
+            },
+            permissions: {
+                contents: workflows_model_1.JobPermission.READ,
+                pullRequests: workflows_model_1.JobPermission.WRITE,
+            },
+            steps: [
+                {
+                    name: 'Checkout',
+                    uses: 'actions/checkout@v4',
+                },
+                {
+                    name: 'Setup Terraform',
+                    uses: 'hashicorp/setup-terraform@v3',
+                    with: {
+                        terraformVersion: terraformVersion,
+                    },
+                },
+                {
+                    name: 'Terraform Format',
+                    id: 'fmt',
+                    run: 'terraform fmt -check',
+                    continueOnError: true,
+                },
+                {
+                    name: 'Terraform Init',
+                    id: 'init',
+                    run: 'terraform init -input=false',
+                },
+                {
+                    name: 'Terraform Validate',
+                    id: 'validate',
+                    run: 'terraform validate -no-color',
+                },
+                {
+                    name: 'Terraform Plan',
+                    id: 'plan',
+                    run: 'terraform plan -no-color -input=false',
+                    continueOnError: true,
+                },
+                {
+                    name: 'Comment PR',
+                    uses: 'actions/github-script@v7',
+                    if: "github.event_name == 'pull_request'",
+                    env: {
+                        PLAN: 'terraform\\n${{ steps.plan.outputs.stdout }}',
+                    },
+                    with: {
+                        'github-token': '${{ secrets.GITHUB_TOKEN }}',
+                        script: `
+              // 1. Retrieve existing bot comments for the PR
+              const { data: comments } = await github.rest.issues.listComments({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.issue.number,
+              })
+              const botComment = comments.find(comment => {
+                return comment.user.type === 'Bot' && comment.body.includes('Terraform Format and Style')
+              })
+
+              // 2. Prepare format of the comment
+              const output = \`#### Terraform Format and Style 🖌\\\`\${{ steps.fmt.outcome }}\\\`
+              #### Terraform Initialization ⚙️\\\`\${{ steps.init.outcome }}\\\`
+              #### Terraform Validation 🤖\\\`\${{ steps.validate.outcome }}\\\`
+              <details><summary>Validation Output</summary>
+
+              \\\`\\\`\\\`
+              \${{ steps.validate.outputs.stdout }}
+              \\\`\\\`\\\`
+
+              </details>
+
+              #### Terraform Plan 📖\\\`\${{ steps.plan.outcome }}\\\`
+
+              <details><summary>Show Plan</summary>
+
+              \\\`\\\`\\\`
+              \${process.env.PLAN}
+              \\\`\\\`\\\`
+
+              </details>
+
+              *Pusher: @\${{ github.actor }}, Action: \\\`\${{ github.event_name }}\\\`, Working Directory: \\\`\${{ env.tf_actions_working_dir }}\\\`, Workflow: \\\`\${{ github.workflow }}\\\`*\`;
+
+              // 3. If we have a comment, update it, otherwise create a new one
+              if (botComment) {
+                github.rest.issues.updateComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  comment_id: botComment.id,
+                  body: output
+                })
+              } else {
+                github.rest.issues.createComment({
+                  issue_number: context.issue.number,
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  body: output
+                })
+              }
+            `,
+                    },
+                },
+            ],
+        });
+    }
+}
+exports.TerraformPlanGithubWorkflow = TerraformPlanGithubWorkflow;
+_a = JSII_RTTI_SYMBOL_1;
+TerraformPlanGithubWorkflow[_a] = { fqn: "@jttc/projen-project-types.TerraformPlanGithubWorkflow", version: "1.0.0-beta.10" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terraform-plan-github-workflow.js","sourceRoot":"","sources":["../../../src/terraform/components/terraform-plan-github-workflow.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Project } from 'projen';\nimport { GitHub } from 'projen/lib/github';\nimport { JobPermission } from 'projen/lib/github/workflows-model';\n\n/**\n * Options for TerraformPlanGithubWorkflow component.\n */\nexport interface TerraformPlanGithubWorkflowOptions {\n  /**\n   * Terraform version to use in the workflow.\n   * @default \"1.6.0\"\n   */\n  readonly terraformVersion?: string;\n\n  /**\n   * Name of the workflow.\n   * @default \"terraform-plan\"\n   */\n  readonly workflowName?: string;\n\n  /**\n   * Working directory for Terraform commands.\n   * @default \".\"\n   */\n  readonly workingDirectory?: string;\n}\n\n/**\n * GitHub workflow component for Terraform plan on Pull Requests.\n * Creates a workflow that validates, plans Terraform changes and comments results on PRs.\n *\n * This component is designed for Terraform stack projects to show plan results\n * in Pull Requests without actually applying changes.\n */\nexport class TerraformPlanGithubWorkflow extends Component {\n  constructor(\n    project: Project,\n    options: TerraformPlanGithubWorkflowOptions = {},\n  ) {\n    super(project);\n\n    // Get or create GitHub component - use root project for subprojects, current project otherwise\n    const targetProject = project.parent ? project.root : project;\n    let github = targetProject.components.find(\n      (c) => c.constructor.name === 'GitHub',\n    ) as GitHub;\n    if (!github) {\n      github = new GitHub(targetProject);\n    }\n\n    const workflowName = options.workflowName ?? 'terraform-plan';\n    const terraformVersion = options.terraformVersion ?? '1.6.0';\n    const workingDirectory =\n      options.workingDirectory ?? (project.parent ? project.outdir : '.');\n\n    const workflow = github.addWorkflow(workflowName);\n\n    workflow.on({\n      pullRequest: {\n        branches: ['main'],\n        paths: ['**.tf', '**.tfvars'],\n      },\n    });\n\n    // Add environment variable for working directory\n    workflow.addJob('terraform-plan', {\n      name: 'Terraform Plan',\n      runsOn: ['ubuntu-latest'],\n      env: {\n        tf_actions_working_dir: workingDirectory,\n      },\n      defaults: {\n        run: {\n          workingDirectory: '${{ env.tf_actions_working_dir }}',\n        },\n      },\n      permissions: {\n        contents: JobPermission.READ,\n        pullRequests: JobPermission.WRITE,\n      },\n      steps: [\n        {\n          name: 'Checkout',\n          uses: 'actions/checkout@v4',\n        },\n        {\n          name: 'Setup Terraform',\n          uses: 'hashicorp/setup-terraform@v3',\n          with: {\n            terraformVersion: terraformVersion,\n          },\n        },\n        {\n          name: 'Terraform Format',\n          id: 'fmt',\n          run: 'terraform fmt -check',\n          continueOnError: true,\n        },\n        {\n          name: 'Terraform Init',\n          id: 'init',\n          run: 'terraform init -input=false',\n        },\n        {\n          name: 'Terraform Validate',\n          id: 'validate',\n          run: 'terraform validate -no-color',\n        },\n        {\n          name: 'Terraform Plan',\n          id: 'plan',\n          run: 'terraform plan -no-color -input=false',\n          continueOnError: true,\n        },\n        {\n          name: 'Comment PR',\n          uses: 'actions/github-script@v7',\n          if: \"github.event_name == 'pull_request'\",\n          env: {\n            PLAN: 'terraform\\\\n${{ steps.plan.outputs.stdout }}',\n          },\n          with: {\n            'github-token': '${{ secrets.GITHUB_TOKEN }}',\n            script: `\n              // 1. Retrieve existing bot comments for the PR\n              const { data: comments } = await github.rest.issues.listComments({\n                owner: context.repo.owner,\n                repo: context.repo.repo,\n                issue_number: context.issue.number,\n              })\n              const botComment = comments.find(comment => {\n                return comment.user.type === 'Bot' && comment.body.includes('Terraform Format and Style')\n              })\n\n              // 2. Prepare format of the comment\n              const output = \\`#### Terraform Format and Style 🖌\\\\\\`\\${{ steps.fmt.outcome }}\\\\\\`\n              #### Terraform Initialization ⚙️\\\\\\`\\${{ steps.init.outcome }}\\\\\\`\n              #### Terraform Validation 🤖\\\\\\`\\${{ steps.validate.outcome }}\\\\\\`\n              <details><summary>Validation Output</summary>\n\n              \\\\\\`\\\\\\`\\\\\\`\n              \\${{ steps.validate.outputs.stdout }}\n              \\\\\\`\\\\\\`\\\\\\`\n\n              </details>\n\n              #### Terraform Plan 📖\\\\\\`\\${{ steps.plan.outcome }}\\\\\\`\n\n              <details><summary>Show Plan</summary>\n\n              \\\\\\`\\\\\\`\\\\\\`\n              \\${process.env.PLAN}\n              \\\\\\`\\\\\\`\\\\\\`\n\n              </details>\n\n              *Pusher: @\\${{ github.actor }}, Action: \\\\\\`\\${{ github.event_name }}\\\\\\`, Working Directory: \\\\\\`\\${{ env.tf_actions_working_dir }}\\\\\\`, Workflow: \\\\\\`\\${{ github.workflow }}\\\\\\`*\\`;\n\n              // 3. If we have a comment, update it, otherwise create a new one\n              if (botComment) {\n                github.rest.issues.updateComment({\n                  owner: context.repo.owner,\n                  repo: context.repo.repo,\n                  comment_id: botComment.id,\n                  body: output\n                })\n              } else {\n                github.rest.issues.createComment({\n                  issue_number: context.issue.number,\n                  owner: context.repo.owner,\n                  repo: context.repo.repo,\n                  body: output\n                })\n              }\n            `,\n          },\n        },\n      ],\n    });\n  }\n}\n"]}

package/lib/terraform/index.d.ts

@@ -0,0 +1,5 @@
+export * from './components';
+export * from './terraform-base-project';
+export * from './terraform-stack-project';
+export * from './terraform-module-project';
+export * from './providers';

package/lib/terraform/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./components"), exports);
+__exportStar(require("./terraform-base-project"), exports);
+__exportStar(require("./terraform-stack-project"), exports);
+__exportStar(require("./terraform-module-project"), exports);
+__exportStar(require("./providers"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVycmFmb3JtL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwrQ0FBNkI7QUFDN0IsMkRBQXlDO0FBQ3pDLDREQUEwQztBQUMxQyw2REFBMkM7QUFDM0MsOENBQTRCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vdGVycmFmb3JtLWJhc2UtcHJvamVjdCc7XG5leHBvcnQgKiBmcm9tICcuL3RlcnJhZm9ybS1zdGFjay1wcm9qZWN0JztcbmV4cG9ydCAqIGZyb20gJy4vdGVycmFmb3JtLW1vZHVsZS1wcm9qZWN0JztcbmV4cG9ydCAqIGZyb20gJy4vcHJvdmlkZXJzJztcbiJdfQ==

package/lib/terraform/providers/hetzner-provider.d.ts

@@ -0,0 +1,105 @@
+import { TerraformProvider, TerraformProviderOptions } from './provider-strategy';
+/**
+ * Poll function types for Hetzner Cloud provider.
+ */
+export declare enum HetznerPollFunction {
+    /**
+     * Constant polling interval.
+     */
+    CONSTANT = "constant",
+    /**
+     * Exponential backoff polling.
+     */
+    EXPONENTIAL = "exponential"
+}
+/**
+ * Configuration for a specific Hetzner Cloud provider instance.
+ */
+export interface HetznerProviderConfig {
+    /**
+     * Provider alias for multiple configurations.
+     */
+    readonly alias?: string;
+    /**
+     * Hetzner Cloud API token (can be set via HCLOUD_TOKEN env var).
+     * Required unless useEnvironmentToken is true or set via environment variable.
+     */
+    readonly token?: string;
+    /**
+     * Use HCLOUD_TOKEN environment variable for authentication.
+     * When true, the token will be read from HCLOUD_TOKEN environment variable
+     * and no explicit token configuration will be generated in the provider block.
+     * This is useful for CI/CD pipelines and different environments.
+     * @default true
+     */
+    readonly useEnvironmentToken?: boolean;
+    /**
+     * Hetzner Cloud API endpoint.
+     * @default "https://api.hetzner.cloud/v1"
+     */
+    readonly endpoint?: string;
+    /**
+     * Hetzner API endpoint (for Hetzner services, not Hetzner Cloud).
+     * @default "https://api.hetzner.com/v1"
+     */
+    readonly endpointHetzner?: string;
+    /**
+     * Configures the interval in which actions are polled by the client.
+     * @default "500ms"
+     * @example "1s", "2000ms"
+     */
+    readonly pollInterval?: string;
+    /**
+     * Configures the type of function to be used during polling.
+     * @default "exponential"
+     */
+    readonly pollFunction?: HetznerPollFunction;
+}
+/**
+ * Options for Hetzner Terraform provider.
+ */
+export interface HetznerProviderOptions extends TerraformProviderOptions {
+    /**
+     * Array of provider configurations for multiple instances/projects.
+     * Each configuration can have its own alias, token, and settings.
+     *
+     * If empty or not provided, a default configuration will be created
+     * with useEnvironmentToken: true and no alias.
+     *
+     * @example
+     * // Simple case - uses default configuration with HCLOUD_TOKEN env var
+     * new HetznerProvider({
+     *   version: '~> 1.45'
+     * })
+     *
+     * // Multiple configurations
+     * new HetznerProvider({
+     *   version: '~> 1.45',
+     *   providers: [
+     *     {
+     *       alias: 'dns',
+     *       token: 'dns-project-token',
+     *       useEnvironmentToken: false
+     *     },
+     *     {
+     *       alias: 'staging',
+     *       useEnvironmentToken: true
+     *     }
+     *   ]
+     * })
+     */
+    readonly providers?: HetznerProviderConfig[];
+}
+/**
+ * Hetzner Cloud Terraform provider configuration.
+ */
+export declare class HetznerProvider extends TerraformProvider {
+    private readonly providerConfigs;
+    constructor(options: HetznerProviderOptions);
+    providerSource(): string;
+    generateProviderBlock(): string[];
+    /**
+     * Add a new provider configuration.
+     */
+    addProviderConfig(config: HetznerProviderConfig): void;
+}

package/lib/terraform/providers/hetzner-provider.js

@@ -0,0 +1,83 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HetznerProvider = exports.HetznerPollFunction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_strategy_1 = require("./provider-strategy");
+/**
+ * Poll function types for Hetzner Cloud provider.
+ */
+var HetznerPollFunction;
+(function (HetznerPollFunction) {
+    /**
+     * Constant polling interval.
+     */
+    HetznerPollFunction["CONSTANT"] = "constant";
+    /**
+     * Exponential backoff polling.
+     */
+    HetznerPollFunction["EXPONENTIAL"] = "exponential";
+})(HetznerPollFunction || (exports.HetznerPollFunction = HetznerPollFunction = {}));
+/**
+ * Hetzner Cloud Terraform provider configuration.
+ */
+class HetznerProvider extends provider_strategy_1.TerraformProvider {
+    constructor(options) {
+        super('hcloud', options);
+        // If no providers are specified, create a default configuration
+        this.providerConfigs =
+            options.providers && options.providers.length > 0
+                ? options.providers
+                : [
+                    {
+                        useEnvironmentToken: true,
+                    },
+                ];
+    }
+    providerSource() {
+        return 'hetznercloud/hcloud';
+    }
+    generateProviderBlock() {
+        const lines = [];
+        // Generate provider block for each configuration
+        this.providerConfigs.forEach((config) => {
+            lines.push('provider "hcloud" {');
+            if (config.alias) {
+                lines.push(`  alias = "${config.alias}"`);
+            }
+            if (config.useEnvironmentToken !== false) {
+                lines.push('  # token will be read from HCLOUD_TOKEN environment variable');
+            }
+            else if (config.token) {
+                lines.push(`  token = "${config.token}"`);
+            }
+            else {
+                lines.push('  # token = var.hcloud_token  # Please set token or use useEnvironmentToken: true');
+            }
+            if (config.endpoint) {
+                lines.push(`  endpoint = "${config.endpoint}"`);
+            }
+            if (config.endpointHetzner) {
+                lines.push(`  endpoint_hetzner = "${config.endpointHetzner}"`);
+            }
+            if (config.pollInterval) {
+                lines.push(`  poll_interval = "${config.pollInterval}"`);
+            }
+            if (config.pollFunction) {
+                lines.push(`  poll_function = "${config.pollFunction}"`);
+            }
+            lines.push('}');
+        });
+        return lines;
+    }
+    /**
+     * Add a new provider configuration.
+     */
+    addProviderConfig(config) {
+        this.providerConfigs.push(config);
+    }
+}
+exports.HetznerProvider = HetznerProvider;
+_a = JSII_RTTI_SYMBOL_1;
+HetznerProvider[_a] = { fqn: "@jttc/projen-project-types.HetznerProvider", version: "1.0.0-beta.10" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hetzner-provider.js","sourceRoot":"","sources":["../../../src/terraform/providers/hetzner-provider.ts"],"names":[],"mappings":";;;;;AAAA,2DAG6B;AAE7B;;GAEG;AACH,IAAY,mBAUX;AAVD,WAAY,mBAAmB;IAC7B;;OAEG;IACH,4CAAqB,CAAA;IAErB;;OAEG;IACH,kDAA2B,CAAA;AAC7B,CAAC,EAVW,mBAAmB,mCAAnB,mBAAmB,QAU9B;AAwFD;;GAEG;AACH,MAAa,eAAgB,SAAQ,qCAAiB;IAGpD,YAAY,OAA+B;QACzC,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAEzB,gEAAgE;QAChE,IAAI,CAAC,eAAe;YAClB,OAAO,CAAC,SAAS,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC;gBAC/C,CAAC,CAAC,OAAO,CAAC,SAAS;gBACnB,CAAC,CAAC;oBACE;wBACE,mBAAmB,EAAE,IAAI;qBAC1B;iBACF,CAAC;IACV,CAAC;IAEM,cAAc;QACnB,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IAEM,qBAAqB;QAC1B,MAAM,KAAK,GAAa,EAAE,CAAC;QAE3B,iDAAiD;QACjD,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YACtC,KAAK,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;YAElC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;gBACjB,KAAK,CAAC,IAAI,CAAC,cAAc,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC;YAC5C,CAAC;YAED,IAAI,MAAM,CAAC,mBAAmB,KAAK,KAAK,EAAE,CAAC;gBACzC,KAAK,CAAC,IAAI,CACR,+DAA+D,CAChE,CAAC;YACJ,CAAC;iBAAM,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;gBACxB,KAAK,CAAC,IAAI,CAAC,cAAc,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC;YAC5C,CAAC;iBAAM,CAAC;gBACN,KAAK,CAAC,IAAI,CACR,mFAAmF,CACpF,CAAC;YACJ,CAAC;YAED,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACpB,KAAK,CAAC,IAAI,CAAC,iBAAiB,MAAM,CAAC,QAAQ,GAAG,CAAC,CAAC;YAClD,CAAC;YAED,IAAI,MAAM,CAAC,eAAe,EAAE,CAAC;gBAC3B,KAAK,CAAC,IAAI,CAAC,yBAAyB,MAAM,CAAC,eAAe,GAAG,CAAC,CAAC;YACjE,CAAC;YAED,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;gBACxB,KAAK,CAAC,IAAI,CAAC,sBAAsB,MAAM,CAAC,YAAY,GAAG,CAAC,CAAC;YAC3D,CAAC;YAED,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;gBACxB,KAAK,CAAC,IAAI,CAAC,sBAAsB,MAAM,CAAC,YAAY,GAAG,CAAC,CAAC;YAC3D,CAAC;YAED,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;QAEH,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACI,iBAAiB,CAAC,MAA6B;QACpD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;;AAvEH,0CAwEC","sourcesContent":["import {\n  TerraformProvider,\n  TerraformProviderOptions,\n} from './provider-strategy';\n\n/**\n * Poll function types for Hetzner Cloud provider.\n */\nexport enum HetznerPollFunction {\n  /**\n   * Constant polling interval.\n   */\n  CONSTANT = 'constant',\n\n  /**\n   * Exponential backoff polling.\n   */\n  EXPONENTIAL = 'exponential',\n}\n\n/**\n * Configuration for a specific Hetzner Cloud provider instance.\n */\nexport interface HetznerProviderConfig {\n  /**\n   * Provider alias for multiple configurations.\n   */\n  readonly alias?: string;\n\n  /**\n   * Hetzner Cloud API token (can be set via HCLOUD_TOKEN env var).\n   * Required unless useEnvironmentToken is true or set via environment variable.\n   */\n  readonly token?: string;\n\n  /**\n   * Use HCLOUD_TOKEN environment variable for authentication.\n   * When true, the token will be read from HCLOUD_TOKEN environment variable\n   * and no explicit token configuration will be generated in the provider block.\n   * This is useful for CI/CD pipelines and different environments.\n   * @default true\n   */\n  readonly useEnvironmentToken?: boolean;\n\n  /**\n   * Hetzner Cloud API endpoint.\n   * @default \"https://api.hetzner.cloud/v1\"\n   */\n  readonly endpoint?: string;\n\n  /**\n   * Hetzner API endpoint (for Hetzner services, not Hetzner Cloud).\n   * @default \"https://api.hetzner.com/v1\"\n   */\n  readonly endpointHetzner?: string;\n\n  /**\n   * Configures the interval in which actions are polled by the client.\n   * @default \"500ms\"\n   * @example \"1s\", \"2000ms\"\n   */\n  readonly pollInterval?: string;\n\n  /**\n   * Configures the type of function to be used during polling.\n   * @default \"exponential\"\n   */\n  readonly pollFunction?: HetznerPollFunction;\n}\n\n/**\n * Options for Hetzner Terraform provider.\n */\nexport interface HetznerProviderOptions extends TerraformProviderOptions {\n  /**\n   * Array of provider configurations for multiple instances/projects.\n   * Each configuration can have its own alias, token, and settings.\n   *\n   * If empty or not provided, a default configuration will be created\n   * with useEnvironmentToken: true and no alias.\n   *\n   * @example\n   * // Simple case - uses default configuration with HCLOUD_TOKEN env var\n   * new HetznerProvider({\n   *   version: '~> 1.45'\n   * })\n   *\n   * // Multiple configurations\n   * new HetznerProvider({\n   *   version: '~> 1.45',\n   *   providers: [\n   *     {\n   *       alias: 'dns',\n   *       token: 'dns-project-token',\n   *       useEnvironmentToken: false\n   *     },\n   *     {\n   *       alias: 'staging',\n   *       useEnvironmentToken: true\n   *     }\n   *   ]\n   * })\n   */\n  readonly providers?: HetznerProviderConfig[];\n}\n\n/**\n * Hetzner Cloud Terraform provider configuration.\n */\nexport class HetznerProvider extends TerraformProvider {\n  private readonly providerConfigs: HetznerProviderConfig[];\n\n  constructor(options: HetznerProviderOptions) {\n    super('hcloud', options);\n\n    // If no providers are specified, create a default configuration\n    this.providerConfigs =\n      options.providers && options.providers.length > 0\n        ? options.providers\n        : [\n            {\n              useEnvironmentToken: true,\n            },\n          ];\n  }\n\n  public providerSource(): string {\n    return 'hetznercloud/hcloud';\n  }\n\n  public generateProviderBlock(): string[] {\n    const lines: string[] = [];\n\n    // Generate provider block for each configuration\n    this.providerConfigs.forEach((config) => {\n      lines.push('provider \"hcloud\" {');\n\n      if (config.alias) {\n        lines.push(`  alias = \"${config.alias}\"`);\n      }\n\n      if (config.useEnvironmentToken !== false) {\n        lines.push(\n          '  # token will be read from HCLOUD_TOKEN environment variable',\n        );\n      } else if (config.token) {\n        lines.push(`  token = \"${config.token}\"`);\n      } else {\n        lines.push(\n          '  # token = var.hcloud_token  # Please set token or use useEnvironmentToken: true',\n        );\n      }\n\n      if (config.endpoint) {\n        lines.push(`  endpoint = \"${config.endpoint}\"`);\n      }\n\n      if (config.endpointHetzner) {\n        lines.push(`  endpoint_hetzner = \"${config.endpointHetzner}\"`);\n      }\n\n      if (config.pollInterval) {\n        lines.push(`  poll_interval = \"${config.pollInterval}\"`);\n      }\n\n      if (config.pollFunction) {\n        lines.push(`  poll_function = \"${config.pollFunction}\"`);\n      }\n\n      lines.push('}');\n    });\n\n    return lines;\n  }\n\n  /**\n   * Add a new provider configuration.\n   */\n  public addProviderConfig(config: HetznerProviderConfig): void {\n    this.providerConfigs.push(config);\n  }\n}\n"]}

package/lib/terraform/providers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './provider-strategy';
+export * from './hetzner-provider';

package/lib/terraform/providers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./provider-strategy"), exports);
+__exportStar(require("./hetzner-provider"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGVycmFmb3JtL3Byb3ZpZGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsc0RBQW9DO0FBQ3BDLHFEQUFtQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHJvdmlkZXItc3RyYXRlZ3knO1xuZXhwb3J0ICogZnJvbSAnLi9oZXR6bmVyLXByb3ZpZGVyJztcbiJdfQ==

package/lib/terraform/providers/provider-strategy.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Base options for Terraform providers.
+ */
+export interface TerraformProviderOptions {
+    /**
+     * Provider version constraint.
+     * @example "~> 5.0"
+     */
+    readonly version?: string;
+    /**
+     * Provider alias (optional).
+     */
+    readonly alias?: string;
+}
+/**
+ * Base class for Terraform provider configurations.
+ * This is a strategy class that holds configuration, not a Projen component.
+ */
+export declare abstract class TerraformProvider {
+    protected readonly version?: string;
+    protected readonly alias?: string;
+    protected readonly providerName: string;
+    constructor(providerName: string, options?: TerraformProviderOptions);
+    /**
+     * Get the provider alias for the required_providers block.
+     */
+    providerAlias(): string;
+    /**
+     * Get the provider source (e.g., "hashicorp/aws").
+     */
+    abstract providerSource(): string;
+    /**
+     * Generate the provider configuration block.
+     */
+    abstract generateProviderBlock(): string[];
+    /**
+     * Get the version constraint.
+     */
+    versionConstraint(): string | undefined;
+    /**
+     * Get the provider name.
+     */
+    name(): string;
+}

package/lib/terraform/providers/provider-strategy.js

@@ -0,0 +1,38 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerraformProvider = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Base class for Terraform provider configurations.
+ * This is a strategy class that holds configuration, not a Projen component.
+ */
+class TerraformProvider {
+    constructor(providerName, options) {
+        this.providerName = providerName;
+        this.version = options?.version;
+        this.alias = options?.alias;
+    }
+    /**
+     * Get the provider alias for the required_providers block.
+     */
+    providerAlias() {
+        return this.alias || this.providerName;
+    }
+    /**
+     * Get the version constraint.
+     */
+    versionConstraint() {
+        return this.version;
+    }
+    /**
+     * Get the provider name.
+     */
+    name() {
+        return this.providerName;
+    }
+}
+exports.TerraformProvider = TerraformProvider;
+_a = JSII_RTTI_SYMBOL_1;
+TerraformProvider[_a] = { fqn: "@jttc/projen-project-types.TerraformProvider", version: "1.0.0-beta.10" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/terraform/terraform-base-project.d.ts

@@ -0,0 +1,38 @@
+import { Project, ProjectOptions } from 'projen';
+import { TerraformProvider } from './providers';
+/**
+ * Options for Terraform base project.
+ */
+export interface TerraformBaseProjectOptions extends ProjectOptions {
+    /**
+     * Minimum required Terraform version.
+     * @default "1.6.0"
+     */
+    readonly terraformVersion?: string;
+    /**
+     * Terraform provider configuration.
+     */
+    readonly provider?: TerraformProvider;
+}
+/**
+ * Base Terraform project that provides common Terraform configuration.
+ */
+export declare class TerraformBaseProject extends Project {
+    private _provider?;
+    private readonly _terraformVersion;
+    constructor(options: TerraformBaseProjectOptions);
+    /**
+     * Add a provider to this Terraform project.
+     * Only one provider per project is allowed.
+     */
+    addProvider(provider: TerraformProvider): void;
+    /**
+     * Get the current provider.
+     */
+    get provider(): TerraformProvider | undefined;
+    preSynthesize(): void;
+    /**
+     * Generate the provider.tf file if a provider is configured.
+     */
+    private generateProviderFile;
+}