@cdktn/provider-generator 0.24.0-pre.9 → 0.24.0-pre.91

package/src/get/__tests__/generator/fixtures/provider-functions.test.fixture.json

@@ -0,0 +1,170 @@
+{
+  "provider_schemas": {
+    "registry.terraform.io/hashicorp/time": {
+      "provider": {
+        "version": 0,
+        "block": {
+          "description": "Use Terraform to trigger actions and generate time based data. Currently supports outputting time or ranges of time from a supplied timestamp, as well as basic date manipulation, encoding into RFC3339, and describing durations.\n\nThis provider is intended to be used in Terraform configurations that require basic date/time functionality where existing time-related data does not exist. Since this provider does not use any external APIs, it does not require any configuration and is used to fill in gaps where the Terraform configuration language itself does not yet support certain functionality.",
+          "description_kind": "markdown"
+        }
+      },
+      "resource_schemas": {
+        "time_static": {
+          "version": 0,
+          "block": {
+            "attributes": {
+              "day": {
+                "type": "number",
+                "description": "Number day of timestamp.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "hour": {
+                "type": "number",
+                "description": "Number hour of timestamp.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "id": {
+                "type": "string",
+                "description": "RFC3339 format of the offset timestamp, e.g. `2020-02-12T06:36:13Z`.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "minute": {
+                "type": "number",
+                "description": "Number minute of timestamp.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "month": {
+                "type": "number",
+                "description": "Number month of timestamp.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "rfc3339": {
+                "type": "string",
+                "description": "Base timestamp in [RFC3339](https://datatracker.ietf.org/doc/html/rfc3339#section-5.8) format (see [RFC3339 time string](https://tools.ietf.org/html/rfc3339#section-5.8) e.g., `YYYY-MM-DDTHH:MM:SSZ`). Defaults to the current time.",
+                "description_kind": "plain",
+                "optional": true,
+                "computed": true
+              },
+              "second": {
+                "type": "number",
+                "description": "Number second of timestamp.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "triggers": {
+                "type": [
+                  "map",
+                  "string"
+                ],
+                "description": "Arbitrary map of values that, when changed, will trigger a new base timestamp value to be saved. See [the main provider documentation](../index.md) for more information.",
+                "description_kind": "plain",
+                "optional": true
+              },
+              "unix": {
+                "type": "number",
+                "description": "Number of seconds since epoch time, e.g. `1581489373`.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "year": {
+                "type": "number",
+                "description": "Number year of timestamp.",
+                "description_kind": "plain",
+                "computed": true
+              }
+            },
+            "description": "Manages a static time resource, which keeps a locally sourced UTC timestamp stored in the Terraform state. This prevents perpetual differences caused by using the [`timestamp()` function](https://www.terraform.io/docs/configuration/functions/timestamp.html).",
+            "description_kind": "plain"
+          }
+        }
+      },
+      "functions": {
+        "duration_parse": {
+          "description": "Given a [Go duration string](https://pkg.go.dev/time#ParseDuration), will parse and return an object representation of that duration.",
+          "summary": "Parse a [Go duration string](https://pkg.go.dev/time#ParseDuration) into an object",
+          "return_type": [
+            "object",
+            {
+              "hours": "number",
+              "microseconds": "number",
+              "milliseconds": "number",
+              "minutes": "number",
+              "nanoseconds": "number",
+              "seconds": "number"
+            }
+          ],
+          "parameters": [
+            {
+              "name": "duration",
+              "description": "Go time package duration string to parse",
+              "type": "string"
+            }
+          ]
+        },
+        "rfc3339_parse": {
+          "description": "Given an RFC3339 timestamp string, will parse and return an object representation of that date and time.",
+          "summary": "Parse an RFC3339 timestamp string into an object",
+          "return_type": [
+            "object",
+            {
+              "day": "number",
+              "hour": "number",
+              "iso_week": "number",
+              "iso_year": "number",
+              "minute": "number",
+              "month": "number",
+              "month_name": "string",
+              "second": "number",
+              "unix": "number",
+              "weekday": "number",
+              "weekday_name": "string",
+              "year": "number",
+              "year_day": "number"
+            }
+          ],
+          "parameters": [
+            {
+              "name": "timestamp",
+              "description": "RFC3339 timestamp string to parse",
+              "type": "string"
+            }
+          ]
+        },
+        "unix_timestamp_parse": {
+          "description": "Given a unix timestamp integer, will parse and return an object representation of that date and time. A unix timestamp is the number of seconds elapsed since January 1, 1970 UTC.",
+          "summary": "Parse a unix timestamp integer into an object",
+          "return_type": [
+            "object",
+            {
+              "day": "number",
+              "hour": "number",
+              "iso_week": "number",
+              "iso_year": "number",
+              "minute": "number",
+              "month": "number",
+              "month_name": "string",
+              "rfc3339": "string",
+              "second": "number",
+              "weekday": "number",
+              "weekday_name": "string",
+              "year": "number",
+              "year_day": "number"
+            }
+          ],
+          "parameters": [
+            {
+              "name": "unix_timestamp",
+              "description": "Unix Timestamp integer to parse",
+              "type": "number"
+            }
+          ]
+        }
+      }
+    }
+  }
+}

