@cdktn/provider-generator 0.24.0-pre.72 → 0.24.0-pre.75

package/build/get/generator/models/supported-stored-classes.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveStoredClassName = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const util_1 = require("../../../util");
+// The core cdktn package (packages/cdktn/src/complex-computed-list.ts) only hand-writes
+// this fixed set of wrapper classes for computed, non-complex collection attributes.
+// Arbitrarily deep nestings of list/set/map (e.g. map(map(list(string)))) compose a
+// storedClassType (e.g. "stringListMapMap") that has no corresponding class. Rather than
+// falling back straight to a plain, untyped getter, resolveStoredClassName below first
+// looks for the nearest typed "Any"-wrapper that still exists in this set, collapsing the
+// unsupported inner shape into an untyped boundary while preserving typed navigation for
+// the outer layers (see https://github.com/open-constructs/cdk-terrain/issues/11).
+const SUPPORTED_STORED_CLASSES = new Set([
+    "StringMap",
+    "NumberMap",
+    "BooleanMap",
+    "AnyMap",
+    "StringMapMap",
+    "NumberMapMap",
+    "BooleanMapMap",
+    "AnyMapMap",
+    "BooleanList",
+    "StringListList",
+    "NumberListList",
+    "BooleanListList",
+    "AnyListList",
+    "StringMapList",
+    "NumberMapList",
+    "BooleanMapList",
+    "AnyMapList",
+    "StringListMap",
+    "NumberListMap",
+    "BooleanListMap",
+    "AnyListMap",
+]);
+// Resolves the composed stored class name to use for a collection attribute (list/set/map)
+// whose element is itself a non-complex collection (or simple type).
+//
+// `ownStoredClassType` is this type's own composed storedClassType (e.g. "stringListMapMap"
+// for map(map(list(string)))) and `elementTypeModelType` is the element's typeModelType
+// ("list" | "set" | "map" | "simple" | ...).
+//
+// Resolution order:
+//   1. The own composed name (e.g. "StringListMapMap") - used as-is when it refers to a
+//      class that is hand-written in the core package (not collapsed).
+//   2. Otherwise, the nearest typed "Any"-wrapper that still encodes the outer two layers
+//      (this type's own layer and its element's layer), e.g. "AnyMapMap" - collapsing the
+//      unsupported inner shape into an untyped boundary while preserving typed navigation
+//      for the outer layers.
+//   3. Otherwise (defensively; every depth should resolve via 1 or 2), undefined - the
+//      caller must fall back to a plain, untyped getter.
+function resolveStoredClassName(ownStoredClassType, elementTypeModelType) {
+    const candidate1 = (0, util_1.uppercaseFirst)(ownStoredClassType);
+    if (SUPPORTED_STORED_CLASSES.has(candidate1)) {
+        return { name: candidate1, collapsed: false };
+    }
+    let ownLayer;
+    if (ownStoredClassType.endsWith("List")) {
+        ownLayer = "List";
+    }
+    else if (ownStoredClassType.endsWith("Map")) {
+        ownLayer = "Map";
+    }
+    if (!ownLayer) {
+        return undefined;
+    }
+    let innerLayer;
+    if (elementTypeModelType === "list" || elementTypeModelType === "set") {
+        innerLayer = "List";
+    }
+    else if (elementTypeModelType === "map") {
+        innerLayer = "Map";
+    }
+    if (!innerLayer) {
+        return undefined;
+    }
+    const candidate2 = `Any${innerLayer}${ownLayer}`;
+    if (SUPPORTED_STORED_CLASSES.has(candidate2)) {
+        return { name: candidate2, collapsed: true };
+    }
+    return undefined;
+}
+exports.resolveStoredClassName = resolveStoredClassName;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cdktn/provider-generator",
-  "version": "0.24.0-pre.72",
+  "version": "0.24.0-pre.75",
   "description": "Exposes API to generate Terraform CDK provider bindings",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -35,9 +35,9 @@
     "glob": "13.0.6",
     "jsii": "~5.9.0",
     "jsii-pacmak": "1.128.0",
