@cdktn/provider-generator 0.23.0-pre.36 → 0.23.0-pre.39

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

@@ -0,0 +1,500 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructEmitter = void 0;
+const models_1 = require("../models");
+const attributes_emitter_1 = require("./attributes-emitter");
+const util_1 = require("../../../util");
+const path = __importStar(require("path"));
+const resource_model_1 = require("../models/resource-model");
+const sanitized_comments_1 = require("../sanitized-comments");
+class StructEmitter {
+    constructor(code) {
+        this.code = code;
+        this.attributesEmitter = new attributes_emitter_1.AttributesEmitter(this.code);
+    }
+    emit(resource) {
+        if (resource.structsRequireSharding) {
+            this.emitNamespacedStructs(resource);
+        }
+        else {
+            this.emitStructs(resource);
+        }
+    }
+    // Due to https://github.com/hashicorp/terraform-plugin-sdk/commit/2387eb85e32c064b4a62718c9f5c80bf00dc7fb9 all
+    // resources from providers using the old SDK have the id field by default
+    // We have no way to distinguish them through the provider schema, so a word of warning for our users
+    warnAboutIdField(att) {
+        if (att.name === "id") {
+            this.code.line(`*`);
+            this.code.line(`* Please be aware that the id field is automatically added to all resources in Terraform providers using a Terraform provider SDK version below 2.`);
+            this.code.line(`* If you experience problems setting this value it might not be settable. Please take a look at the provider documentation to ensure it should be settable.`);
+        }
+    }
+    emitInterface(resource, struct, name = struct.name) {
+        if (resource.isProvider) {
+            this.code.openBlock(`export interface ${name}`);
+        }
+        else {
+            this.code.openBlock(`export interface ${name}${struct.extends}`);
+        }
+        for (const att of struct.assignableAttributes) {
+            const comment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+            if (att.description) {
+                comment.line(att.description);
+                comment.line(``);
+                comment.line(`Docs at Terraform Registry: {@link ${resource.linkToDocs}#${att.terraformName} ${resource.className}#${att.terraformName}}`);
+                this.warnAboutIdField(att);
+                comment.end();
+            }
+            else {
+                comment.line(`Docs at Terraform Registry: {@link ${resource.linkToDocs}#${att.terraformName} ${resource.className}#${att.terraformName}}`);
+                this.warnAboutIdField(att);
+                comment.end();
+            }
+            this.code.line(`readonly ${att.typeDefinition};`);
+        }
+        this.code.closeBlock();
+        if (!(struct instanceof models_1.ConfigStruct)) {
+            this.emitToTerraformFunction(struct);
+            this.emitToHclTerraformFunction(struct);
+        }
+    }
+    emitStructs(resource) {
+        resource.structs.forEach((struct) => {
+            if (struct instanceof models_1.ConfigStruct) {
+                this.emitInterface(resource, struct);
+            }
+            else {
+                // We use the interface here for the configuration / inputs of a resource / nested block
+                this.emitInterface(resource, struct);
+                // And we use the class for the attributes / outputs of a resource / nested block
+                if (!struct.isProvider) {
+                    this.emitClass(struct);
+                }
+            }
+        });
+    }
+    emitNamespacedStructs(resource) {
+        // iterate over all structs in batches of 400 to avoid too many exports (> 1200)
+        const structImports = {};
+        // drop configStruct from resource.structs to avoid double import
+        const structsWithoutConfigStruct = resource.structs.slice(1);
+        const structSplits = [[]];
+        const splitCounts = [0];
+        structsWithoutConfigStruct.forEach((struct) => {
+            if (splitCounts[splitCounts.length - 1] + struct.exportCount <=
+                resource_model_1.STRUCT_SHARDING_THRESHOLD) {
+                structSplits[structSplits.length - 1].push(struct);
+                splitCounts[splitCounts.length - 1] += struct.exportCount;
+            }
+            else {
+                structSplits.push([struct]);
+                splitCounts.push(struct.exportCount);
+            }
+        });
+        // fill the struct imports mapping before code generation so that imports can
+        // point to not yet generated struct files
+        for (let i = 0; i < structSplits.length; i++) {
+            const structFilename = `structs${i * resource_model_1.STRUCT_SHARDING_THRESHOLD}.ts`;
+            const structs = structSplits[i];
+            // associate current structs batch with the file it will be written to
+            // to find it in subsequent files for importing
+            structs.forEach((struct) => (structImports[struct.name] = structFilename));
+        }
+        const structPaths = [];
+        for (let i = 0; i < structSplits.length; i++) {
+            const structsToImport = {};
+            const structs = structSplits[i];
+            const structFilename = `structs${i * resource_model_1.STRUCT_SHARDING_THRESHOLD}.ts`;
+            structPaths.push(structFilename);
+            // find all structs that need to be imported in this file
+            structs.forEach((struct) => {
+                struct.attributes.forEach((att) => {
+                    var _a, _b;
+                    const structTypeName = (_a = att.type.struct) === null || _a === void 0 ? void 0 : _a.name;
+                    const fileToImport = structImports[structTypeName !== null && structTypeName !== void 0 ? structTypeName : ""];
+                    if (fileToImport && fileToImport !== structFilename) {
+                        const attTypeStruct = att.type.struct;
+                        if (!attTypeStruct)
+                            throw new Error(`${structTypeName} is not a struct`);
+                        (_b = structsToImport[fileToImport]) !== null && _b !== void 0 ? _b : (structsToImport[fileToImport] = []);
+                        const attReferences = att.getReferencedTypes(struct instanceof models_1.ConfigStruct);
+                        if (attReferences) {
+                            structsToImport[fileToImport].push(...attReferences);
+                        }
+                    }
+                });
+            });
+            const namespacedFilePath = path.join(resource.structsFolderPath, structFilename);
+            this.code.openFile(namespacedFilePath);
+            // the structs only makes use of cdktn not constructs
+            this.code.line(`import * as cdktn from 'cdktn';`);
+            Object.entries(structsToImport).forEach(([fileToImport, structs]) => {
+                this.code.line(`import { ${[...new Set(structs)].join(",\n")} } from './${path.basename(fileToImport, ".ts")}'`);
+            });
+            structs.forEach((struct) => {
+                if (struct instanceof models_1.ConfigStruct) {
+                    this.emitInterface(resource, struct);
+                }
+                else {
+                    // We use the interface here for the configuration / inputs of a resource / nested block
+                    this.emitInterface(resource, struct);
+                    // And we use the class for the attributes / outputs of a resource / nested block
+                    if (!struct.isProvider) {
+                        this.emitClass(struct);
+                    }
+                }
+            });
+            this.code.closeFile(namespacedFilePath);
+        }
+        // emit the index file that exports all the struct files we've just generated
+        const indexFilePath = path.join(resource.structsFolderPath, "index.ts");
+        this.code.openFile(indexFilePath);
+        structPaths.forEach((structPath) => {
+            this.code.line(`export * from './${path.basename(structPath, ".ts")}'`);
+        });
+        this.code.closeFile(indexFilePath);
+    }
+    emitClass(struct) {
+        this.code.openBlock(`export class ${struct.outputReferenceName} extends cdktn.ComplexObject`);
+        this.code.line("private isEmptyObject = false;");
+        if (!struct.isClass) {
+            this.code.line("private resolvableValue?: cdktn.IResolvable;");
+        }
+        this.code.line();
+        const comment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        comment.line(`@param terraformResource The parent resource`);
+        comment.line(`@param terraformAttribute The attribute on the parent resource this class is referencing`);
+        if (struct.isSingleItem) {
+            comment.end();
+            this.code.openBlock(`public constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string)`);
+            this.code.line(`super(terraformResource, terraformAttribute, false, 0);`);
+            this.code.closeBlock();
+        }
+        else if (struct.nestingMode === "single" ||
+            struct.nestingMode === "object") {
+            comment.end();
+            this.code.openBlock(`public constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string)`);
+            this.code.line(`super(terraformResource, terraformAttribute, false);`);
+            this.code.closeBlock();
+        }
+        else if (struct.nestingMode.startsWith("map")) {
+            this.code.line(`* @param complexObjectKey the key of this item in the map`);
+            comment.end();
+            this.code.openBlock(`public constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string, complexObjectKey: string)`);
+            this.code.line(`super(terraformResource, terraformAttribute, false, complexObjectKey);`);
+            this.code.closeBlock();
+        }
+        else {
+            comment.line(`@param complexObjectIndex the index of this item in the list`);
+            comment.line(`@param complexObjectIsFromSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)`);
+            comment.end();
+            this.code.openBlock(`public constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string, complexObjectIndex: number, complexObjectIsFromSet: boolean)`);
+            this.code.line(`super(terraformResource, terraformAttribute, complexObjectIsFromSet, complexObjectIndex);`);
+            this.code.closeBlock();
+        }
+        this.code.line();
+        this.emitInternalValueGetter(struct);
+        this.code.line();
+        this.emitInternalValueSetter(struct);
+        for (const att of struct.attributes) {
+            this.attributesEmitter.emit(att, this.attributesEmitter.needsResetEscape(att, struct.attributes), this.attributesEmitter.needsInputEscape(att, struct.attributes));
+        }
+        this.code.closeBlock();
+        if (!struct.isSingleItem &&
+            (struct.nestingMode === "list" || struct.nestingMode === "set")) {
+            this.emitComplexListClass(struct);
+        }
+        else if (struct.nestingMode === "map") {
+            this.emitComplexMapClass(struct);
+        }
+        else if (struct.nestingMode === "maplist") {
+            this.emitComplexMapListClasses(struct);
+        }
+        else if (struct.nestingMode === "mapset") {
+            this.emitComplexMapListClasses(struct);
+        }
+        else if (struct.nestingMode === "listmap") {
+            this.emitComplexListMapClasses(struct, false);
+        }
+        else if (struct.nestingMode === "setmap") {
+            this.emitComplexListMapClasses(struct, true);
+        }
+        else if (struct.nestingMode === "listlist" ||
+            struct.nestingMode === "listset" ||
+            struct.nestingMode === "setlist" ||
+            struct.nestingMode === "setset") {
+            this.emitComplexListListClasses(struct);
+        }
+        // other types of nested collections aren't supported
+    }
+    emitComplexListClass(struct) {
+        this.code.line();
+        this.code.openBlock(`export class ${struct.listName} extends cdktn.ComplexList`);
+        if (struct.assignable) {
+            this.code.line(`public internalValue? : ${struct.name}[] | cdktn.IResolvable`);
+        }
+        this.code.line();
+        const constructorComment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        constructorComment.line(`@param terraformResource The parent resource`);
+        constructorComment.line(`@param terraformAttribute The attribute on the parent resource this class is referencing`);
+        constructorComment.line(`@param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)`);
+        constructorComment.end();
+        this.code.openBlock(`constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string, wrapsSet: boolean)`);
+        this.code.line(`super(terraformResource, terraformAttribute, wrapsSet)`);
+        this.code.closeBlock();
+        this.code.line();
+        const getterComment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        getterComment.line(`@param index the index of the item to return`);
+        getterComment.end();
+        this.code.openBlock(`public get(index: number): ${struct.outputReferenceName}`);
+        this.code.line(`return new ${struct.outputReferenceName}(this.terraformResource, this.terraformAttribute, index, this.wrapsSet);`);
+        this.code.closeBlock();
+        this.code.closeBlock();
+    }
+    emitComplexMapClass(struct) {
+        this.code.line();
+        this.code.openBlock(`export class ${struct.mapName} extends cdktn.ComplexMap`);
+        if (struct.assignable) {
+            this.code.line(`public internalValue? : { [key: string]: ${struct.name} } | cdktn.IResolvable`);
+        }
+        this.code.line();
+        const constructorComment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        constructorComment.line(`@param terraformResource The parent resource`);
+        constructorComment.line(`@param terraformAttribute The attribute on the parent resource this class is referencing`);
+        constructorComment.end();
+        this.code.openBlock(`constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string)`);
+        this.code.line(`super(terraformResource, terraformAttribute)`);
+        this.code.closeBlock();
+        this.code.line();
+        const getterComment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        getterComment.line(`@param key the key of the item to return`);
+        getterComment.end();
+        this.code.openBlock(`public get(key: string): ${struct.outputReferenceName}`);
+        this.code.line(`return new ${struct.outputReferenceName}(this.terraformResource, this.terraformAttribute, key);`);
+        this.code.closeBlock();
+        this.code.closeBlock();
+    }
+    emitComplexMapListClasses(struct) {
+        this.emitComplexMapListClass(struct);
+        this.emitComplexMapClass(struct);
+    }
+    emitComplexMapListClass(struct) {
+        this.code.line();
+        this.code.openBlock(`export class ${struct.mapListName} extends cdktn.MapList`);
+        if (struct.assignable) {
+            this.code.line(`public internalValue? : ${struct.mapName}[] | cdktn.IResolvable`);
+        }
+        this.code.line();
+        const constructorComment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        constructorComment.line(`@param terraformResource The parent resource`);
+        constructorComment.line(`@param terraformAttribute The attribute on the parent resource this class is referencing`);
+        constructorComment.line(`@param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)`);
+        constructorComment.end();
+        this.code.openBlock(`constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string, wrapsSet: boolean)`);
+        this.code.line(`super(terraformResource, terraformAttribute, wrapsSet)`);
+        this.code.closeBlock();
+        this.code.line();
+        const getterComment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        getterComment.line(`@param index the index of the item to return`);
+        getterComment.end();
+        this.code.openBlock(`public get(index: number): ${struct.mapName}`);
+        this.code.line(`return new ${struct.mapName}(this, \`[\${index}]\`);`);
+        this.code.closeBlock();
+        this.code.closeBlock();
+    }
+    emitComplexListMapClasses(struct, isSet) {
+        this.emitComplexListMapClass(struct, isSet);
+        this.emitComplexListClass(struct);
+    }
+    emitComplexListMapClass(struct, isSet) {
+        this.code.line();
+        this.code.openBlock(`export class ${struct.listMapName} extends cdktn.ComplexMap`);
+        if (struct.assignable) {
+            this.code.line(`public internalValue? : { [key: string]: ${struct.name}[] } | cdktn.IResolvable`);
+        }
+        this.code.line();
+        const constructorComment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        constructorComment.line(`@param terraformResource The parent resource`);
+        constructorComment.line(`@param terraformAttribute The attribute on the parent resource this class is referencing`);
+        constructorComment.end();
+        this.code.openBlock(`constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string)`);
+        this.code.line(`super(terraformResource, terraformAttribute)`);
+        this.code.closeBlock();
+        this.code.line();
+        const getterComment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        getterComment.line(`@param key the key of the item to return`);
+        getterComment.end();
+        this.code.openBlock(`public get(key: string): ${struct.listName}`);
+        this.code.line(`return new ${struct.listName}(this, \`[\${key}]\`, ${isSet});`);
+        this.code.closeBlock();
+        this.code.closeBlock();
+    }
+    emitComplexListListClasses(struct) {
+        this.emitComplexListListClass(struct);
+        this.emitComplexListClass(struct);
+    }
+    emitComplexListListClass(struct) {
+        this.code.line();
+        this.code.openBlock(`export class ${struct.listListName} extends cdktn.MapList`);
+        if (struct.assignable) {
+            this.code.line(`public internalValue? : ${struct.name}[][] | cdktn.IResolvable`);
+        }
+        this.code.line();
+        const constructorComment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        constructorComment.line(`@param terraformResource The parent resource`);
+        constructorComment.line(`@param terraformAttribute The attribute on the parent resource this class is referencing`);
+        constructorComment.line(`@param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)`);
+        constructorComment.end();
+        this.code.openBlock(`constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string, wrapsSet: boolean)`);
+        this.code.line(`super(terraformResource, terraformAttribute, wrapsSet)`);
+        this.code.closeBlock();
+        this.code.line();
+        const getterComment = (0, sanitized_comments_1.sanitizedComment)(this.code);
+        getterComment.line(`@param index the index of the item to return`);
+        getterComment.end();
+        this.code.openBlock(`public get(index: number): ${struct.listName}`);
+        this.code.line(`return new ${struct.listName}(this, \`[\${index}]\`, ${struct.nestingMode === "setlist" || struct.nestingMode === "setset"});`);
+        this.code.closeBlock();
+        this.code.closeBlock();
+    }
+    emitInternalValueGetter(struct) {
+        this.code.openBlock(`public get internalValue(): ${struct.name}${!struct.isClass ? " | cdktn.IResolvable" : ""} | undefined`);
+        if (!struct.isClass) {
+            this.code.openBlock("if (this.resolvableValue)");
+            this.code.line("return this.resolvableValue;");
+            this.code.closeBlock();
+        }
+        this.code.line("let hasAnyValues = this.isEmptyObject;");
+        this.code.line("const internalValueResult: any = {};");
+        for (const att of struct.attributes) {
+            if (att.isStored) {
+                if (att.getterType._type === "stored_class") {
+                    this.code.openBlock(`if (this.${att.storageName}?.internalValue !== undefined)`);
+                }
+                else {
+                    this.code.openBlock(`if (this.${att.storageName} !== undefined)`);
+                }
+                this.code.line("hasAnyValues = true;");
+                if (att.getterType._type === "stored_class") {
+                    this.code.line(`internalValueResult.${att.name} = this.${att.storageName}?.internalValue;`);
+                }
+                else {
+                    this.code.line(`internalValueResult.${att.name} = this.${att.storageName};`);
+                }
+                this.code.closeBlock();
+            }
+        }
+        this.code.line("return hasAnyValues ? internalValueResult : undefined;");
+        this.code.closeBlock();
+    }
+    emitInternalValueSetter(struct) {
+        this.code.openBlock(`public set internalValue(value: ${struct.name}${!struct.isClass ? " | cdktn.IResolvable" : ""} | undefined)`);
+        this.code.openBlock("if (value === undefined)");
+        this.code.line("this.isEmptyObject = false;");
+        if (!struct.isClass) {
+            this.code.line("this.resolvableValue = undefined;");
+        }
+        for (const att of struct.attributes) {
+            if (att.isStored) {
+                if (att.setterType._type === "stored_class") {
+                    this.code.line(`this.${att.storageName}.internalValue = undefined;`);
+                }
+                else if (att.setterType._type !== "none") {
+                    this.code.line(`this.${att.storageName} = undefined;`);
+                }
+            }
+        }
+        this.code.closeBlock();
+        if (!struct.isClass) {
+            this.code.openBlock("else if (cdktn.Tokenization.isResolvable(value))");
+            this.code.line("this.isEmptyObject = false;");
+            this.code.line("this.resolvableValue = value;");
+            this.code.closeBlock();
+        }
+        this.code.openBlock("else");
+        this.code.line("this.isEmptyObject = Object.keys(value).length === 0;");
+        if (!struct.isClass) {
+            this.code.line("this.resolvableValue = undefined;");
+        }
+        for (const att of struct.attributes) {
+            if (att.isStored) {
+                if (att.setterType._type === "stored_class") {
+                    this.code.line(`this.${att.storageName}.internalValue = value.${att.name};`);
+                }
+                else if (att.setterType._type !== "none") {
+                    this.code.line(`this.${att.storageName} = value.${att.name};`);
+                }
+            }
+        }
+        this.code.closeBlock();
+        this.code.closeBlock();
+    }
+    emitToHclTerraformFunction(struct) {
+        this.code.line();
+        this.code.openBlock(`export function ${(0, util_1.downcaseFirst)(struct.name)}ToHclTerraform(struct?: ${struct.isSingleItem && !struct.isProvider
+            ? `${struct.name}OutputReference | `
+            : ""}${struct.name}${!struct.isClass ? " | cdktn.IResolvable" : ""}): any`);
+        this.code.line(`if (!cdktn.canInspect(struct) || cdktn.Tokenization.isResolvable(struct)) { return struct; }`);
+        this.code.openBlock(`if (cdktn.isComplexElement(struct))`);
+        this.code.line(`throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");`);
+        this.code.closeBlock();
+        this.code.open(`const attrs = {`);
+        for (const att of struct.assignableAttributes) {
+            this.attributesEmitter.emitToHclTerraform(att, true);
+        }
+        this.code.close(`};`);
+        if (struct.assignableAttributes.length > 0) {
+            this.code.line();
+            this.code.line(`// remove undefined attributes`);
+            this.code.line(`return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));`);
+        }
+        else {
+            this.code.line(`return attrs;`);
+        }
+        this.code.closeBlock();
+        this.code.line();
+    }
+    emitToTerraformFunction(struct) {
+        this.code.line();
+        this.code.openBlock(`export function ${(0, util_1.downcaseFirst)(struct.name)}ToTerraform(struct?: ${struct.isSingleItem && !struct.isProvider
+            ? `${struct.name}OutputReference | `
+            : ""}${struct.name}${!struct.isClass ? " | cdktn.IResolvable" : ""}): any`);
+        this.code.line(`if (!cdktn.canInspect(struct) || cdktn.Tokenization.isResolvable(struct)) { return struct; }`);
+        this.code.openBlock(`if (cdktn.isComplexElement(struct))`);
+        this.code.line(`throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");`);
+        this.code.closeBlock();
+        this.code.openBlock("return");
+        for (const att of struct.assignableAttributes) {
+            this.attributesEmitter.emitToTerraform(att, true);
+        }
+        this.code.closeBlock(";");
+        this.code.closeBlock();
+        this.code.line();
+    }
+}
+exports.StructEmitter = StructEmitter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"struct-emitter.js","sourceRoot":"","sources":["../../../../src/get/generator/emitter/struct-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, Struct, ConfigStruct } from \"../models\";\nimport { AttributesEmitter } from \"./attributes-emitter\";\nimport { downcaseFirst } from \"../../../util\";\nimport * as path from \"path\";\nimport { STRUCT_SHARDING_THRESHOLD } from \"../models/resource-model\";\nimport { AttributeModel } from \"../models/attribute-model\";\nimport { sanitizedComment } from \"../sanitized-comments\";\nexport class StructEmitter {\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    if (resource.structsRequireSharding) {\n      this.emitNamespacedStructs(resource);\n    } else {\n      this.emitStructs(resource);\n    }\n  }\n\n  // Due to https://github.com/hashicorp/terraform-plugin-sdk/commit/2387eb85e32c064b4a62718c9f5c80bf00dc7fb9 all\n  // resources from providers using the old SDK have the id field by default\n  // We have no way to distinguish them through the provider schema, so a word of warning for our users\n  private warnAboutIdField(att: AttributeModel) {\n    if (att.name === \"id\") {\n      this.code.line(`*`);\n      this.code.line(\n        `* Please be aware that the id field is automatically added to all resources in Terraform providers using a Terraform provider SDK version below 2.`,\n      );\n      this.code.line(\n        `* If you experience problems setting this value it might not be settable. Please take a look at the provider documentation to ensure it should be settable.`,\n      );\n    }\n  }\n\n  public emitInterface(\n    resource: ResourceModel,\n    struct: Struct,\n    name = struct.name,\n  ) {\n    if (resource.isProvider) {\n      this.code.openBlock(`export interface ${name}`);\n    } else {\n      this.code.openBlock(`export interface ${name}${struct.extends}`);\n    }\n\n    for (const att of struct.assignableAttributes) {\n      const comment = sanitizedComment(this.code);\n      if (att.description) {\n        comment.line(att.description);\n        comment.line(``);\n        comment.line(\n          `Docs at Terraform Registry: {@link ${resource.linkToDocs}#${att.terraformName} ${resource.className}#${att.terraformName}}`,\n        );\n        this.warnAboutIdField(att);\n        comment.end();\n      } else {\n        comment.line(\n          `Docs at Terraform Registry: {@link ${resource.linkToDocs}#${att.terraformName} ${resource.className}#${att.terraformName}}`,\n        );\n        this.warnAboutIdField(att);\n        comment.end();\n      }\n\n      this.code.line(`readonly ${att.typeDefinition};`);\n    }\n    this.code.closeBlock();\n\n    if (!(struct instanceof ConfigStruct)) {\n      this.emitToTerraformFunction(struct);\n      this.emitToHclTerraformFunction(struct);\n    }\n  }\n\n  private emitStructs(resource: ResourceModel) {\n    resource.structs.forEach((struct) => {\n      if (struct instanceof ConfigStruct) {\n        this.emitInterface(resource, struct);\n      } else {\n        // We use the interface here for the configuration / inputs of a resource / nested block\n        this.emitInterface(resource, struct);\n        // And we use the class for the attributes / outputs of a resource / nested block\n        if (!struct.isProvider) {\n          this.emitClass(struct);\n        }\n      }\n    });\n  }\n\n  private emitNamespacedStructs(resource: ResourceModel) {\n    // iterate over all structs in batches of 400 to avoid too many exports (> 1200)\n    const structImports: Record<string, string> = {};\n\n    // drop configStruct from resource.structs to avoid double import\n    const structsWithoutConfigStruct = resource.structs.slice(1);\n\n    const structSplits: Struct[][] = [[]];\n    const splitCounts: number[] = [0];\n    structsWithoutConfigStruct.forEach((struct) => {\n      if (\n        splitCounts[splitCounts.length - 1] + struct.exportCount <=\n        STRUCT_SHARDING_THRESHOLD\n      ) {\n        structSplits[structSplits.length - 1].push(struct);\n        splitCounts[splitCounts.length - 1] += struct.exportCount;\n      } else {\n        structSplits.push([struct]);\n        splitCounts.push(struct.exportCount);\n      }\n    });\n\n    // fill the struct imports mapping before code generation so that imports can\n    // point to not yet generated struct files\n    for (let i = 0; i < structSplits.length; i++) {\n      const structFilename = `structs${i * STRUCT_SHARDING_THRESHOLD}.ts`;\n      const structs = structSplits[i];\n\n      // associate current structs batch with the file it will be written to\n      // to find it in subsequent files for importing\n      structs.forEach(\n        (struct) => (structImports[struct.name] = structFilename),\n      );\n    }\n\n    const structPaths = [];\n    for (let i = 0; i < structSplits.length; i++) {\n      const structsToImport: Record<string, string[]> = {};\n      const structs = structSplits[i];\n      const structFilename = `structs${i * STRUCT_SHARDING_THRESHOLD}.ts`;\n      structPaths.push(structFilename);\n\n      // find all structs that need to be imported in this file\n      structs.forEach((struct) => {\n        struct.attributes.forEach((att) => {\n          const structTypeName = att.type.struct?.name;\n          const fileToImport = structImports[structTypeName ?? \"\"];\n\n          if (fileToImport && fileToImport !== structFilename) {\n            const attTypeStruct = att.type.struct;\n            if (!attTypeStruct)\n              throw new Error(`${structTypeName} is not a struct`);\n\n            structsToImport[fileToImport] ??\n              (structsToImport[fileToImport] = []);\n\n            const attReferences = att.getReferencedTypes(\n              struct instanceof ConfigStruct,\n            );\n            if (attReferences) {\n              structsToImport[fileToImport].push(...attReferences);\n            }\n          }\n        });\n      });\n\n      const namespacedFilePath = path.join(\n        resource.structsFolderPath,\n        structFilename,\n      );\n\n      this.code.openFile(namespacedFilePath);\n      // the structs only makes use of cdktn not constructs\n      this.code.line(`import * as cdktn from 'cdktn';`);\n      Object.entries(structsToImport).forEach(([fileToImport, structs]) => {\n        this.code.line(\n          `import { ${[...new Set(structs)].join(\n            \",\\n\",\n          )} } from './${path.basename(fileToImport, \".ts\")}'`,\n        );\n      });\n\n      structs.forEach((struct) => {\n        if (struct instanceof ConfigStruct) {\n          this.emitInterface(resource, struct);\n        } else {\n          // We use the interface here for the configuration / inputs of a resource / nested block\n          this.emitInterface(resource, struct);\n          // And we use the class for the attributes / outputs of a resource / nested block\n          if (!struct.isProvider) {\n            this.emitClass(struct);\n          }\n        }\n      });\n      this.code.closeFile(namespacedFilePath);\n    }\n\n    // emit the index file that exports all the struct files we've just generated\n    const indexFilePath = path.join(resource.structsFolderPath, \"index.ts\");\n\n    this.code.openFile(indexFilePath);\n    structPaths.forEach((structPath) => {\n      this.code.line(`export * from './${path.basename(structPath, \".ts\")}'`);\n    });\n    this.code.closeFile(indexFilePath);\n  }\n\n  private emitClass(struct: Struct) {\n    this.code.openBlock(\n      `export class ${struct.outputReferenceName} extends cdktn.ComplexObject`,\n    );\n\n    this.code.line(\"private isEmptyObject = false;\");\n    if (!struct.isClass) {\n      this.code.line(\"private resolvableValue?: cdktn.IResolvable;\");\n    }\n    this.code.line();\n\n    const comment = sanitizedComment(this.code);\n    comment.line(`@param terraformResource The parent resource`);\n    comment.line(\n      `@param terraformAttribute The attribute on the parent resource this class is referencing`,\n    );\n    if (struct.isSingleItem) {\n      comment.end();\n      this.code.openBlock(\n        `public constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string)`,\n      );\n      this.code.line(`super(terraformResource, terraformAttribute, false, 0);`);\n      this.code.closeBlock();\n    } else if (\n      struct.nestingMode === \"single\" ||\n      struct.nestingMode === \"object\"\n    ) {\n      comment.end();\n      this.code.openBlock(\n        `public constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string)`,\n      );\n      this.code.line(`super(terraformResource, terraformAttribute, false);`);\n      this.code.closeBlock();\n    } else if (struct.nestingMode.startsWith(\"map\")) {\n      this.code.line(\n        `* @param complexObjectKey the key of this item in the map`,\n      );\n      comment.end();\n      this.code.openBlock(\n        `public constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string, complexObjectKey: string)`,\n      );\n      this.code.line(\n        `super(terraformResource, terraformAttribute, false, complexObjectKey);`,\n      );\n      this.code.closeBlock();\n    } else {\n      comment.line(\n        `@param complexObjectIndex the index of this item in the list`,\n      );\n      comment.line(\n        `@param complexObjectIsFromSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)`,\n      );\n      comment.end();\n      this.code.openBlock(\n        `public constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string, complexObjectIndex: number, complexObjectIsFromSet: boolean)`,\n      );\n      this.code.line(\n        `super(terraformResource, terraformAttribute, complexObjectIsFromSet, complexObjectIndex);`,\n      );\n      this.code.closeBlock();\n    }\n\n    this.code.line();\n    this.emitInternalValueGetter(struct);\n    this.code.line();\n    this.emitInternalValueSetter(struct);\n\n    for (const att of struct.attributes) {\n      this.attributesEmitter.emit(\n        att,\n        this.attributesEmitter.needsResetEscape(att, struct.attributes),\n        this.attributesEmitter.needsInputEscape(att, struct.attributes),\n      );\n    }\n\n    this.code.closeBlock();\n\n    if (\n      !struct.isSingleItem &&\n      (struct.nestingMode === \"list\" || struct.nestingMode === \"set\")\n    ) {\n      this.emitComplexListClass(struct);\n    } else if (struct.nestingMode === \"map\") {\n      this.emitComplexMapClass(struct);\n    } else if (struct.nestingMode === \"maplist\") {\n      this.emitComplexMapListClasses(struct);\n    } else if (struct.nestingMode === \"mapset\") {\n      this.emitComplexMapListClasses(struct);\n    } else if (struct.nestingMode === \"listmap\") {\n      this.emitComplexListMapClasses(struct, false);\n    } else if (struct.nestingMode === \"setmap\") {\n      this.emitComplexListMapClasses(struct, true);\n    } else if (\n      struct.nestingMode === \"listlist\" ||\n      struct.nestingMode === \"listset\" ||\n      struct.nestingMode === \"setlist\" ||\n      struct.nestingMode === \"setset\"\n    ) {\n      this.emitComplexListListClasses(struct);\n    }\n    // other types of nested collections aren't supported\n  }\n\n  private emitComplexListClass(struct: Struct) {\n    this.code.line();\n    this.code.openBlock(\n      `export class ${struct.listName} extends cdktn.ComplexList`,\n    );\n\n    if (struct.assignable) {\n      this.code.line(\n        `public internalValue? : ${struct.name}[] | cdktn.IResolvable`,\n      );\n    }\n\n    this.code.line();\n    const constructorComment = sanitizedComment(this.code);\n    constructorComment.line(`@param terraformResource The parent resource`);\n    constructorComment.line(\n      `@param terraformAttribute The attribute on the parent resource this class is referencing`,\n    );\n    constructorComment.line(\n      `@param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)`,\n    );\n    constructorComment.end();\n    this.code.openBlock(\n      `constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string, wrapsSet: boolean)`,\n    );\n    this.code.line(`super(terraformResource, terraformAttribute, wrapsSet)`);\n    this.code.closeBlock();\n\n    this.code.line();\n    const getterComment = sanitizedComment(this.code);\n    getterComment.line(`@param index the index of the item to return`);\n    getterComment.end();\n    this.code.openBlock(\n      `public get(index: number): ${struct.outputReferenceName}`,\n    );\n    this.code.line(\n      `return new ${struct.outputReferenceName}(this.terraformResource, this.terraformAttribute, index, this.wrapsSet);`,\n    );\n    this.code.closeBlock();\n\n    this.code.closeBlock();\n  }\n\n  private emitComplexMapClass(struct: Struct) {\n    this.code.line();\n    this.code.openBlock(\n      `export class ${struct.mapName} extends cdktn.ComplexMap`,\n    );\n\n    if (struct.assignable) {\n      this.code.line(\n        `public internalValue? : { [key: string]: ${struct.name} } | cdktn.IResolvable`,\n      );\n    }\n\n    this.code.line();\n    const constructorComment = sanitizedComment(this.code);\n    constructorComment.line(`@param terraformResource The parent resource`);\n    constructorComment.line(\n      `@param terraformAttribute The attribute on the parent resource this class is referencing`,\n    );\n    constructorComment.end();\n    this.code.openBlock(\n      `constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string)`,\n    );\n    this.code.line(`super(terraformResource, terraformAttribute)`);\n    this.code.closeBlock();\n\n    this.code.line();\n    const getterComment = sanitizedComment(this.code);\n    getterComment.line(`@param key the key of the item to return`);\n    getterComment.end();\n    this.code.openBlock(\n      `public get(key: string): ${struct.outputReferenceName}`,\n    );\n    this.code.line(\n      `return new ${struct.outputReferenceName}(this.terraformResource, this.terraformAttribute, key);`,\n    );\n    this.code.closeBlock();\n\n    this.code.closeBlock();\n  }\n\n  private emitComplexMapListClasses(struct: Struct) {\n    this.emitComplexMapListClass(struct);\n    this.emitComplexMapClass(struct);\n  }\n\n  private emitComplexMapListClass(struct: Struct) {\n    this.code.line();\n    this.code.openBlock(\n      `export class ${struct.mapListName} extends cdktn.MapList`,\n    );\n\n    if (struct.assignable) {\n      this.code.line(\n        `public internalValue? : ${struct.mapName}[] | cdktn.IResolvable`,\n      );\n    }\n\n    this.code.line();\n    const constructorComment = sanitizedComment(this.code);\n    constructorComment.line(`@param terraformResource The parent resource`);\n    constructorComment.line(\n      `@param terraformAttribute The attribute on the parent resource this class is referencing`,\n    );\n    constructorComment.line(\n      `@param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)`,\n    );\n    constructorComment.end();\n    this.code.openBlock(\n      `constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string, wrapsSet: boolean)`,\n    );\n    this.code.line(`super(terraformResource, terraformAttribute, wrapsSet)`);\n    this.code.closeBlock();\n\n    this.code.line();\n    const getterComment = sanitizedComment(this.code);\n    getterComment.line(`@param index the index of the item to return`);\n    getterComment.end();\n    this.code.openBlock(`public get(index: number): ${struct.mapName}`);\n    this.code.line(`return new ${struct.mapName}(this, \\`[\\${index}]\\`);`);\n    this.code.closeBlock();\n\n    this.code.closeBlock();\n  }\n\n  private emitComplexListMapClasses(struct: Struct, isSet: boolean) {\n    this.emitComplexListMapClass(struct, isSet);\n    this.emitComplexListClass(struct);\n  }\n\n  private emitComplexListMapClass(struct: Struct, isSet: boolean) {\n    this.code.line();\n    this.code.openBlock(\n      `export class ${struct.listMapName} extends cdktn.ComplexMap`,\n    );\n\n    if (struct.assignable) {\n      this.code.line(\n        `public internalValue? : { [key: string]: ${struct.name}[] } | cdktn.IResolvable`,\n      );\n    }\n\n    this.code.line();\n    const constructorComment = sanitizedComment(this.code);\n    constructorComment.line(`@param terraformResource The parent resource`);\n    constructorComment.line(\n      `@param terraformAttribute The attribute on the parent resource this class is referencing`,\n    );\n    constructorComment.end();\n    this.code.openBlock(\n      `constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string)`,\n    );\n    this.code.line(`super(terraformResource, terraformAttribute)`);\n    this.code.closeBlock();\n\n    this.code.line();\n    const getterComment = sanitizedComment(this.code);\n    getterComment.line(`@param key the key of the item to return`);\n    getterComment.end();\n    this.code.openBlock(`public get(key: string): ${struct.listName}`);\n    this.code.line(\n      `return new ${struct.listName}(this, \\`[\\${key}]\\`, ${isSet});`,\n    );\n    this.code.closeBlock();\n\n    this.code.closeBlock();\n  }\n\n  private emitComplexListListClasses(struct: Struct) {\n    this.emitComplexListListClass(struct);\n    this.emitComplexListClass(struct);\n  }\n\n  private emitComplexListListClass(struct: Struct) {\n    this.code.line();\n    this.code.openBlock(\n      `export class ${struct.listListName} extends cdktn.MapList`, // despite name, need the same behavior\n    );\n\n    if (struct.assignable) {\n      this.code.line(\n        `public internalValue? : ${struct.name}[][] | cdktn.IResolvable`,\n      );\n    }\n\n    this.code.line();\n    const constructorComment = sanitizedComment(this.code);\n    constructorComment.line(`@param terraformResource The parent resource`);\n    constructorComment.line(\n      `@param terraformAttribute The attribute on the parent resource this class is referencing`,\n    );\n    constructorComment.line(\n      `@param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)`,\n    );\n    constructorComment.end();\n    this.code.openBlock(\n      `constructor(terraformResource: cdktn.IInterpolatingParent, terraformAttribute: string, wrapsSet: boolean)`,\n    );\n    this.code.line(`super(terraformResource, terraformAttribute, wrapsSet)`);\n    this.code.closeBlock();\n\n    this.code.line();\n    const getterComment = sanitizedComment(this.code);\n    getterComment.line(`@param index the index of the item to return`);\n    getterComment.end();\n    this.code.openBlock(`public get(index: number): ${struct.listName}`);\n    this.code.line(\n      `return new ${struct.listName}(this, \\`[\\${index}]\\`, ${\n        struct.nestingMode === \"setlist\" || struct.nestingMode === \"setset\"\n      });`,\n    );\n    this.code.closeBlock();\n\n    this.code.closeBlock();\n  }\n\n  private emitInternalValueGetter(struct: Struct) {\n    this.code.openBlock(\n      `public get internalValue(): ${struct.name}${\n        !struct.isClass ? \" | cdktn.IResolvable\" : \"\"\n      } | undefined`,\n    );\n\n    if (!struct.isClass) {\n      this.code.openBlock(\"if (this.resolvableValue)\");\n      this.code.line(\"return this.resolvableValue;\");\n      this.code.closeBlock();\n    }\n\n    this.code.line(\"let hasAnyValues = this.isEmptyObject;\");\n    this.code.line(\"const internalValueResult: any = {};\");\n    for (const att of struct.attributes) {\n      if (att.isStored) {\n        if (att.getterType._type === \"stored_class\") {\n          this.code.openBlock(\n            `if (this.${att.storageName}?.internalValue !== undefined)`,\n          );\n        } else {\n          this.code.openBlock(`if (this.${att.storageName} !== undefined)`);\n        }\n        this.code.line(\"hasAnyValues = true;\");\n        if (att.getterType._type === \"stored_class\") {\n          this.code.line(\n            `internalValueResult.${att.name} = this.${att.storageName}?.internalValue;`,\n          );\n        } else {\n          this.code.line(\n            `internalValueResult.${att.name} = this.${att.storageName};`,\n          );\n        }\n        this.code.closeBlock();\n      }\n    }\n    this.code.line(\"return hasAnyValues ? internalValueResult : undefined;\");\n    this.code.closeBlock();\n  }\n\n  private emitInternalValueSetter(struct: Struct) {\n    this.code.openBlock(\n      `public set internalValue(value: ${struct.name}${\n        !struct.isClass ? \" | cdktn.IResolvable\" : \"\"\n      } | undefined)`,\n    );\n\n    this.code.openBlock(\"if (value === undefined)\");\n    this.code.line(\"this.isEmptyObject = false;\");\n    if (!struct.isClass) {\n      this.code.line(\"this.resolvableValue = undefined;\");\n    }\n    for (const att of struct.attributes) {\n      if (att.isStored) {\n        if (att.setterType._type === \"stored_class\") {\n          this.code.line(`this.${att.storageName}.internalValue = undefined;`);\n        } else if (att.setterType._type !== \"none\") {\n          this.code.line(`this.${att.storageName} = undefined;`);\n        }\n      }\n    }\n    this.code.closeBlock();\n    if (!struct.isClass) {\n      this.code.openBlock(\"else if (cdktn.Tokenization.isResolvable(value))\");\n      this.code.line(\"this.isEmptyObject = false;\");\n      this.code.line(\"this.resolvableValue = value;\");\n      this.code.closeBlock();\n    }\n    this.code.openBlock(\"else\");\n    this.code.line(\"this.isEmptyObject = Object.keys(value).length === 0;\");\n    if (!struct.isClass) {\n      this.code.line(\"this.resolvableValue = undefined;\");\n    }\n    for (const att of struct.attributes) {\n      if (att.isStored) {\n        if (att.setterType._type === \"stored_class\") {\n          this.code.line(\n            `this.${att.storageName}.internalValue = value.${att.name};`,\n          );\n        } else if (att.setterType._type !== \"none\") {\n          this.code.line(`this.${att.storageName} = value.${att.name};`);\n        }\n      }\n    }\n    this.code.closeBlock();\n    this.code.closeBlock();\n  }\n\n  private emitToHclTerraformFunction(struct: Struct) {\n    this.code.line();\n    this.code.openBlock(\n      `export function ${downcaseFirst(struct.name)}ToHclTerraform(struct?: ${\n        struct.isSingleItem && !struct.isProvider\n          ? `${struct.name}OutputReference | `\n          : \"\"\n      }${struct.name}${!struct.isClass ? \" | cdktn.IResolvable\" : \"\"}): any`,\n    );\n    this.code.line(\n      `if (!cdktn.canInspect(struct) || cdktn.Tokenization.isResolvable(struct)) { return struct; }`,\n    );\n    this.code.openBlock(`if (cdktn.isComplexElement(struct))`);\n    this.code.line(\n      `throw new Error(\"A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration\");`,\n    );\n    this.code.closeBlock();\n\n    this.code.open(`const attrs = {`);\n\n    for (const att of struct.assignableAttributes) {\n      this.attributesEmitter.emitToHclTerraform(att, true);\n    }\n\n    this.code.close(`};`);\n\n    if (struct.assignableAttributes.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    this.code.line();\n  }\n\n  private emitToTerraformFunction(struct: Struct) {\n    this.code.line();\n    this.code.openBlock(\n      `export function ${downcaseFirst(struct.name)}ToTerraform(struct?: ${\n        struct.isSingleItem && !struct.isProvider\n          ? `${struct.name}OutputReference | `\n          : \"\"\n      }${struct.name}${!struct.isClass ? \" | cdktn.IResolvable\" : \"\"}): any`,\n    );\n    this.code.line(\n      `if (!cdktn.canInspect(struct) || cdktn.Tokenization.isResolvable(struct)) { return struct; }`,\n    );\n    this.code.openBlock(`if (cdktn.isComplexElement(struct))`);\n    this.code.line(\n      `throw new Error(\"A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration\");`,\n    );\n    this.code.closeBlock();\n\n    this.code.openBlock(\"return\");\n    for (const att of struct.assignableAttributes) {\n      this.attributesEmitter.emitToTerraform(att, true);\n    }\n    this.code.closeBlock(\";\");\n    this.code.closeBlock();\n    this.code.line();\n  }\n}\n"]}