package/src/get/__tests__/generator/fixtures/write-only.test.fixture.json

@@ -0,0 +1,58 @@
+{
+  "provider_schemas": {
+    "registry.terraform.io/hashicorp/vault": {
+      "resource_schemas": {
+        "vault_alicloud_secret_backend": {
+          "version": 0,
+          "block": {
+            "attributes": {
+              "access_key": {
+                "type": "string",
+                "description": "The AliCloud Access Key ID to use when generating new credentials.",
+                "description_kind": "markdown",
+                "required": true,
+                "sensitive": true
+              },
+              "mount": {
+                "type": "string",
+                "description": "Path of the AliCloud secrets engine mount. Must match the `path` of a `vault_mount` resource with `type = \"alicloud\"`. Use `vault_mount.alicloud.path` here.",
+                "description_kind": "markdown",
+                "required": true
+              },
+              "namespace": {
+                "type": "string",
+                "description": "Target namespace. (requires Enterprise)",
+                "description_kind": "markdown",
+                "optional": true
+              },
+              "secret_key_wo": {
+                "type": "string",
+                "description": "Write-only AliCloud Secret Access Key. This value will never be read back from Vault.",
+                "description_kind": "markdown",
+                "required": true,
+                "sensitive": true,
+                "write_only": true
+              },
+              "secondary_secret_key_wo": {
+                "type": "string",
+                "description": "Optional write-only secondary AliCloud Secret Access Key. This value will never be read back from Vault.",
+                "description_kind": "markdown",
+                "optional": true,
+                "sensitive": true,
+                "write_only": true
+              },
+              "secret_key_wo_version": {
+                "type": "number",
+                "description": "A version counter for the write-only `secret_key_wo` field. Incrementing this value will trigger an update to the secret key in Vault.",
+                "description_kind": "markdown",
+                "required": true
+              }
+            },
+            "description": "Configures the AliCloud secrets engine credentials. The mount itself must be created first using a `vault_mount` resource with `type = \"alicloud\"`. Use `vault_mount.alicloud.id` as `mount_id` on ephemeral resources to guarantee deferral.",
+            "description_kind": "markdown"
+          }
+        }
+      }
+    }
+  }
+}

package/src/get/__tests__/generator/import-style.test.ts