-    "@cdktn/commons": "0.24.0-pre.72",
-    "@cdktn/provider-schema": "0.24.0-pre.72",
-    "cdktn": "0.24.0-pre.72"
+    "@cdktn/commons": "0.24.0-pre.75",
+    "@cdktn/provider-schema": "0.24.0-pre.75",
+    "cdktn": "0.24.0-pre.75"
   },
   "devDependencies": {
     "@types/fs-extra": "8.1.5",

package/src/get/__tests__/generator/__snapshots__/types.test.ts.snap

@@ -2172,6 +2172,155 @@ export class ComputedOptionalComplex extends cdktn.TerraformResource {
 "
 `;
 
+exports[`deeply nested (unsupported) collection attribute types 1`] = `
+"// https://registry.terraform.io/providers/hashicorp/test/latest/docs/data-sources/deeply_nested_collections
+// generated from terraform resource schema
+
+import { Construct } from 'constructs';
+import * as cdktn from 'cdktn';
+
+// Configuration
+
+export interface DataDeeplyNestedCollectionsConfig extends cdktn.TerraformMetaArguments {
+}
+
+/**
+* Represents a {@link https://registry.terraform.io/providers/hashicorp/test/latest/docs/data-sources/deeply_nested_collections deeply_nested_collections}
+*/
+export class DataDeeplyNestedCollections extends cdktn.TerraformDataSource {
+
+  // =================
+  // STATIC PROPERTIES
+  // =================
+  public static readonly tfResourceType = "deeply_nested_collections";
+
+  // ==============
+  // STATIC Methods
+  // ==============
+  /**
+  * Generates CDKTN code for importing a DataDeeplyNestedCollections resource upon running "cdktn plan <stack-name>"
+  * @param scope The scope in which to define this construct
+  * @param importToId The construct id used in the generated config for the DataDeeplyNestedCollections to import
+  * @param importFromId The id of the existing DataDeeplyNestedCollections that should be imported. Refer to the {@link https://registry.terraform.io/providers/hashicorp/test/latest/docs/data-sources/deeply_nested_collections#import import section} in the documentation of this resource for the id to use
+  * @param provider? Optional instance of the provider where the DataDeeplyNestedCollections to import is found
+  */
+  public static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktn.TerraformProvider) {
+        return new cdktn.ImportableResource(scope, importToId, { terraformResourceType: "deeply_nested_collections", importId: importFromId, provider });
+      }
+
+  // ===========
+  // INITIALIZER
+  // ===========
+
+  /**
+  * Create a new {@link https://registry.terraform.io/providers/hashicorp/test/latest/docs/data-sources/deeply_nested_collections deeply_nested_collections} Data Source
+  *
+  * @param scope The scope in which to define this construct
+  * @param id The scoped construct ID. Must be unique amongst siblings in the same scope
+  * @param options DataDeeplyNestedCollectionsConfig = {}
+  */
+  public constructor(scope: Construct, id: string, config: DataDeeplyNestedCollectionsConfig = {}) {
+    super(scope, id, {
+      terraformResourceType: 'deeply_nested_collections',
+      terraformGeneratorMetadata: {
+        providerName: 'test'
+      },
+      provider: config.provider,
+      dependsOn: config.dependsOn,
+      count: config.count,
+      lifecycle: config.lifecycle,
+      provisioners: config.provisioners,
+      connection: config.connection,
+      forEach: config.forEach
+    });
+  }
+
+  // ==========
+  // ATTRIBUTES
+  // ==========
+
+  // map_map_list_string - computed: true, optional: false, required: false
+  private _mapMapListString = new cdktn.AnyMapMap(this, "map_map_list_string");
+  /**
+  * Terraform type: \`map(map(list(string)))\`.
+  * This nesting is deeper than the typed wrapper classes in the core cdktn package; it is exposed as \`AnyMapMap\` and values below that boundary are untyped tokens.
+  */
+  public get mapMapListString() {
+    return this._mapMapListString;
+  }
+
+  // list_map_map_string - computed: true, optional: false, required: false
+  private _listMapMapString = new cdktn.AnyMapList(this, "list_map_map_string", false);
+  /**
+  * Terraform type: \`list(map(map(string)))\`.
+  * This nesting is deeper than the typed wrapper classes in the core cdktn package; it is exposed as \`AnyMapList\` and values below that boundary are untyped tokens.
+  */
+  public get listMapMapString() {
+    return this._listMapMapString;
+  }
+
+  // set_map_list_number - computed: true, optional: false, required: false
+  private _setMapListNumber = new cdktn.AnyMapList(this, "set_map_list_number", true);
+  /**
+  * Terraform type: \`set(map(list(number)))\`.
+  * This nesting is deeper than the typed wrapper classes in the core cdktn package; it is exposed as \`AnyMapList\` and values below that boundary are untyped tokens.
+  */
+  public get setMapListNumber() {
+    return this._setMapListNumber;
+  }
+
+  // map_list_string - computed: true, optional: false, required: false
+  private _mapListString = new cdktn.StringListMap(this, "map_list_string");
+  public get mapListString() {
+    return this._mapListString;
+  }
+
+  // map_map_number - computed: true, optional: false, required: false
+  private _mapMapNumber = new cdktn.NumberMapMap(this, "map_map_number");
+  public get mapMapNumber() {
+    return this._mapMapNumber;
+  }
+
+  // map_map_bool - computed: true, optional: false, required: false
+  private _mapMapBool = new cdktn.BooleanMapMap(this, "map_map_bool");
+  public get mapMapBool() {
+    return this._mapMapBool;
+  }
+
+  // map_map_string - computed: true, optional: false, required: false
+  private _mapMapString = new cdktn.StringMapMap(this, "map_map_string");
+  public get mapMapString() {
+    return this._mapMapString;
+  }
+
+  // map_map_map_list_string - computed: true, optional: false, required: false
+  private _mapMapMapListString = new cdktn.AnyMapMap(this, "map_map_map_list_string");
+  /**
+  * Terraform type: \`map(map(map(list(string))))\`.
+  * This nesting is deeper than the typed wrapper classes in the core cdktn package; it is exposed as \`AnyMapMap\` and values below that boundary are untyped tokens.
+  */
+  public get mapMapMapListString() {
+    return this._mapMapMapListString;
+  }
+
+  // =========
+  // SYNTHESIS
+  // =========
+
+  protected synthesizeAttributes(): { [name: string]: any } {
+    return {
+    };
+  }
+
+  protected synthesizeHclAttributes(): { [name: string]: any } {
+    const attrs = {
+    };
+    return attrs;
+  }
+}
+"
+`;
+
 exports[`deeply nested block types 1`] = `
 "// https://registry.terraform.io/providers/hashicorp/aws/latest/docs/resources/deeply_nested_block_types
 // generated from terraform resource schema

package/src/get/__tests__/generator/fixtures/deeply-nested-collections.test.fixture.json

@@ -0,0 +1,129 @@
+{
+  "format_version": "1.0",
+  "provider_schemas": {
+    "registry.terraform.io/hashicorp/test": {
+      "data_source_schemas": {
+        "deeply_nested_collections": {
+          "version": 0,
+          "block": {
+            "attributes": {
+              "map_map_list_string": {
+                "type": [
+                  "map",
+                  [
+                    "map",
+                    [
+                      "list",
+                      "string"
+                    ]
+                  ]
+                ],
+                "description": "map(map(list(string))) - unsupported triple nesting, reproduces open-constructs/cdk-terrain#11.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "list_map_map_string": {
+                "type": [
+                  "list",
+                  [
+                    "map",
+                    [
+                      "map",
+                      "string"
+                    ]
+                  ]
+                ],
+                "description": "list(map(map(string))) - unsupported triple nesting.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "set_map_list_number": {
+                "type": [
+                  "set",
+                  [
+                    "map",
+                    [
+                      "list",
+                      "number"
+                    ]
+                  ]
+                ],
+                "description": "set(map(list(number))) - unsupported triple nesting.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "map_list_string": {
+                "type": [
+                  "map",
+                  [
+                    "list",
+                    "string"
+                  ]
+                ],
+                "description": "map(list(string)) - supported double nesting, must still emit cdktn.StringListMap.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "map_map_number": {
+                "type": [
+                  "map",
+                  [
+                    "map",
+                    "number"
+                  ]
+                ],
+                "description": "map(map(number)) - now directly supported via cdktn.NumberMapMap.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "map_map_bool": {
+                "type": [
+                  "map",
+                  [
+                    "map",
+                    "bool"
+                  ]
+                ],
+                "description": "map(map(bool)) - now directly supported via cdktn.BooleanMapMap.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "map_map_string": {
+                "type": [
+                  "map",
+                  [
+                    "map",
+                    "string"
+                  ]
+                ],
+                "description": "map(map(string)) - pre-existing support via cdktn.StringMapMap, unchanged.",
+                "description_kind": "plain",
+                "computed": true
+              },
+              "map_map_map_list_string": {
+                "type": [
+                  "map",
+                  [
+                    "map",
+                    [
+                      "map",
+                      [
+                        "list",
+                        "string"
+                      ]
+                    ]
+                  ]
+                ],
+                "description": "map(map(map(list(string)))) - unsupported quadruple nesting, collapses to cdktn.AnyMapMap.",
+                "description_kind": "plain",
+                "computed": true
+              }
+            },
+            "description": "Data source used to verify deeply nested collection attribute types are handled without generating references to non-existent cdktn classes.",
+            "description_kind": "plain"
+          }
+        }
+      }
+    }
+  }
+}

package/src/get/__tests__/generator/supported-stored-classes.test.ts

@@ -0,0 +1,147 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { logger } from "@cdktn/commons";
+import { resolveStoredClassName } from "../../generator/models/supported-stored-classes";
+import {
+  AttributeModel,
+  AttributeTypeModel,
+  MapAttributeTypeModel,
+} from "../../generator/models";
+
+describe("resolveStoredClassName", () => {
+  test("own composed name resolves as-is when supported (not collapsed)", () => {
+    expect(resolveStoredClassName("stringListMap", "list")).toEqual({
+      name: "StringListMap",
+      collapsed: false,
+    });
+    expect(resolveStoredClassName("stringMapMap", "map")).toEqual({
+      name: "StringMapMap",
+      collapsed: false,
+    });
+    expect(resolveStoredClassName("numberMapMap", "map")).toEqual({
+      name: "NumberMapMap",
+      collapsed: false,
+    });
+    expect(resolveStoredClassName("booleanMapMap", "map")).toEqual({
+      name: "BooleanMapMap",
+      collapsed: false,
+    });
+  });
+
+  test("unsupported own composed name collapses to nearest Any-wrapper", () => {
+    // map(map(list(string))) - own "stringListMapMap" unsupported, element is a map
+    expect(resolveStoredClassName("stringListMapMap", "map")).toEqual({
+      name: "AnyMapMap",
+      collapsed: true,
+    });
+    // list(map(map(string))) - own "stringMapMapList" unsupported, element is a map
+    expect(resolveStoredClassName("stringMapMapList", "map")).toEqual({
+      name: "AnyMapList",
+      collapsed: true,
+    });
+    // set(map(list(number))) - own "numberListMapList" unsupported, element is a map
+    expect(resolveStoredClassName("numberListMapList", "map")).toEqual({
+      name: "AnyMapList",
+      collapsed: true,
+    });
+    // map(map(map(list(string)))) - own "stringListMapMapMap" unsupported, element is a map
+    expect(resolveStoredClassName("stringListMapMapMap", "map")).toEqual({
+      name: "AnyMapMap",
+      collapsed: true,
+    });
+  });
+
+  test("returns undefined when neither the own name nor a collapsed Any-wrapper exists", () => {
+    // Own name doesn't end in List/Map at all.
+    expect(resolveStoredClassName("somethingWeird", "map")).toBeUndefined();
+    // Own name ends in Map, but the element isn't itself a list/set/map, so there is no
+    // "AnyXMap" candidate to fall back to.
+    expect(resolveStoredClassName("weirdMap", "struct")).toBeUndefined();
+    expect(resolveStoredClassName("weirdMap", "simple")).toBeUndefined();
+  });
+});
+
+// A minimal stand-in for a non-complex, non-collection AttributeTypeModel whose
+// typeModelType is neither "list", "set", "map", nor "simple"/"struct" - i.e. a shape the
+// generator's collapse logic has no candidate class name for. Used to exercise the
+// defensive plain-getter fallback in AttributeModel.getterType without needing a real
+// (currently nonexistent) unsupported shape.
+class UnresolvableStubTypeModel implements AttributeTypeModel {
+  get struct() {
+    return undefined;
+  }
+  get isComplex() {
+    return false;
+  }
+  getStoredClassInitializer(_name: string) {
+    return "";
+  }
+  get storedClassType() {
+    return "unresolvable";
+  }
+  get inputTypeDefinition() {
+    return "any";
+  }
+  getAttributeAccessFunction(name: string) {
+    return `this.interpolationForAttribute('${name}')`;
+  }
+  get toTerraformFunction() {
+    return "cdktn.anyToTerraform";
+  }
+  get toHclTerraformFunction() {
+    return "cdktn.anyToHclTerraform";
+  }
+  get typeModelType() {
+    return "unresolvable-shape";
+  }
+  get hasReferenceClass() {
+    return false;
+  }
+  get isTokenizable() {
+    return false;
+  }
+  get isStoredClassUnavailable() {
+    return false;
+  }
+}
+
+describe("AttributeModel.getterType loud fallback", () => {
+  test("falls back to a plain getter and logs a debug breadcrumb when no stored class (not even a collapsed Any-wrapper) is available", () => {
+    const debugSpy = jest.spyOn(logger, "debug").mockImplementation();
+
+    try {
+      // A map whose element is itself an unrecognized shape: own composed name
+      // ("unresolvableMap") isn't in the supported set, and the element's typeModelType
+      // isn't "list"/"set"/"map", so there is no "AnyXMap" candidate either.
+      const type = new MapAttributeTypeModel(new UnresolvableStubTypeModel());
+      expect(type.isStoredClassUnavailable).toBe(true);
+
+      const attribute = new AttributeModel({
+        storageName: "_weirdAttribute",
+        name: "weirdAttribute",
+        type,
+        optional: false,
+        computed: true,
+        terraformName: "weird_attribute",
+        terraformFullName: "test_resource.weird_attribute",
+        provider: false,
+        required: false,
+      });
+
+      expect(attribute.getterType).toEqual({ _type: "plain" });
+      expect(attribute.storedClassBoundaryKind).toEqual("fallback");
+
+      expect(debugSpy).toHaveBeenCalledTimes(1);
+      const [message] = debugSpy.mock.calls[0];
+      expect(message).toContain("test_resource.weird_attribute");
+      expect(message).toContain("unresolvableMap");
+
+      // Repeated access must not spam the logger.
+      void attribute.getterType;
+      void attribute.getterType;
+      expect(debugSpy).toHaveBeenCalledTimes(1);
+    } finally {
+      debugSpy.mockRestore();
+    }
+  });
+});

package/src/get/__tests__/generator/types.test.ts

@@ -609,3 +609,78 @@ test("case-insensitive base name collision", async () => {
     expect(output).toMatchSnapshot(file);
   }
 });
