@cdktn/provider-generator 0.24.0-pre.87 → 0.24.0-pre.89

package/src/get/__tests__/generator/__snapshots__/write-only.test.ts.snap

@@ -0,0 +1,262 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`generate a vault_alicloud_secret_backend resource with a write-only attribute 1`] = `
+"// https://registry.terraform.io/providers/hashicorp/vault/latest/docs/resources/alicloud_secret_backend
+// generated from terraform resource schema
+
+import { Construct } from 'constructs';
+import * as cdktn from 'cdktn';
+
+// Configuration
+
+export interface AlicloudSecretBackendConfig extends cdktn.TerraformMetaArguments {
+  /**
+  * The AliCloud Access Key ID to use when generating new credentials.
+  *
+  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/vault/latest/docs/resources/alicloud_secret_backend#access_key AlicloudSecretBackend#access_key}
+  */
+  readonly accessKey: string;
+  /**
+  * 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.
+  *
+  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/vault/latest/docs/resources/alicloud_secret_backend#mount AlicloudSecretBackend#mount}
+  */
+  readonly mount: string;
+  /**
+  * Target namespace. (requires Enterprise)
+  *
+  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/vault/latest/docs/resources/alicloud_secret_backend#namespace AlicloudSecretBackend#namespace}
+  */
+  readonly namespace?: string;
+  /**
+  * Write-only AliCloud Secret Access Key. This value will never be read back from Vault.
+  *
+  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/vault/latest/docs/resources/alicloud_secret_backend#secret_key_wo AlicloudSecretBackend#secret_key_wo}
+  */
+  readonly secretKeyWo: string;
+  /**
+  * Optional write-only secondary AliCloud Secret Access Key. This value will never be read back from Vault.
+  *
+  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/vault/latest/docs/resources/alicloud_secret_backend#secondary_secret_key_wo AlicloudSecretBackend#secondary_secret_key_wo}
+  */
+  readonly secondarySecretKeyWo?: string;
+  /**
+  * A version counter for the write-only \`secret_key_wo\` field. Incrementing this value will trigger an update to the secret key in Vault.
+  *
+  * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/vault/latest/docs/resources/alicloud_secret_backend#secret_key_wo_version AlicloudSecretBackend#secret_key_wo_version}
+  */
+  readonly secretKeyWoVersion: number;
+}
+
+/**
+* Represents a {@link https://registry.terraform.io/providers/hashicorp/vault/latest/docs/resources/alicloud_secret_backend vault_alicloud_secret_backend}
+*/
+export class AlicloudSecretBackend extends cdktn.TerraformResource {
+
+  // =================
+  // STATIC PROPERTIES
+  // =================
+  public static readonly tfResourceType = "vault_alicloud_secret_backend";
+
+  // ==============
+  // STATIC Methods
+  // ==============
+  /**
+  * Generates CDKTN code for importing a AlicloudSecretBackend resource upon running "cdktn plan <stack-name>"
+  * @param scope The scope in which to define this construct
+  * @param importToId The construct id used in the generated config for the AlicloudSecretBackend to import
+  * @param importFromId The id of the existing AlicloudSecretBackend that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/vault/latest/docs/resources/alicloud_secret_backend#import import section} in the documentation of this resource for the id to use
+  * @param provider? Optional instance of the provider where the AlicloudSecretBackend to import is found
+  */
+  public static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktn.TerraformProvider) {
+        return new cdktn.ImportableResource(scope, importToId, { terraformResourceType: "vault_alicloud_secret_backend", importId: importFromId, provider });
+      }
+
+  // ===========
+  // INITIALIZER
+  // ===========
+
+  /**
+  * Create a new {@link https://registry.terraform.io/providers/hashicorp/vault/latest/docs/resources/alicloud_secret_backend vault_alicloud_secret_backend} Resource
+  *
+  * @param scope The scope in which to define this construct
+  * @param id The scoped construct ID. Must be unique amongst siblings in the same scope
+  * @param options AlicloudSecretBackendConfig
+  */
+  public constructor(scope: Construct, id: string, config: AlicloudSecretBackendConfig) {
+    super(scope, id, {
+      terraformResourceType: 'vault_alicloud_secret_backend',
+      terraformGeneratorMetadata: {
+        providerName: 'vault'
+      },
+      provider: config.provider,
+      dependsOn: config.dependsOn,
+      count: config.count,
+      lifecycle: config.lifecycle,
+      provisioners: config.provisioners,
+      connection: config.connection,
+      forEach: config.forEach
+    });
+    this._accessKey = config.accessKey;
+    this._mount = config.mount;
+    this._namespace = config.namespace;
+    this._secretKeyWo = config.secretKeyWo;
+    this._secondarySecretKeyWo = config.secondarySecretKeyWo;
+    this._secretKeyWoVersion = config.secretKeyWoVersion;
+  }
+
+  // ==========
+  // ATTRIBUTES
+  // ==========
+
+  // access_key - computed: false, optional: false, required: true
+  private _accessKey?: string; 
+  public get accessKey() {
+    return this.getStringAttribute('access_key');
+  }
+  public set accessKey(value: string) {
+    this._accessKey = value;
+  }
+  // Temporarily expose input value. Use with caution.
+  public get accessKeyInput() {
+    return this._accessKey;
+  }
+
+  // mount - computed: false, optional: false, required: true
+  private _mount?: string; 
+  public get mount() {
+    return this.getStringAttribute('mount');
+  }
+  public set mount(value: string) {
+    this._mount = value;
+  }
+  // Temporarily expose input value. Use with caution.
+  public get mountInput() {
+    return this._mount;
+  }
+
+  // namespace - computed: false, optional: true, required: false
+  private _namespace?: string; 
+  public get namespace() {
+    return this.getStringAttribute('namespace');
+  }
+  public set namespace(value: string) {
+    this._namespace = value;
+  }
+  public resetNamespace() {
+    this._namespace = undefined;
+  }
+  // Temporarily expose input value. Use with caution.
+  public get namespaceInput() {
+    return this._namespace;
+  }
+
+  // secret_key_wo - computed: false, optional: false, required: true
+  private _secretKeyWo?: string; 
+  /**
+  * @deprecated Write-only: the provider never returns this value; reading it always yields null by protocol contract. The getter remains for compatibility and will be removed in a future prebuilt-provider major.
+  */
+  public get secretKeyWo() {
+    return this.getStringAttribute('secret_key_wo');
+  }
+  public set secretKeyWo(value: string) {
+    this._secretKeyWo = value;
+  }
+  // Temporarily expose input value. Use with caution.
+  public get secretKeyWoInput() {
+    return this._secretKeyWo;
+  }
+
+  // secondary_secret_key_wo - computed: false, optional: true, required: false
+  private _secondarySecretKeyWo?: string; 
+  /**
+  * @deprecated Write-only: the provider never returns this value; reading it always yields null by protocol contract. The getter remains for compatibility and will be removed in a future prebuilt-provider major.
+  */
+  public get secondarySecretKeyWo() {
+    return this.getStringAttribute('secondary_secret_key_wo');
+  }
+  public set secondarySecretKeyWo(value: string) {
+    this._secondarySecretKeyWo = value;
+  }
+  public resetSecondarySecretKeyWo() {
+    this._secondarySecretKeyWo = undefined;
+  }
+  // Temporarily expose input value. Use with caution.
+  public get secondarySecretKeyWoInput() {
+    return this._secondarySecretKeyWo;
+  }
+
+  // secret_key_wo_version - computed: false, optional: false, required: true
+  private _secretKeyWoVersion?: number; 
+  public get secretKeyWoVersion() {
+    return this.getNumberAttribute('secret_key_wo_version');
+  }
+  public set secretKeyWoVersion(value: number) {
+    this._secretKeyWoVersion = value;
+  }
+  // Temporarily expose input value. Use with caution.
+  public get secretKeyWoVersionInput() {
+    return this._secretKeyWoVersion;
+  }
+
+  // =========
+  // SYNTHESIS
+  // =========
+
+  protected synthesizeAttributes(): { [name: string]: any } {
+    return {
+      access_key: cdktn.stringToTerraform(this._accessKey),
+      mount: cdktn.stringToTerraform(this._mount),
+      namespace: cdktn.stringToTerraform(this._namespace),
+      secret_key_wo: this.markWriteOnlyAttribute(cdktn.stringToTerraform(this._secretKeyWo)),
+      secondary_secret_key_wo: this.markWriteOnlyAttribute(cdktn.stringToTerraform(this._secondarySecretKeyWo)),
+      secret_key_wo_version: cdktn.numberToTerraform(this._secretKeyWoVersion),
+    };
+  }
+
+  protected synthesizeHclAttributes(): { [name: string]: any } {
+    const attrs = {
+      access_key: {
+        value: cdktn.stringToHclTerraform(this._accessKey),
+        isBlock: false,
+        type: "simple",
+        storageClassType: "string",
+      },
+      mount: {
+        value: cdktn.stringToHclTerraform(this._mount),
+        isBlock: false,
+        type: "simple",
+        storageClassType: "string",
+      },
+      namespace: {
+        value: cdktn.stringToHclTerraform(this._namespace),
+        isBlock: false,
+        type: "simple",
+        storageClassType: "string",
+      },
+      secret_key_wo: {
+        value: this.markWriteOnlyAttribute(cdktn.stringToHclTerraform(this._secretKeyWo)),
+        isBlock: false,
+        type: "simple",
+        storageClassType: "string",
+      },
+      secondary_secret_key_wo: {
+        value: this.markWriteOnlyAttribute(cdktn.stringToHclTerraform(this._secondarySecretKeyWo)),
+        isBlock: false,
+        type: "simple",
+        storageClassType: "string",
+      },
+      secret_key_wo_version: {
+        value: cdktn.numberToHclTerraform(this._secretKeyWoVersion),
+        isBlock: false,
+        type: "simple",
+        storageClassType: "number",
+      },
+    };
+
+    // remove undefined attributes
+    return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined ))
+  }
+}
+"
+`;