@@ -0,0 +1,129 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { CodeMaker } from "codemaker";
+import {
+  TerraformProviderGenerator,
+  type TerraformProviderGeneratorOptions,
+} from "../../generator/provider-generator";
+
+const fixture = JSON.parse(
+  fs.readFileSync(
+    path.join(__dirname, "fixtures", "aws_wafv2_web_acl.test.fixture.json"),
+    "utf-8",
+  ),
+);
+
+async function generate(options: TerraformProviderGeneratorOptions = {}) {
+  const code = new CodeMaker();
+  const workdir = fs.mkdtempSync(path.join(os.tmpdir(), "import-style.test"));
+  new TerraformProviderGenerator(code, fixture, options).generateAll();
+  await code.save(workdir);
+  return workdir;
+}
+
+const RESOURCE_INDEX = "providers/test/wafv2-web-acl/index.ts";
+const STRUCTS_INDEX = "providers/test/wafv2-web-acl/index-structs/index.ts";
+const STRUCTS_DIR = "providers/test/wafv2-web-acl/index-structs";
+const PROVIDER_INDEX = "providers/test/index.ts";
+
+function readAllShards(workdir: string): string {
+  return fs
+    .readdirSync(path.join(workdir, STRUCTS_DIR))
+    .filter((f) => /^structs\d+\.ts$/.test(f))
+    .map((f) => fs.readFileSync(path.join(workdir, STRUCTS_DIR, f), "utf-8"))
+    .join("\n");
+}
+
+test("default (no importExtension): emits explicit /index for folders, bare for files", async () => {
+  const workdir = await generate();
+
+  const resource = fs.readFileSync(path.join(workdir, RESOURCE_INDEX), "utf-8");
+  expect(resource).toContain(`} from './index-structs/index'`);
+  expect(resource).toContain(`export * from './index-structs/index'`);
+  expect(resource).not.toMatch(/from '\.\/[^']*\.(js|ts)'/);
+
+  const structsIndex = fs.readFileSync(
+    path.join(workdir, STRUCTS_INDEX),
+    "utf-8",
+  );
+  expect(structsIndex).toContain(`export * from './structs0'`);
+  expect(structsIndex).not.toMatch(/from '\.\/[^']*\.(js|ts)'/);
+
+  const providerIndex = fs.readFileSync(
+    path.join(workdir, PROVIDER_INDEX),
+    "utf-8",
+  );
+  expect(providerIndex).toMatch(/from '\.\/[^']+\/index';/);
+});
+
+test("importExtension '.js': emits fully-qualified ./<folder>/index.js and ./<file>.js", async () => {
+  const workdir = await generate({ importExtension: ".js" });
+
+  const resource = fs.readFileSync(path.join(workdir, RESOURCE_INDEX), "utf-8");
+  expect(resource).toContain(`} from './index-structs/index.js'`);
+  expect(resource).toContain(`export * from './index-structs/index.js'`);
+
+  const structsIndex = fs.readFileSync(
+    path.join(workdir, STRUCTS_INDEX),
+    "utf-8",
+  );
+  expect(structsIndex).toContain(`export * from './structs0.js'`);
+
+  const allShards = readAllShards(workdir);
+  expect(allShards).toMatch(/from '\.\/structs\d+\.js'/);
+
+  const providerIndex = fs.readFileSync(
+    path.join(workdir, PROVIDER_INDEX),
+    "utf-8",
+  );
+  expect(providerIndex).toMatch(/from '\.\/[^']+\/index\.js';/);
+});
+
+test("importExtension '.ts': emits fully-qualified ./<folder>/index.ts and ./<file>.ts", async () => {
+  const workdir = await generate({ importExtension: ".ts" });
+
+  const resource = fs.readFileSync(path.join(workdir, RESOURCE_INDEX), "utf-8");
+  expect(resource).toContain(`} from './index-structs/index.ts'`);
+  expect(resource).toContain(`export * from './index-structs/index.ts'`);
+
+  const structsIndex = fs.readFileSync(
+    path.join(workdir, STRUCTS_INDEX),
+    "utf-8",
+  );
+  expect(structsIndex).toContain(`export * from './structs0.ts'`);
+
+  const allShards = readAllShards(workdir);
+  expect(allShards).toMatch(/from '\.\/structs\d+\.ts'/);
+
+  const providerIndex = fs.readFileSync(
+    path.join(workdir, PROVIDER_INDEX),
+    "utf-8",
+  );
+  expect(providerIndex).toMatch(/from '\.\/[^']+\/index\.ts';/);
+});
+
+test("importExtension '': emits explicit /index for folders, bare for files", async () => {
+  const workdir = await generate({ importExtension: "" });
+
+  const resource = fs.readFileSync(path.join(workdir, RESOURCE_INDEX), "utf-8");
+  expect(resource).toContain(`} from './index-structs/index'`);
+  expect(resource).toContain(`export * from './index-structs/index'`);
+  expect(resource).not.toMatch(/from '\.\/[^']*\.(js|ts)'/);
+
+  const structsIndex = fs.readFileSync(
+    path.join(workdir, STRUCTS_INDEX),
+    "utf-8",
+  );
+  // file targets get the (empty) extension, so they stay bare
+  expect(structsIndex).toContain(`export * from './structs0'`);
+  expect(structsIndex).not.toMatch(/from '\.\/[^']*\.(js|ts)'/);
+
+  const providerIndex = fs.readFileSync(
+    path.join(workdir, PROVIDER_INDEX),
+    "utf-8",
+  );
+  expect(providerIndex).toMatch(/from '\.\/[^']+\/index';/);
+});