+
+test("deeply nested (unsupported) collection attribute types", async () => {
+  // Regression test for https://github.com/open-constructs/cdk-terrain/issues/11:
+  // computed attributes whose type nests list/set/map more than two levels deep (e.g.
+  // map(map(list(string)))) must not generate a reference to a "cdktn.*" stored class
+  // that doesn't exist (e.g. "StringListMapMap"). Instead of falling straight back to a
+  // plain, untyped getter, the generator collapses these into the nearest typed
+  // "Any"-wrapper that does exist (e.g. "AnyMapMap"), preserving typed navigation for the
+  // outer layers. Only shapes with no available stored class at all fall back to a plain
+  // getter.
+  const code = new CodeMaker();
+  const workdir = tmp("deeply-nested-collections.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "deeply-nested-collections.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(
+      workdir,
+      "providers/test/data-deeply-nested-collections/index.ts",
+    ),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+
+  // None of the unsupported nested attributes should reference a non-existent "cdktn.*"
+  // wrapper class.
+  expect(output).not.toContain("StringListMapMap");
+  expect(output).not.toContain("StringMapMapList");
+  expect(output).not.toContain("NumberListMapList");
+  expect(output).not.toContain("StringListMapMapMap");
+
+  // Unsupported triple nestings collapse to the nearest typed "Any"-wrapper instead of
+  // falling back to a plain getter.
+  expect(output).toContain('new cdktn.AnyMapMap(this, "map_map_list_string")');
+  expect(output).toContain(
+    'new cdktn.AnyMapList(this, "list_map_map_string", false)',
+  );
+  expect(output).toContain(
+    'new cdktn.AnyMapList(this, "set_map_list_number", true)',
+  );
+  expect(output).toContain(
+    'new cdktn.AnyMapMap(this, "map_map_map_list_string")',
+  );
+
+  // A supported double nesting (map(list(string))) must still emit its stored class.
+  expect(output).toContain('new cdktn.StringListMap(this, "map_list_string")');
+
+  // map(map(number)) / map(map(bool)) are now directly supported by new core classes.
+  expect(output).toContain('new cdktn.NumberMapMap(this, "map_map_number")');
+  expect(output).toContain('new cdktn.BooleanMapMap(this, "map_map_bool")');
+
+  // map(map(string)) is pre-existing, unchanged support.
+  expect(output).toContain('new cdktn.StringMapMap(this, "map_map_string")');
+
+  // Collapsed getters get a JSDoc documenting the Terraform type and the collapse
+  // boundary.
+  expect(output).toContain("Terraform type: `map(map(list(string)))`");
+  expect(output).toContain(
+    "it is exposed as `AnyMapMap` and values below that boundary are untyped tokens",
+  );
+
+  // Supported, non-collapsed attributes must NOT get this JSDoc (avoids snapshot churn).
+  expect(output).not.toContain("Terraform type: `map(list(string))`");
+  expect(output).not.toContain("Terraform type: `map(map(string))`");
+});