package/src/get/__tests__/generator/ephemeral-resources.test.ts

@@ -0,0 +1,46 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { CodeMaker } from "codemaker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("generate an ephemeral random_password resource alongside a regular random_uuid resource", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("ephemeral.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "ephemeral-resources.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const ephemeralOutput = fs.readFileSync(
+    path.join(workdir, "providers/random/ephemeral-random-password/index.ts"),
+    "utf-8",
+  );
+  expect(ephemeralOutput).toMatchSnapshot("ephemeral-random-password");
+
+  const resourceOutput = fs.readFileSync(
+    path.join(workdir, "providers/random/uuid/index.ts"),
+    "utf-8",
+  );
+  expect(resourceOutput).toMatchSnapshot("random-uuid");
+
+  const providerIndex = fs.readFileSync(
+    path.join(workdir, "providers/random/index.ts"),
+    "utf-8",
+  );
+  expect(providerIndex).toMatchSnapshot("provider-index");
+
+  const providerLazyIndex = fs.readFileSync(
+    path.join(workdir, "providers/random/lazy-index.ts"),
+    "utf-8",
+  );
+  expect(providerLazyIndex).toMatchSnapshot("provider-lazy-index");
+});

package/src/get/__tests__/generator/fixtures/ephemeral-resources.test.fixture.json

