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

package/build/get/generator/emitter/provider-functions-emitter.d.ts

@@ -0,0 +1,11 @@
+import { CodeMaker } from "codemaker";
+import { ProviderFunctionsModel } from "../models/provider-function-model";
+export declare class ProviderFunctionsEmitter {
+    private readonly code;
+    constructor(code: CodeMaker);
+    emit(model: ProviderFunctionsModel): void;
+    private emitClass;
+    private emitConstructor;
+    private emitMethod;
+}
+//# sourceMappingURL=provider-functions-emitter.d.ts.map

package/build/get/generator/emitter/provider-functions-emitter.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderFunctionsEmitter = void 0;
+const sanitized_comments_1 = require("../sanitized-comments");
+const PROVIDER_LOCAL_NAME_JSDOC = "The local name of the provider in required_providers; defaults to the registry short name. Override when the provider is declared under a different local name — aliases do not change the namespace, local names do.";
+class ProviderFunctionsEmitter {
+    constructor(code) {
+        this.code = code;
+    }
+    emit(model) {
+        this.code.line(`import * as cdktn from 'cdktn';`);
+        this.code.line();
+        this.emitClass(model);
+    }
+    emitClass(model) {
+        const comment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        comment.line(`Provider-defined functions of the ${model.providerName} provider.`);
+        comment.end();
+        this.code.openBlock(`export class ${model.className}`);
+        this.emitConstructor();
+        for (const fn of model.functions) {
+            this.emitMethod(fn);
+        }
+        this.code.closeBlock();
+    }
+    emitConstructor() {
+        // A TypeScript parameter property (`constructor(private readonly x: T)`)
+        // requires the compiler to synthesize a `this.x = x;` assignment - that's
+        // a real transform, not a type-only erasure, so it isn't recognized by
+        // Node's native type-stripping (`node file.ts` with no bundler/transpiler,
+        // e.g. `--experimental-strip-types`), which throws
+        // `ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX` on sight of one. Declare the field
+        // and assign it in the constructor body instead, which strips cleanly.
+        this.code.line(`private readonly providerLocalName: string;`);
+        this.code.line();
+        const comment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        comment.line(`@param providerLocalName ${PROVIDER_LOCAL_NAME_JSDOC}`);
+        comment.end();
+        this.code.openBlock(`constructor(providerLocalName: string)`);
+        this.code.line(`this.providerLocalName = providerLocalName;`);
+        this.code.closeBlock();
+    }
+    emitMethod(fn) {
+        var _a;
+        this.code.line();
+        const comment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        const description = (_a = fn.description) !== null && _a !== void 0 ? _a : fn.summary;
+        if (description)
+            comment.line(description);
+        if (fn.deprecationMessage) {
+            comment.line(`@deprecated ${fn.deprecationMessage}`);
+        }
+        // The variadic parameter's docstringType is already wrapped in
+        // `Array<...>` by buildFunctionModel (see provider-function-model.ts),
+        // so it shares this one `@param` emission path with every fixed
+        // parameter instead of needing its own wrapping here.
+        const allParameters = fn.variadicParameter
+            ? [...fn.parameters, fn.variadicParameter]
+            : fn.parameters;
+        for (const param of allParameters) {
+            // Official JSDoc grammar: only the type expression goes inside the
+            // braces; prose (the schema description plus any generated
+            // list/set/nullability guidance - see the model's `docstringNote`)
+            // follows the parameter name after ` - `.
+            const prose = [param.description, param.docstringNote]
+                .filter(Boolean)
+                .join(" ");
+            comment.line(`@param {${param.docstringType}} ${param.name}${prose ? ` - ${prose}` : ""}`);
+        }
+        comment.line(`@returns {${fn.returnDocstringType}}${fn.returnDocstringNote ? ` ${fn.returnDocstringNote}` : ""}`);
+        comment.end();
+        const methodParams = [
+            ...fn.parameters.map((p) => `${p.name}${p.optional ? "?" : ""}: ${p.tsType}`),
+            ...(fn.variadicParameter
+                ? // `Array<T>` rather than `T[]`: for a union element type (e.g.
+                    // `boolean | cdktn.IResolvable`), bare `T[]` binds as `boolean |
+                    // (cdktn.IResolvable[])` instead of `(boolean | cdktn.IResolvable)[]`.
+                    [
+                        `${fn.variadicParameter.name}: Array<${fn.variadicParameter.tsType}>`,
+                    ]
+                : []),
+        ];
+        const invokeArgs = [
+            ...fn.parameters.map((p) => p.name),
+            ...(fn.variadicParameter ? [`...${fn.variadicParameter.name}`] : []),
+        ];
+        const invokeExpression = `cdktn.TerraformProviderFunction.invoke(this.providerLocalName, "${fn.terraformName}", [${invokeArgs.join(", ")}])`;
+        this.code.openBlock(`public ${fn.methodName}(${methodParams.join(", ")}): ${fn.returnTsType}`);
+        this.code.line(`return ${fn.wrapReturn(invokeExpression)};`);
+        this.code.closeBlock();
+    }
+}
+exports.ProviderFunctionsEmitter = ProviderFunctionsEmitter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider-functions-emitter.js","sourceRoot":"","sources":["../../../../src/get/generator/emitter/provider-functions-emitter.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { CodeMaker } from \"codemaker\";\nimport {\n  ProviderFunctionModel,\n  ProviderFunctionsModel,\n} from \"../models/provider-function-model\";\nimport { sanitizedComment } from \"../sanitized-comments\";\n\nconst PROVIDER_LOCAL_NAME_JSDOC =\n  \"The local name of the provider in required_providers; defaults to the registry short name. Override when the provider is declared under a different local name — aliases do not change the namespace, local names do.\";\n\nexport class ProviderFunctionsEmitter {\n  constructor(private readonly code: CodeMaker) {}\n\n  public emit(model: ProviderFunctionsModel) {\n    this.code.line(`import * as cdktn from 'cdktn';`);\n    this.code.line();\n    this.emitClass(model);\n  }\n\n  private emitClass(model: ProviderFunctionsModel) {\n    const comment = sanitizedComment(this.code);\n    comment.line(\n      `Provider-defined functions of the ${model.providerName} provider.`,\n    );\n    comment.end();\n    this.code.openBlock(`export class ${model.className}`);\n\n    this.emitConstructor();\n\n    for (const fn of model.functions) {\n      this.emitMethod(fn);\n    }\n\n    this.code.closeBlock();\n  }\n\n  private emitConstructor() {\n    // A TypeScript parameter property (`constructor(private readonly x: T)`)\n    // requires the compiler to synthesize a `this.x = x;` assignment - that's\n    // a real transform, not a type-only erasure, so it isn't recognized by\n    // Node's native type-stripping (`node file.ts` with no bundler/transpiler,\n    // e.g. `--experimental-strip-types`), which throws\n    // `ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX` on sight of one. Declare the field\n    // and assign it in the constructor body instead, which strips cleanly.\n    this.code.line(`private readonly providerLocalName: string;`);\n    this.code.line();\n    const comment = sanitizedComment(this.code);\n    comment.line(`@param providerLocalName ${PROVIDER_LOCAL_NAME_JSDOC}`);\n    comment.end();\n    this.code.openBlock(`constructor(providerLocalName: string)`);\n    this.code.line(`this.providerLocalName = providerLocalName;`);\n    this.code.closeBlock();\n  }\n\n  private emitMethod(fn: ProviderFunctionModel) {\n    this.code.line();\n\n    const comment = sanitizedComment(this.code);\n    const description = fn.description ?? fn.summary;\n    if (description) comment.line(description);\n    if (fn.deprecationMessage) {\n      comment.line(`@deprecated ${fn.deprecationMessage}`);\n    }\n    // The variadic parameter's docstringType is already wrapped in\n    // `Array<...>` by buildFunctionModel (see provider-function-model.ts),\n    // so it shares this one `@param` emission path with every fixed\n    // parameter instead of needing its own wrapping here.\n    const allParameters = fn.variadicParameter\n      ? [...fn.parameters, fn.variadicParameter]\n      : fn.parameters;\n    for (const param of allParameters) {\n      // Official JSDoc grammar: only the type expression goes inside the\n      // braces; prose (the schema description plus any generated\n      // list/set/nullability guidance - see the model's `docstringNote`)\n      // follows the parameter name after ` - `.\n      const prose = [param.description, param.docstringNote]\n        .filter(Boolean)\n        .join(\" \");\n      comment.line(\n        `@param {${param.docstringType}} ${param.name}${prose ? ` - ${prose}` : \"\"}`,\n      );\n    }\n    comment.line(\n      `@returns {${fn.returnDocstringType}}${fn.returnDocstringNote ? ` ${fn.returnDocstringNote}` : \"\"}`,\n    );\n    comment.end();\n\n    const methodParams = [\n      ...fn.parameters.map(\n        (p) => `${p.name}${p.optional ? \"?\" : \"\"}: ${p.tsType}`,\n      ),\n      ...(fn.variadicParameter\n        ? // `Array<T>` rather than `T[]`: for a union element type (e.g.\n          // `boolean | cdktn.IResolvable`), bare `T[]` binds as `boolean |\n          // (cdktn.IResolvable[])` instead of `(boolean | cdktn.IResolvable)[]`.\n          [\n            `${fn.variadicParameter.name}: Array<${fn.variadicParameter.tsType}>`,\n          ]\n        : []),\n    ];\n\n    const invokeArgs = [\n      ...fn.parameters.map((p) => p.name),\n      ...(fn.variadicParameter ? [`...${fn.variadicParameter.name}`] : []),\n    ];\n\n    const invokeExpression = `cdktn.TerraformProviderFunction.invoke(this.providerLocalName, \"${fn.terraformName}\", [${invokeArgs.join(\", \")}])`;\n\n    this.code.openBlock(\n      `public ${fn.methodName}(${methodParams.join(\", \")}): ${fn.returnTsType}`,\n    );\n    this.code.line(`return ${fn.wrapReturn(invokeExpression)};`);\n    this.code.closeBlock();\n  }\n}\n"]}