@@ -0,0 +1,160 @@
+{
+  "provider_schemas": {
+    "registry.terraform.io/hashicorp/random": {
+      "resource_schemas": {
+        "random_uuid": {
+          "version": 0,
+          "block": {
+            "attributes": {
+              "id": {
+                "type": "string",
+                "description": "The generated uuid presented in string format.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "keepers": {
+                "type": [
+                  "map",
+                  "string"
+                ],
+                "description": "Arbitrary map of values that, when changed, will trigger recreation of resource. See [the main provider documentation](../index.html) for more information.",
+                "description_kind": "plain",
+                "optional": true
+              },
+              "result": {
+                "type": "string",
+                "description": "The generated uuid presented in string format.",
+                "description_kind": "plain",
+                "computed": true
+              }
+            },
+            "description": "The resource `random_uuid` generates a random uuid string that is intended to be used as a unique identifier for other resources.\n\nThis resource uses [hashicorp/go-uuid](https://github.com/hashicorp/go-uuid) to generate a UUID-formatted string for use with services needing a unique string identifier.",
+            "description_kind": "plain"
+          }
+        }
+      },
+      "ephemeral_resource_schemas": {
+        "random_bytes": {
+          "version": 0,
+          "block": {
+            "attributes": {
+              "base64": {
+                "type": "string",
+                "description": "The generated bytes presented in base64 string format.",
+                "description_kind": "plain",
+                "computed": true,
+                "sensitive": true
+              },
+              "hex": {
+                "type": "string",
+                "description": "The generated bytes presented in lowercase hexadecimal string format. The length of the encoded string is exactly twice the `length` parameter.",
+                "description_kind": "plain",
+                "computed": true,
+                "sensitive": true
+              },
+              "length": {
+                "type": "number",
+                "description": "The number of bytes requested. The minimum value for length is 1.",
+                "description_kind": "plain",
+                "required": true
+              }
+            },
+            "description": "-> If the managed resource doesn't have a write-only argument available for the secret (first introduced in Terraform 1.11), then the secret can only be created with the managed resource variant of [`random_bytes`](https://registry.terraform.io/providers/hashicorp/random/latest/docs/resources/bytes).\n\nGenerates ephemeral random bytes using a cryptographic random number generator.\n\nThe primary use-case for generating ephemeral random bytes is to be used in combination with a write-only argument in a managed resource, which will avoid Terraform storing the secret value in the plan or state file.",
+            "description_kind": "plain"
+          }
+        },
+        "random_password": {
+          "version": 0,
+          "block": {
+            "attributes": {
+              "bcrypt_hash": {
+                "type": "string",
+                "description": "A bcrypt hash of the generated random string. **NOTE**: If the generated random string is greater than 72 bytes in length, `bcrypt_hash` will contain a hash of the first 72 bytes.",
+                "description_kind": "plain",
+                "computed": true,
+                "sensitive": true
+              },
+              "length": {
+                "type": "number",
+                "description": "The length of the string desired. The minimum value for length is 1 and, length must also be >= (`min_upper` + `min_lower` + `min_numeric` + `min_special`).",
+                "description_kind": "plain",
+                "required": true
+              },
+              "lower": {
+                "type": "bool",
+                "description": "Include lowercase alphabet characters in the result. Default value is `true`.",
+                "description_kind": "plain",
+                "optional": true,
+                "computed": true
+              },
+              "min_lower": {
+                "type": "number",
+                "description": "Minimum number of lowercase alphabet characters in the result. Default value is `0`.",
+                "description_kind": "plain",
+                "optional": true,
+                "computed": true
+              },
+              "min_numeric": {
+                "type": "number",
+                "description": "Minimum number of numeric characters in the result. Default value is `0`.",
+                "description_kind": "plain",
+                "optional": true,
+                "computed": true
+              },
+              "min_special": {
+                "type": "number",
+                "description": "Minimum number of special characters in the result. Default value is `0`.",
+                "description_kind": "plain",
+                "optional": true,
+                "computed": true
+              },
+              "min_upper": {
+                "type": "number",
+                "description": "Minimum number of uppercase alphabet characters in the result. Default value is `0`.",
+                "description_kind": "plain",
+                "optional": true,
+                "computed": true
+              },
+              "numeric": {
+                "type": "bool",
+                "description": "Include numeric characters in the result. Default value is `true`. If `numeric`, `upper`, `lower`, and `special` are all configured, at least one of them must be set to `true`.",
+                "description_kind": "plain",
+                "optional": true,
+                "computed": true
+              },
+              "override_special": {
+                "type": "string",
+                "description": "Supply your own list of special characters to use for string generation.  This overrides the default character list in the special argument.  The `special` argument must still be set to true for any overwritten characters to be used in generation.",
+                "description_kind": "plain",
+                "optional": true
+              },
+              "result": {
+                "type": "string",
+                "description": "The generated random string.",
+                "description_kind": "plain",
+                "computed": true,
+                "sensitive": true
+              },
+              "special": {
+                "type": "bool",
+                "description": "Include special characters in the result. These are `!@#$%&*()-_=+[]{}<>:?`. Default value is `true`.",
+                "description_kind": "plain",
+                "optional": true,
+                "computed": true
+              },
+              "upper": {
+                "type": "bool",
+                "description": "Include uppercase alphabet characters in the result. Default value is `true`.",
+                "description_kind": "plain",
+                "optional": true,
+                "computed": true
+              }
+            },
+            "description": "-> If the managed resource doesn't have a write-only argument available for the password (first introduced in Terraform 1.11), then the password can only be created with the managed resource variant of [`random_password`](https://registry.terraform.io/providers/hashicorp/random/latest/docs/resources/password).\n\nGenerates an ephemeral password string using a cryptographic random number generator.\n\nThe primary use-case for generating an ephemeral random password is to be used in combination with a write-only argument in a managed resource, which will avoid Terraform storing the password string in the plan or state file.",
+            "description_kind": "plain"
+          }
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,31 @@
+{
+  "provider_schemas": {
+    "registry.terraform.io/hashicorp/example": {
+      "provider": {
+        "version": 0,
+        "block": {
+          "attributes": {
+            "functions": {
+              "type": "string",
+              "description": "A config attribute that happens to be named the same as the generated functions getter.",
+              "description_kind": "plain",
+              "optional": true
+            }
+          }
+        }
+      },
+      "functions": {
+        "greet": {
+          "description": "Greets the given name.",
+          "return_type": "string",
+          "parameters": [
+            {
+              "name": "name",
+              "type": "string"
+            }
+          ]
+        }
+      }
+    }
+  }
+}