package/build/get/generator/emitter/resource-emitter.d.ts

@@ -3,17 +3,21 @@ import { ResourceModel } from "../models";
 import { AttributesEmitter } from "./attributes-emitter";
 export declare class ResourceEmitter {
     private readonly code;
+    private readonly importExtension;
     attributesEmitter: AttributesEmitter;
-    constructor(code: CodeMaker);
+    constructor(code: CodeMaker, importExtension: string);
     emit(resource: ResourceModel): void;
+    private emitFunctionsGetter;
     private emitHeader;
     private emitStaticProperties;
     private emitStaticMethods;
     private emitHclResourceSynthesis;
     private emitResourceSynthesis;
+    private supportsWriteOnlyRegistration;
     private emitResourceAttributes;
     private emitInitializer;
     private emitResourceSuper;
+    private emitEphemeralResourceSuper;
     private emitProviderSuper;
     private emitTerraformGeneratorMetadata;
 }

package/build/get/generator/emitter/resource-emitter.js

@@ -4,30 +4,68 @@ exports.ResourceEmitter = void 0;
 const attributes_emitter_1 = require("./attributes-emitter");
 const sanitized_comments_1 = require("../sanitized-comments");
 class ResourceEmitter {
-    constructor(code) {
+    constructor(code, importExtension) {
         this.code = code;
+        this.importExtension = importExtension;
         this.attributesEmitter = new attributes_emitter_1.AttributesEmitter(this.code);
     }
     emit(resource) {
         this.code.line();
+        if (resource.isProvider && resource.providerFunctionsModel) {
+            // Sibling-directory import: providers/<provider>/provider/index.ts
+            // (the emitted file) and providers/<provider>/provider-functions/
+            // index.ts are siblings under providers/<provider>/, so unlike the
+            // child-folder struct imports this one has to step up a level.
+            this.code.line(`import { ${resource.providerFunctionsModel.className} } from '../provider-functions/index${this.importExtension}';`);
+        }
         const comment = (0, sanitized_comments_1.sanitizedComment)(this.code);
         comment.line(`Represents a {@link ${resource.linkToDocs} ${resource.terraformResourceType}}`);
         comment.end();
         this.code.openBlock(`export class ${resource.className} extends cdktn.${resource.parentClassName}`);
         this.emitHeader("STATIC PROPERTIES");
         this.emitStaticProperties(resource);
-        this.emitHeader("STATIC Methods");
-        this.emitStaticMethods(resource);
+        if (!resource.isEphemeralResource) {
+            this.emitHeader("STATIC Methods");
+            this.emitStaticMethods(resource);
+        }
         this.emitHeader("INITIALIZER");
         this.emitInitializer(resource);
         this.emitHeader("ATTRIBUTES");
         this.emitResourceAttributes(resource);
+        if (resource.isProvider && resource.providerFunctionsModel) {
+            this.emitHeader("PROVIDER-DEFINED FUNCTIONS");
+            this.emitFunctionsGetter(resource.providerFunctionsModel);
+        }
         // synthesis
         this.emitHeader("SYNTHESIS");
         this.emitResourceSynthesis(resource);
         this.emitHclResourceSynthesis(resource);
         this.code.closeBlock(); // construct
     }
+    // Emits a memoized `functions` getter on a provider class that declares
+    // provider-defined functions. The local name to invoke functions under is
+    // derived from `this.terraformResourceType`, not baked in as the schema
+    // name constant: terraform-provider.ts keys both `required_providers` and
+    // the `provider` block directly off `terraformResourceType`, so whatever
+    // this instance's `terraformResourceType` is IS its correct
+    // required_providers local name (it already accounts for a `name`
+    // override in the cdktf.json provider constraint, see
+    // ConstructsMakerProviderTarget/TerraformProviderConstraint) - the
+    // instance always knows its own correct local name, so there is no need
+    // for a providerLocalName override parameter here.
+    emitFunctionsGetter(model) {
+        this.code.line(`private _functions?: ${model.className};`);
+        this.code.line();
+        const comment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        comment.line(`Provider-defined functions of the ${model.providerName} provider.`);
+        comment.end();
+        this.code.openBlock(`public get functions(): ${model.className}`);
+        this.code.openBlock(`if (!this._functions)`);
+        this.code.line(`this._functions = new ${model.className}(this.terraformResourceType);`);
+        this.code.closeBlock();
+        this.code.line(`return this._functions;`);
+        this.code.closeBlock();
+    }
     emitHeader(title) {
         this.code.line();
         this.code.line("// " + "=".repeat(title.length));
@@ -53,8 +91,9 @@ class ResourceEmitter {
         this.code.line();
         this.code.openBlock(`protected synthesizeHclAttributes(): { [name: string]: any }`);
         this.code.open(`const attrs = {`);
+        const registerWriteOnlyUsage = this.supportsWriteOnlyRegistration(resource);
         for (const att of resource.synthesizableAttributes) {
-            this.attributesEmitter.emitToHclTerraform(att, false);
+            this.attributesEmitter.emitToHclTerraform(att, false, registerWriteOnlyUsage);
         }
         this.code.close(`};`);
         if (resource.synthesizableAttributes.length > 0) {
@@ -71,12 +110,31 @@ class ResourceEmitter {
         this.code.line();
         this.code.openBlock(`protected synthesizeAttributes(): { [name: string]: any }`);
         this.code.open(`return {`);
+        const registerWriteOnlyUsage = this.supportsWriteOnlyRegistration(resource);
         for (const att of resource.synthesizableAttributes) {
-            this.attributesEmitter.emitToTerraform(att, false);
+            this.attributesEmitter.emitToTerraform(att, false, registerWriteOnlyUsage);
         }
         this.code.close(`};`);
         this.code.closeBlock();
     }
+    // `markWriteOnlyAttribute` (called from generated `synthesizeAttributes()`/
+    // `synthesizeHclAttributes()` for write-only attributes, see
+    // AttributesEmitter#emitToTerraform/#emitToHclTerraform) lives on
+    // TerraformResource - so only managed resources can register write-only
+    // usage; data sources, providers, and ephemeral resources only get the
+    // deprecated getter.
+    //
+    // write-only is fundamentally a state concept - the value is passed to
+    // the provider but never persisted to state - so gating this on
+    // TerraformResource is a semantic choice, not a capability one: ephemeral
+    // resources have no state at all, and, consistent with that, no provider
+    // schema in the RFC-04 sweep (including vault's 16 ephemeral resources)
+    // marks an ephemeral attribute write_only. So ephemeral classes
+    // deliberately land in the same "getter only" bucket as data sources and
+    // providers.
+    supportsWriteOnlyRegistration(resource) {
+        return resource.parentClassName === "TerraformResource";
+    }
     emitResourceAttributes(resource) {
         for (const att of resource.attributes) {
             this.attributesEmitter.emit(att, this.attributesEmitter.needsResetEscape(att, resource.attributes), this.attributesEmitter.needsInputEscape(att, resource.attributes));
@@ -85,7 +143,11 @@ class ResourceEmitter {
     emitInitializer(resource) {
         this.code.line();
         const comment = (0, sanitized_comments_1.sanitizedComment)(this.code);
-        comment.line(`Create a new {@link ${resource.linkToDocs} ${resource.terraformResourceType}} ${resource.isDataSource ? "Data Source" : "Resource"}`);
+        comment.line(`Create a new {@link ${resource.linkToDocs} ${resource.terraformResourceType}} ${resource.isDataSource
+            ? "Data Source"
+            : resource.isEphemeralResource
+                ? "Ephemeral Resource"
+                : "Resource"}`);
         comment.line(``);
         comment.line(`@param scope The scope in which to define this construct`);
         comment.line(`@param id The scoped construct ID. Must be unique amongst siblings in the same scope`);
@@ -95,6 +157,9 @@ class ResourceEmitter {
         if (resource.isProvider) {
             this.emitProviderSuper(resource);
         }
+        else if (resource.isEphemeralResource) {
+            this.emitEphemeralResourceSuper(resource);
+        }
         else {
             this.emitResourceSuper(resource);
         }
@@ -122,6 +187,17 @@ class ResourceEmitter {
         this.code.line(`forEach: config.forEach`);
         this.code.close(`});`);
     }
+    emitEphemeralResourceSuper(resource) {
+        this.code.open(`super(scope, id, {`);
+        this.code.line(`terraformResourceType: '${resource.terraformResourceType}',`);
+        this.emitTerraformGeneratorMetadata(resource);
+        this.code.line(`provider: config.provider,`);
+        this.code.line(`dependsOn: config.dependsOn,`);
+        this.code.line(`count: config.count,`);
+        this.code.line(`lifecycle: config.lifecycle,`);
+        this.code.line(`forEach: config.forEach`);
+        this.code.close(`});`);
+    }
     emitProviderSuper(resource) {
         this.code.open(`super(scope, id, {`);
         this.code.line(`terraformResourceType: '${resource.terraformResourceType}',`);
@@ -144,4 +220,4 @@ class ResourceEmitter {
     }
 }
 exports.ResourceEmitter = ResourceEmitter;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-emitter.js","sourceRoot":"","sources":["../../../../src/get/generator/emitter/resource-emitter.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { CodeMaker } from \"codemaker\";\nimport { ResourceModel } from \"../models\";\nimport { AttributesEmitter } from \"./attributes-emitter\";\nimport { sanitizedComment } from \"../sanitized-comments\";\n\nexport class ResourceEmitter {\n  attributesEmitter: AttributesEmitter;\n\n  constructor(private readonly code: CodeMaker) {\n    this.attributesEmitter = new AttributesEmitter(this.code);\n  }\n\n  public emit(resource: ResourceModel) {\n    this.code.line();\n    const comment = sanitizedComment(this.code);\n    comment.line(\n      `Represents a {@link ${resource.linkToDocs} ${resource.terraformResourceType}}`,\n    );\n    comment.end();\n    this.code.openBlock(\n      `export class ${resource.className} extends cdktn.${resource.parentClassName}`,\n    );\n\n    this.emitHeader(\"STATIC PROPERTIES\");\n    this.emitStaticProperties(resource);\n\n    this.emitHeader(\"STATIC Methods\");\n    this.emitStaticMethods(resource);\n\n    this.emitHeader(\"INITIALIZER\");\n    this.emitInitializer(resource);\n\n    this.emitHeader(\"ATTRIBUTES\");\n    this.emitResourceAttributes(resource);\n\n    // synthesis\n    this.emitHeader(\"SYNTHESIS\");\n    this.emitResourceSynthesis(resource);\n    this.emitHclResourceSynthesis(resource);\n\n    this.code.closeBlock(); // construct\n  }\n\n  private emitHeader(title: string) {\n    this.code.line();\n    this.code.line(\"// \" + \"=\".repeat(title.length));\n    this.code.line(`// ${title}`);\n    this.code.line(\"// \" + \"=\".repeat(title.length));\n  }\n\n  private emitStaticProperties(resource: ResourceModel) {\n    this.code.line(\n      `public static readonly tfResourceType = \"${resource.terraformResourceType}\";`,\n    );\n  }\n\n  private emitStaticMethods(resource: ResourceModel) {\n    const comment = sanitizedComment(this.code);\n    comment.line(\n      `Generates CDKTN code for importing a ${resource.className} resource upon running \"cdktn plan <stack-name>\"`,\n    );\n    comment.line(`@param scope The scope in which to define this construct`);\n    comment.line(\n      `@param importToId The construct id used in the generated config for the ${resource.className} to import`,\n    );\n    comment.line(\n      `@param importFromId The id of the existing ${resource.className} that should be imported. Refer to the {@link ${resource.linkToDocs}#import import section} in the documentation of this resource for the id to use`,\n    );\n    comment.line(\n      `@param provider? Optional instance of the provider where the ${resource.className} to import is found`,\n    );\n    comment.end();\n    this.code.line(\n      `public static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktn.TerraformProvider) {\n        return new cdktn.ImportableResource(scope, importToId, { terraformResourceType: \"${resource.terraformResourceType}\", importId: importFromId, provider });\n      }`,\n    );\n  }\n\n  private emitHclResourceSynthesis(resource: ResourceModel) {\n    this.code.line();\n    this.code.openBlock(\n      `protected synthesizeHclAttributes(): { [name: string]: any }`,\n    );\n    this.code.open(`const attrs = {`);\n\n    for (const att of resource.synthesizableAttributes) {\n      this.attributesEmitter.emitToHclTerraform(att, false);\n    }\n\n    this.code.close(`};`);\n\n    if (resource.synthesizableAttributes.length > 0) {\n      this.code.line();\n      this.code.line(`// remove undefined attributes`);\n      this.code.line(\n        `return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined ))`,\n      );\n    } else {\n      this.code.line(`return attrs;`);\n    }\n\n    this.code.closeBlock();\n  }\n\n  private emitResourceSynthesis(resource: ResourceModel) {\n    this.code.line();\n    this.code.openBlock(\n      `protected synthesizeAttributes(): { [name: string]: any }`,\n    );\n    this.code.open(`return {`);\n\n    for (const att of resource.synthesizableAttributes) {\n      this.attributesEmitter.emitToTerraform(att, false);\n    }\n\n    this.code.close(`};`);\n    this.code.closeBlock();\n  }\n\n  private emitResourceAttributes(resource: ResourceModel) {\n    for (const att of resource.attributes) {\n      this.attributesEmitter.emit(\n        att,\n        this.attributesEmitter.needsResetEscape(att, resource.attributes),\n        this.attributesEmitter.needsInputEscape(att, resource.attributes),\n      );\n    }\n  }\n\n  private emitInitializer(resource: ResourceModel) {\n    this.code.line();\n    const comment = sanitizedComment(this.code);\n    comment.line(\n      `Create a new {@link ${resource.linkToDocs} ${\n        resource.terraformResourceType\n      }} ${resource.isDataSource ? \"Data Source\" : \"Resource\"}`,\n    );\n    comment.line(``);\n    comment.line(`@param scope The scope in which to define this construct`);\n    comment.line(\n      `@param id The scoped construct ID. Must be unique amongst siblings in the same scope`,\n    );\n    comment.line(`@param options ${resource.configStruct.attributeType}`);\n    comment.end();\n    this.code.openBlock(\n      `public constructor(scope: Construct, id: string, config: ${resource.configStruct.attributeType})`,\n    );\n\n    if (resource.isProvider) {\n      this.emitProviderSuper(resource);\n    } else {\n      this.emitResourceSuper(resource);\n    }\n\n    // initialize config properties\n    for (const att of resource.configStruct.assignableAttributes) {\n      if (att.setterType._type === \"stored_class\") {\n        this.code.line(\n          `this.${att.storageName}.internalValue = config.${att.name};`,\n        );\n      } else {\n        this.code.line(`this.${att.storageName} = config.${att.name};`);\n      }\n    }\n\n    this.code.closeBlock();\n  }\n\n  private emitResourceSuper(resource: ResourceModel) {\n    this.code.open(`super(scope, id, {`);\n    this.code.line(\n      `terraformResourceType: '${resource.terraformResourceType}',`,\n    );\n    this.emitTerraformGeneratorMetadata(resource);\n    this.code.line(`provider: config.provider,`);\n    this.code.line(`dependsOn: config.dependsOn,`);\n    this.code.line(`count: config.count,`);\n    this.code.line(`lifecycle: config.lifecycle,`);\n    this.code.line(`provisioners: config.provisioners,`);\n    this.code.line(`connection: config.connection,`);\n    this.code.line(`forEach: config.forEach`);\n    this.code.close(`});`);\n  }\n\n  private emitProviderSuper(resource: ResourceModel) {\n    this.code.open(`super(scope, id, {`);\n    this.code.line(\n      `terraformResourceType: '${resource.terraformResourceType}',`,\n    );\n    this.emitTerraformGeneratorMetadata(resource);\n    this.code.line(\n      `terraformProviderSource: '${resource.terraformProviderSource}'`,\n    );\n    this.code.close(`});`);\n  }\n\n  private emitTerraformGeneratorMetadata(resource: ResourceModel) {\n    this.code.open(`terraformGeneratorMetadata: {`);\n    this.code.line(\n      `providerName: '${resource.provider}'${\n        resource.providerVersion || resource.providerVersionConstraint\n          ? \",\"\n          : \"\"\n      }`,\n    );\n\n    if (resource.providerVersion) {\n      this.code.line(\n        `providerVersion: '${resource.providerVersion}'${\n          resource.providerVersionConstraint ? \",\" : \"\"\n        }`,\n      );\n    }\n\n    if (resource.providerVersionConstraint) {\n      this.code.line(\n        `providerVersionConstraint: '${resource.providerVersionConstraint}'`,\n      );\n    }\n\n    this.code.close(`},`);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-emitter.js","sourceRoot":"","sources":["../../../../src/get/generator/emitter/resource-emitter.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { CodeMaker } from \"codemaker\";\nimport { ResourceModel } from \"../models\";\nimport { AttributesEmitter } from \"./attributes-emitter\";\nimport { sanitizedComment } from \"../sanitized-comments\";\n\nexport class ResourceEmitter {\n  attributesEmitter: AttributesEmitter;\n\n  constructor(\n    private readonly code: CodeMaker,\n    private readonly importExtension: string,\n  ) {\n    this.attributesEmitter = new AttributesEmitter(this.code);\n  }\n\n  public emit(resource: ResourceModel) {\n    this.code.line();\n\n    if (resource.isProvider && resource.providerFunctionsModel) {\n      // Sibling-directory import: providers/<provider>/provider/index.ts\n      // (the emitted file) and providers/<provider>/provider-functions/\n      // index.ts are siblings under providers/<provider>/, so unlike the\n      // child-folder struct imports this one has to step up a level.\n      this.code.line(\n        `import { ${resource.providerFunctionsModel.className} } from '../provider-functions/index${this.importExtension}';`,\n      );\n    }\n\n    const comment = sanitizedComment(this.code);\n    comment.line(\n      `Represents a {@link ${resource.linkToDocs} ${resource.terraformResourceType}}`,\n    );\n    comment.end();\n    this.code.openBlock(\n      `export class ${resource.className} extends cdktn.${resource.parentClassName}`,\n    );\n\n    this.emitHeader(\"STATIC PROPERTIES\");\n    this.emitStaticProperties(resource);\n\n    if (!resource.isEphemeralResource) {\n      this.emitHeader(\"STATIC Methods\");\n      this.emitStaticMethods(resource);\n    }\n\n    this.emitHeader(\"INITIALIZER\");\n    this.emitInitializer(resource);\n\n    this.emitHeader(\"ATTRIBUTES\");\n    this.emitResourceAttributes(resource);\n\n    if (resource.isProvider && resource.providerFunctionsModel) {\n      this.emitHeader(\"PROVIDER-DEFINED FUNCTIONS\");\n      this.emitFunctionsGetter(resource.providerFunctionsModel);\n    }\n\n    // synthesis\n    this.emitHeader(\"SYNTHESIS\");\n    this.emitResourceSynthesis(resource);\n    this.emitHclResourceSynthesis(resource);\n\n    this.code.closeBlock(); // construct\n  }\n\n  // Emits a memoized `functions` getter on a provider class that declares\n  // provider-defined functions. The local name to invoke functions under is\n  // derived from `this.terraformResourceType`, not baked in as the schema\n  // name constant: terraform-provider.ts keys both `required_providers` and\n  // the `provider` block directly off `terraformResourceType`, so whatever\n  // this instance's `terraformResourceType` is IS its correct\n  // required_providers local name (it already accounts for a `name`\n  // override in the cdktf.json provider constraint, see\n  // ConstructsMakerProviderTarget/TerraformProviderConstraint) - the\n  // instance always knows its own correct local name, so there is no need\n  // for a providerLocalName override parameter here.\n  private emitFunctionsGetter(\n    model: NonNullable<ResourceModel[\"providerFunctionsModel\"]>,\n  ) {\n    this.code.line(`private _functions?: ${model.className};`);\n    this.code.line();\n\n    const comment = sanitizedComment(this.code);\n    comment.line(\n      `Provider-defined functions of the ${model.providerName} provider.`,\n    );\n    comment.end();\n    this.code.openBlock(`public get functions(): ${model.className}`);\n    this.code.openBlock(`if (!this._functions)`);\n    this.code.line(\n      `this._functions = new ${model.className}(this.terraformResourceType);`,\n    );\n    this.code.closeBlock();\n    this.code.line(`return this._functions;`);\n    this.code.closeBlock();\n  }\n\n  private emitHeader(title: string) {\n    this.code.line();\n    this.code.line(\"// \" + \"=\".repeat(title.length));\n    this.code.line(`// ${title}`);\n    this.code.line(\"// \" + \"=\".repeat(title.length));\n  }\n\n  private emitStaticProperties(resource: ResourceModel) {\n    this.code.line(\n      `public static readonly tfResourceType = \"${resource.terraformResourceType}\";`,\n    );\n  }\n\n  private emitStaticMethods(resource: ResourceModel) {\n    const comment = sanitizedComment(this.code);\n    comment.line(\n      `Generates CDKTN code for importing a ${resource.className} resource upon running \"cdktn plan <stack-name>\"`,\n    );\n    comment.line(`@param scope The scope in which to define this construct`);\n    comment.line(\n      `@param importToId The construct id used in the generated config for the ${resource.className} to import`,\n    );\n    comment.line(\n      `@param importFromId The id of the existing ${resource.className} that should be imported. Refer to the {@link ${resource.linkToDocs}#import import section} in the documentation of this resource for the id to use`,\n    );\n    comment.line(\n      `@param provider? Optional instance of the provider where the ${resource.className} to import is found`,\n    );\n    comment.end();\n    this.code.line(\n      `public static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktn.TerraformProvider) {\n        return new cdktn.ImportableResource(scope, importToId, { terraformResourceType: \"${resource.terraformResourceType}\", importId: importFromId, provider });\n      }`,\n    );\n  }\n\n  private emitHclResourceSynthesis(resource: ResourceModel) {\n    this.code.line();\n    this.code.openBlock(\n      `protected synthesizeHclAttributes(): { [name: string]: any }`,\n    );\n    this.code.open(`const attrs = {`);\n\n    const registerWriteOnlyUsage = this.supportsWriteOnlyRegistration(resource);\n    for (const att of resource.synthesizableAttributes) {\n      this.attributesEmitter.emitToHclTerraform(\n        att,\n        false,\n        registerWriteOnlyUsage,\n      );\n    }\n\n    this.code.close(`};`);\n\n    if (resource.synthesizableAttributes.length > 0) {\n      this.code.line();\n      this.code.line(`// remove undefined attributes`);\n      this.code.line(\n        `return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined ))`,\n      );\n    } else {\n      this.code.line(`return attrs;`);\n    }\n\n    this.code.closeBlock();\n  }\n\n  private emitResourceSynthesis(resource: ResourceModel) {\n    this.code.line();\n    this.code.openBlock(\n      `protected synthesizeAttributes(): { [name: string]: any }`,\n    );\n    this.code.open(`return {`);\n\n    const registerWriteOnlyUsage = this.supportsWriteOnlyRegistration(resource);\n    for (const att of resource.synthesizableAttributes) {\n      this.attributesEmitter.emitToTerraform(\n        att,\n        false,\n        registerWriteOnlyUsage,\n      );\n    }\n\n    this.code.close(`};`);\n    this.code.closeBlock();\n  }\n\n  // `markWriteOnlyAttribute` (called from generated `synthesizeAttributes()`/\n  // `synthesizeHclAttributes()` for write-only attributes, see\n  // AttributesEmitter#emitToTerraform/#emitToHclTerraform) lives on\n  // TerraformResource - so only managed resources can register write-only\n  // usage; data sources, providers, and ephemeral resources only get the\n  // deprecated getter.\n  //\n  // write-only is fundamentally a state concept - the value is passed to\n  // the provider but never persisted to state - so gating this on\n  // TerraformResource is a semantic choice, not a capability one: ephemeral\n  // resources have no state at all, and, consistent with that, no provider\n  // schema in the RFC-04 sweep (including vault's 16 ephemeral resources)\n  // marks an ephemeral attribute write_only. So ephemeral classes\n  // deliberately land in the same \"getter only\" bucket as data sources and\n  // providers.\n  private supportsWriteOnlyRegistration(resource: ResourceModel): boolean {\n    return resource.parentClassName === \"TerraformResource\";\n  }\n\n  private emitResourceAttributes(resource: ResourceModel) {\n    for (const att of resource.attributes) {\n      this.attributesEmitter.emit(\n        att,\n        this.attributesEmitter.needsResetEscape(att, resource.attributes),\n        this.attributesEmitter.needsInputEscape(att, resource.attributes),\n      );\n    }\n  }\n\n  private emitInitializer(resource: ResourceModel) {\n    this.code.line();\n    const comment = sanitizedComment(this.code);\n    comment.line(\n      `Create a new {@link ${resource.linkToDocs} ${\n        resource.terraformResourceType\n      }} ${\n        resource.isDataSource\n          ? \"Data Source\"\n          : resource.isEphemeralResource\n            ? \"Ephemeral Resource\"\n            : \"Resource\"\n      }`,\n    );\n    comment.line(``);\n    comment.line(`@param scope The scope in which to define this construct`);\n    comment.line(\n      `@param id The scoped construct ID. Must be unique amongst siblings in the same scope`,\n    );\n    comment.line(`@param options ${resource.configStruct.attributeType}`);\n    comment.end();\n    this.code.openBlock(\n      `public constructor(scope: Construct, id: string, config: ${resource.configStruct.attributeType})`,\n    );\n\n    if (resource.isProvider) {\n      this.emitProviderSuper(resource);\n    } else if (resource.isEphemeralResource) {\n      this.emitEphemeralResourceSuper(resource);\n    } else {\n      this.emitResourceSuper(resource);\n    }\n\n    // initialize config properties\n    for (const att of resource.configStruct.assignableAttributes) {\n      if (att.setterType._type === \"stored_class\") {\n        this.code.line(\n          `this.${att.storageName}.internalValue = config.${att.name};`,\n        );\n      } else {\n        this.code.line(`this.${att.storageName} = config.${att.name};`);\n      }\n    }\n\n    this.code.closeBlock();\n  }\n\n  private emitResourceSuper(resource: ResourceModel) {\n    this.code.open(`super(scope, id, {`);\n    this.code.line(\n      `terraformResourceType: '${resource.terraformResourceType}',`,\n    );\n    this.emitTerraformGeneratorMetadata(resource);\n    this.code.line(`provider: config.provider,`);\n    this.code.line(`dependsOn: config.dependsOn,`);\n    this.code.line(`count: config.count,`);\n    this.code.line(`lifecycle: config.lifecycle,`);\n    this.code.line(`provisioners: config.provisioners,`);\n    this.code.line(`connection: config.connection,`);\n    this.code.line(`forEach: config.forEach`);\n    this.code.close(`});`);\n  }\n\n  private emitEphemeralResourceSuper(resource: ResourceModel) {\n    this.code.open(`super(scope, id, {`);\n    this.code.line(\n      `terraformResourceType: '${resource.terraformResourceType}',`,\n    );\n    this.emitTerraformGeneratorMetadata(resource);\n    this.code.line(`provider: config.provider,`);\n    this.code.line(`dependsOn: config.dependsOn,`);\n    this.code.line(`count: config.count,`);\n    this.code.line(`lifecycle: config.lifecycle,`);\n    this.code.line(`forEach: config.forEach`);\n    this.code.close(`});`);\n  }\n\n  private emitProviderSuper(resource: ResourceModel) {\n    this.code.open(`super(scope, id, {`);\n    this.code.line(\n      `terraformResourceType: '${resource.terraformResourceType}',`,\n    );\n    this.emitTerraformGeneratorMetadata(resource);\n    this.code.line(\n      `terraformProviderSource: '${resource.terraformProviderSource}'`,\n    );\n    this.code.close(`});`);\n  }\n\n  private emitTerraformGeneratorMetadata(resource: ResourceModel) {\n    this.code.open(`terraformGeneratorMetadata: {`);\n    this.code.line(\n      `providerName: '${resource.provider}'${\n        resource.providerVersion || resource.providerVersionConstraint\n          ? \",\"\n          : \"\"\n      }`,\n    );\n\n    if (resource.providerVersion) {\n      this.code.line(\n        `providerVersion: '${resource.providerVersion}'${\n          resource.providerVersionConstraint ? \",\" : \"\"\n        }`,\n      );\n    }\n\n    if (resource.providerVersionConstraint) {\n      this.code.line(\n        `providerVersionConstraint: '${resource.providerVersionConstraint}'`,\n      );\n    }\n\n    this.code.close(`},`);\n  }\n}\n"]}

package/build/get/generator/models/attribute-model.d.ts

@@ -34,6 +34,7 @@ export interface AttributeModelOptions {
     provider: boolean;
     required: boolean;
     forcePlainGetterType?: boolean;
+    isWriteOnly?: boolean;
 }
 export declare function escapeAttributeName(name: string): string;
 export declare class AttributeModel {
@@ -49,6 +50,7 @@ export declare class AttributeModel {
     required: boolean;
     forcePlainGetterType?: boolean;
     private loggedStoredClassUnavailable;
+    isWriteOnly: boolean;
     constructor(options: AttributeModelOptions);
     get typeDefinition(): string;
     get isAssignable(): boolean;

package/build/get/generator/models/attribute-model.js

@@ -49,6 +49,7 @@ class AttributeModel {
         this.provider = options.provider;
         this.required = options.required;
         this.forcePlainGetterType = options.forcePlainGetterType;
+        this.isWriteOnly = !!options.isWriteOnly;
     }
     get typeDefinition() {
         const optional = this.optional ? "?" : "";
@@ -202,4 +203,4 @@ class AttributeModel {
     }
 }
 exports.AttributeModel = AttributeModel;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attribute-model.js","sourceRoot":"","sources":["../../../../src/get/generator/models/attribute-model.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { logger } from \"@cdktn/commons\";\nimport {\n  AttributeTypeModel,\n  CollectionAttributeTypeModel,\n} from \"./attribute-type-model\";\n\nexport type GetterType =\n  | { _type: \"plain\" }\n  | {\n      _type: \"args\";\n      args: string;\n      returnType?: string;\n      returnStatement: string;\n    }\n  | {\n      _type: \"stored_class\";\n    };\n\nexport type SetterType =\n  | { _type: \"none\" }\n  | { _type: \"set\"; type: string }\n  | { _type: \"put\"; type: string }\n  | { _type: \"stored_class\"; type: string };\n\nexport interface AttributeModelOptions {\n  storageName: string; // private property\n  name: string;\n  type: AttributeTypeModel;\n  optional: boolean;\n  computed: boolean;\n  terraformName: string;\n  terraformFullName: string;\n  description?: string;\n  getAttCall?: string;\n  provider: boolean;\n  required: boolean;\n  forcePlainGetterType?: boolean; // used for skipping attribute type attributes that use the SkippedAttributeTypeModel which returns an interpolation and has no stored type\n}\n\nexport function escapeAttributeName(name: string) {\n  // `self` and `build` doesn't work in as property name in Python\n  if (name === \"self\" || name === \"build\") return `${name}Attribute`;\n  // jsii can't handle `getFoo` properties, since it's incompatible with Java\n  if (name.match(/^get[A-Za-z]+/)) return name.replace(\"get\", \"fetch\");\n  // `equals` is a prohibited name in jsii\n  if (name === \"equals\") return \"equalTo\";\n  // `node` is already used by the Constructs base class\n  if (name === \"node\") return \"nodeAttribute\";\n  // `System` shadows built-in types in CSharp (see #1420)\n  if (name === \"system\") return \"systemAttribute\";\n  // `tfResourceType` is already used by resources to distinguish between different resource types\n  if (name === \"tfResourceType\") return `${name}Attribute`;\n  // `importFrom` has potential for common name collision with providers\n  if (name === \"importFrom\") return `${name}Attribute`;\n  // `move` could have common name collision with providers\n  if (name === \"moveTo\") return `${name}Attribute`;\n  // `software` attribute can be confused with the JSII Java runtime package (see #3115)\n  if (name === \"software\") return `${name}Attribute`;\n  return name;\n}\n\nexport class AttributeModel {\n  public storageName: string; // private property\n  private _name: string;\n  public type: AttributeTypeModel;\n  public optional: boolean;\n  public computed: boolean;\n  public terraformName: string;\n  public terraformFullName: string;\n  private _description?: string;\n  public provider: boolean;\n  public required: boolean;\n  public forcePlainGetterType?: boolean;\n  private loggedStoredClassUnavailable = false;\n\n  constructor(options: AttributeModelOptions) {\n    this.storageName = options.storageName;\n    this._name = options.name;\n    this.type = options.type;\n    this.optional = options.optional;\n    this.computed = options.computed;\n    this.terraformName = options.terraformName;\n    this.terraformFullName = options.terraformFullName;\n    this._description = options.description;\n    this.provider = options.provider;\n    this.required = options.required;\n    this.forcePlainGetterType = options.forcePlainGetterType;\n  }\n\n  public get typeDefinition() {\n    const optional = this.optional ? \"?\" : \"\";\n    return `${this.name}${optional}: ${this.type.inputTypeDefinition}`;\n  }\n\n  public get isAssignable() {\n    return this.required || this.optional;\n  }\n\n  public get isOptional(): boolean {\n    return this.optional;\n  }\n\n  public get isRequired(): boolean {\n    return this.required;\n  }\n\n  public get isProvider(): boolean {\n    return this.provider;\n  }\n\n  public get getterType(): GetterType {\n    let getterType: GetterType = { _type: \"plain\" };\n\n    if (this.forcePlainGetterType) {\n      return getterType;\n    }\n\n    if (this.isProvider) {\n      return getterType;\n    }\n\n    if (this.type.hasReferenceClass) {\n      getterType = {\n        _type: \"stored_class\",\n      };\n    } else if (\n      this.computed &&\n      !this.isAssignable &&\n      (!this.type.isTokenizable || this.type.typeModelType === \"map\")\n    ) {\n      if (this.type.isStoredClassUnavailable) {\n        // Defensive fallback: neither the composed stored class name (e.g.\n        // \"StringListMapMap\") nor a collapsed nearest-Any wrapper (e.g. \"AnyMapMap\")\n        // exists in the core cdktn package for this type. This should be rare - see\n        // resolveStoredClassName in supported-stored-classes.ts - so log it loudly to\n        // make regressions in the collapse logic visible.\n        if (!this.loggedStoredClassUnavailable) {\n          this.loggedStoredClassUnavailable = true;\n          logger.debug(\n            `No stored class (not even a collapsed nearest-Any wrapper) is available for computed attribute \"${this.terraformFullName}\" (composed storedClassType: \"${this.type.storedClassType}\"). Falling back to a plain, untyped getter.`,\n          );\n        }\n      } else {\n        getterType = {\n          _type: \"stored_class\",\n        };\n      }\n    }\n\n    return getterType;\n  }\n\n  // Reports whether this attribute's getter sits at a \"stored class boundary\" that is\n  // worth documenting: \"collapsed\" when a deeper, unsupported nesting was collapsed into\n  // the nearest typed \"Any\"-wrapper (e.g. \"AnyMapMap\"), or \"fallback\" when no stored class\n  // at all is available and a plain, untyped getter is emitted instead. Mirrors the same\n  // condition tree as getterType above, so it only ever reports a boundary for attributes\n  // that actually went through that computed-collection branch - plain getters for\n  // ordinary tokenizable types (e.g. list(string)) are never flagged.\n  public get storedClassBoundaryKind(): \"collapsed\" | \"fallback\" | undefined {\n    if (this.forcePlainGetterType || this.isProvider) {\n      return undefined;\n    }\n\n    if (this.type.hasReferenceClass) {\n      return undefined;\n    }\n\n    if (\n      this.computed &&\n      !this.isAssignable &&\n      (!this.type.isTokenizable || this.type.typeModelType === \"map\")\n    ) {\n      if (this.type.isStoredClassUnavailable) {\n        return \"fallback\";\n      }\n\n      const resolvedStoredClass = (this.type as CollectionAttributeTypeModel)\n        .resolvedStoredClass;\n      if (resolvedStoredClass?.collapsed) {\n        return \"collapsed\";\n      }\n    }\n\n    return undefined;\n  }\n\n  public get isStored(): boolean {\n    return this.isAssignable;\n  }\n\n  public get setterType(): SetterType {\n    if (!this.isStored) {\n      return { _type: \"none\" };\n    }\n\n    if (this.getterType._type === \"stored_class\") {\n      return {\n        _type: \"stored_class\",\n        type: this.type.inputTypeDefinition,\n      };\n    }\n\n    return {\n      _type: \"set\",\n      type: `${this.type.inputTypeDefinition}${\n        this.isProvider ? \" | undefined\" : \"\"\n      }`,\n    };\n  }\n\n  public get name(): string {\n    return AttributeModel.escapeName(this._name);\n  }\n\n  public static escapeName(name: string): string {\n    return escapeAttributeName(name);\n  }\n\n  public get description(): string | undefined {\n    return this._description?.replace(/'''/gi, \"```\");\n  }\n\n  public getReferencedTypes(isConfigStruct: boolean): string[] | undefined {\n    const attTypeStruct = this.type.struct;\n    if (!attTypeStruct) {\n      return undefined;\n    }\n\n    const types: string[] = [];\n\n    if (this.isAssignable) {\n      types.push(attTypeStruct.name);\n      types.push(attTypeStruct.mapperName);\n      types.push(attTypeStruct.hclMapperName);\n    }\n\n    if (\n      !attTypeStruct.isSingleItem &&\n      (attTypeStruct.nestingMode === \"list\" ||\n        attTypeStruct.nestingMode === \"set\")\n    ) {\n      types.push(attTypeStruct.listName);\n    } else if (attTypeStruct.nestingMode === \"map\") {\n      types.push(attTypeStruct.mapName);\n    } else if (attTypeStruct.nestingMode === \"maplist\") {\n      types.push(attTypeStruct.mapListName);\n    } else if (attTypeStruct.nestingMode === \"mapset\") {\n      types.push(attTypeStruct.mapListName);\n    } else if (attTypeStruct.nestingMode === \"listmap\") {\n      types.push(attTypeStruct.listMapName);\n    } else if (attTypeStruct.nestingMode === \"setmap\") {\n      types.push(attTypeStruct.listMapName);\n    } else if (\n      attTypeStruct.nestingMode === \"listlist\" ||\n      attTypeStruct.nestingMode === \"listset\" ||\n      attTypeStruct.nestingMode === \"setlist\" ||\n      attTypeStruct.nestingMode == \"setset\"\n    ) {\n      types.push(attTypeStruct.listListName);\n    } else if (!isConfigStruct) {\n      types.push(attTypeStruct.outputReferenceName);\n    }\n    // other types of nested collections aren't supported\n\n    return types;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attribute-model.js","sourceRoot":"","sources":["../../../../src/get/generator/models/attribute-model.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { logger } from \"@cdktn/commons\";\nimport {\n  AttributeTypeModel,\n  CollectionAttributeTypeModel,\n} from \"./attribute-type-model\";\n\nexport type GetterType =\n  | { _type: \"plain\" }\n  | {\n      _type: \"args\";\n      args: string;\n      returnType?: string;\n      returnStatement: string;\n    }\n  | {\n      _type: \"stored_class\";\n    };\n\nexport type SetterType =\n  | { _type: \"none\" }\n  | { _type: \"set\"; type: string }\n  | { _type: \"put\"; type: string }\n  | { _type: \"stored_class\"; type: string };\n\nexport interface AttributeModelOptions {\n  storageName: string; // private property\n  name: string;\n  type: AttributeTypeModel;\n  optional: boolean;\n  computed: boolean;\n  terraformName: string;\n  terraformFullName: string;\n  description?: string;\n  getAttCall?: string;\n  provider: boolean;\n  required: boolean;\n  forcePlainGetterType?: boolean; // used for skipping attribute type attributes that use the SkippedAttributeTypeModel which returns an interpolation and has no stored type\n  isWriteOnly?: boolean; // provider protocol write-only attribute: providers never persist/return its value, see RFC-04\n}\n\nexport function escapeAttributeName(name: string) {\n  // `self` and `build` doesn't work in as property name in Python\n  if (name === \"self\" || name === \"build\") return `${name}Attribute`;\n  // jsii can't handle `getFoo` properties, since it's incompatible with Java\n  if (name.match(/^get[A-Za-z]+/)) return name.replace(\"get\", \"fetch\");\n  // `equals` is a prohibited name in jsii\n  if (name === \"equals\") return \"equalTo\";\n  // `node` is already used by the Constructs base class\n  if (name === \"node\") return \"nodeAttribute\";\n  // `System` shadows built-in types in CSharp (see #1420)\n  if (name === \"system\") return \"systemAttribute\";\n  // `tfResourceType` is already used by resources to distinguish between different resource types\n  if (name === \"tfResourceType\") return `${name}Attribute`;\n  // `importFrom` has potential for common name collision with providers\n  if (name === \"importFrom\") return `${name}Attribute`;\n  // `move` could have common name collision with providers\n  if (name === \"moveTo\") return `${name}Attribute`;\n  // `software` attribute can be confused with the JSII Java runtime package (see #3115)\n  if (name === \"software\") return `${name}Attribute`;\n  return name;\n}\n\nexport class AttributeModel {\n  public storageName: string; // private property\n  private _name: string;\n  public type: AttributeTypeModel;\n  public optional: boolean;\n  public computed: boolean;\n  public terraformName: string;\n  public terraformFullName: string;\n  private _description?: string;\n  public provider: boolean;\n  public required: boolean;\n  public forcePlainGetterType?: boolean;\n  private loggedStoredClassUnavailable = false;\n  public isWriteOnly: boolean;\n\n  constructor(options: AttributeModelOptions) {\n    this.storageName = options.storageName;\n    this._name = options.name;\n    this.type = options.type;\n    this.optional = options.optional;\n    this.computed = options.computed;\n    this.terraformName = options.terraformName;\n    this.terraformFullName = options.terraformFullName;\n    this._description = options.description;\n    this.provider = options.provider;\n    this.required = options.required;\n    this.forcePlainGetterType = options.forcePlainGetterType;\n    this.isWriteOnly = !!options.isWriteOnly;\n  }\n\n  public get typeDefinition() {\n    const optional = this.optional ? \"?\" : \"\";\n    return `${this.name}${optional}: ${this.type.inputTypeDefinition}`;\n  }\n\n  public get isAssignable() {\n    return this.required || this.optional;\n  }\n\n  public get isOptional(): boolean {\n    return this.optional;\n  }\n\n  public get isRequired(): boolean {\n    return this.required;\n  }\n\n  public get isProvider(): boolean {\n    return this.provider;\n  }\n\n  public get getterType(): GetterType {\n    let getterType: GetterType = { _type: \"plain\" };\n\n    if (this.forcePlainGetterType) {\n      return getterType;\n    }\n\n    if (this.isProvider) {\n      return getterType;\n    }\n\n    if (this.type.hasReferenceClass) {\n      getterType = {\n        _type: \"stored_class\",\n      };\n    } else if (\n      this.computed &&\n      !this.isAssignable &&\n      (!this.type.isTokenizable || this.type.typeModelType === \"map\")\n    ) {\n      if (this.type.isStoredClassUnavailable) {\n        // Defensive fallback: neither the composed stored class name (e.g.\n        // \"StringListMapMap\") nor a collapsed nearest-Any wrapper (e.g. \"AnyMapMap\")\n        // exists in the core cdktn package for this type. This should be rare - see\n        // resolveStoredClassName in supported-stored-classes.ts - so log it loudly to\n        // make regressions in the collapse logic visible.\n        if (!this.loggedStoredClassUnavailable) {\n          this.loggedStoredClassUnavailable = true;\n          logger.debug(\n            `No stored class (not even a collapsed nearest-Any wrapper) is available for computed attribute \"${this.terraformFullName}\" (composed storedClassType: \"${this.type.storedClassType}\"). Falling back to a plain, untyped getter.`,\n          );\n        }\n      } else {\n        getterType = {\n          _type: \"stored_class\",\n        };\n      }\n    }\n\n    return getterType;\n  }\n\n  // Reports whether this attribute's getter sits at a \"stored class boundary\" that is\n  // worth documenting: \"collapsed\" when a deeper, unsupported nesting was collapsed into\n  // the nearest typed \"Any\"-wrapper (e.g. \"AnyMapMap\"), or \"fallback\" when no stored class\n  // at all is available and a plain, untyped getter is emitted instead. Mirrors the same\n  // condition tree as getterType above, so it only ever reports a boundary for attributes\n  // that actually went through that computed-collection branch - plain getters for\n  // ordinary tokenizable types (e.g. list(string)) are never flagged.\n  public get storedClassBoundaryKind(): \"collapsed\" | \"fallback\" | undefined {\n    if (this.forcePlainGetterType || this.isProvider) {\n      return undefined;\n    }\n\n    if (this.type.hasReferenceClass) {\n      return undefined;\n    }\n\n    if (\n      this.computed &&\n      !this.isAssignable &&\n      (!this.type.isTokenizable || this.type.typeModelType === \"map\")\n    ) {\n      if (this.type.isStoredClassUnavailable) {\n        return \"fallback\";\n      }\n\n      const resolvedStoredClass = (this.type as CollectionAttributeTypeModel)\n        .resolvedStoredClass;\n      if (resolvedStoredClass?.collapsed) {\n        return \"collapsed\";\n      }\n    }\n\n    return undefined;\n  }\n\n  public get isStored(): boolean {\n    return this.isAssignable;\n  }\n\n  public get setterType(): SetterType {\n    if (!this.isStored) {\n      return { _type: \"none\" };\n    }\n\n    if (this.getterType._type === \"stored_class\") {\n      return {\n        _type: \"stored_class\",\n        type: this.type.inputTypeDefinition,\n      };\n    }\n\n    return {\n      _type: \"set\",\n      type: `${this.type.inputTypeDefinition}${\n        this.isProvider ? \" | undefined\" : \"\"\n      }`,\n    };\n  }\n\n  public get name(): string {\n    return AttributeModel.escapeName(this._name);\n  }\n\n  public static escapeName(name: string): string {\n    return escapeAttributeName(name);\n  }\n\n  public get description(): string | undefined {\n    return this._description?.replace(/'''/gi, \"```\");\n  }\n\n  public getReferencedTypes(isConfigStruct: boolean): string[] | undefined {\n    const attTypeStruct = this.type.struct;\n    if (!attTypeStruct) {\n      return undefined;\n    }\n\n    const types: string[] = [];\n\n    if (this.isAssignable) {\n      types.push(attTypeStruct.name);\n      types.push(attTypeStruct.mapperName);\n      types.push(attTypeStruct.hclMapperName);\n    }\n\n    if (\n      !attTypeStruct.isSingleItem &&\n      (attTypeStruct.nestingMode === \"list\" ||\n        attTypeStruct.nestingMode === \"set\")\n    ) {\n      types.push(attTypeStruct.listName);\n    } else if (attTypeStruct.nestingMode === \"map\") {\n      types.push(attTypeStruct.mapName);\n    } else if (attTypeStruct.nestingMode === \"maplist\") {\n      types.push(attTypeStruct.mapListName);\n    } else if (attTypeStruct.nestingMode === \"mapset\") {\n      types.push(attTypeStruct.mapListName);\n    } else if (attTypeStruct.nestingMode === \"listmap\") {\n      types.push(attTypeStruct.listMapName);\n    } else if (attTypeStruct.nestingMode === \"setmap\") {\n      types.push(attTypeStruct.listMapName);\n    } else if (\n      attTypeStruct.nestingMode === \"listlist\" ||\n      attTypeStruct.nestingMode === \"listset\" ||\n      attTypeStruct.nestingMode === \"setlist\" ||\n      attTypeStruct.nestingMode == \"setset\"\n    ) {\n      types.push(attTypeStruct.listListName);\n    } else if (!isConfigStruct) {\n      types.push(attTypeStruct.outputReferenceName);\n    }\n    // other types of nested collections aren't supported\n\n    return types;\n  }\n}\n"]}

package/build/get/generator/models/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./attribute-model";
 export * from "./attribute-type-model";
+export * from "./provider-function-model";
 export * from "./resource-model";
 export * from "./scope";
 export * from "./struct";

package/build/get/generator/models/index.js

@@ -18,7 +18,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // SPDX-License-Identifier: MPL-2.0
 __exportStar(require("./attribute-model"), exports);
 __exportStar(require("./attribute-type-model"), exports);
+__exportStar(require("./provider-function-model"), exports);
 __exportStar(require("./resource-model"), exports);
 __exportStar(require("./scope"), exports);
 __exportStar(require("./struct"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ2V0L2dlbmVyYXRvci9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtCQUErQjtBQUMvQixtQ0FBbUM7QUFDbkMsb0RBQWtDO0FBQ2xDLHlEQUF1QztBQUN2QyxtREFBaUM7QUFDakMsMENBQXdCO0FBQ3hCLDJDQUF5QiIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAoYykgSGFzaGlDb3JwLCBJbmNcbi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNUEwtMi4wXG5leHBvcnQgKiBmcm9tIFwiLi9hdHRyaWJ1dGUtbW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2F0dHJpYnV0ZS10eXBlLW1vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9yZXNvdXJjZS1tb2RlbFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2NvcGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3N0cnVjdFwiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ2V0L2dlbmVyYXRvci9tb2RlbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLCtCQUErQjtBQUMvQixtQ0FBbUM7QUFDbkMsb0RBQWtDO0FBQ2xDLHlEQUF1QztBQUN2Qyw0REFBMEM7QUFDMUMsbURBQWlDO0FBQ2pDLDBDQUF3QjtBQUN4QiwyQ0FBeUIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgKGMpIEhhc2hpQ29ycCwgSW5jXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTVBMLTIuMFxuZXhwb3J0ICogZnJvbSBcIi4vYXR0cmlidXRlLW1vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9hdHRyaWJ1dGUtdHlwZS1tb2RlbFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vcHJvdmlkZXItZnVuY3Rpb24tbW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Jlc291cmNlLW1vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zY29wZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vc3RydWN0XCI7XG4iXX0=