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

package/build/get/__tests__/generator/provider-functions.test.js

@@ -0,0 +1,176 @@
+"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 });
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const provider_generator_1 = require("../../generator/provider-generator");
+const provider_function_model_1 = require("../../generator/models/provider-function-model");
+const codemaker_1 = require("codemaker");
+const util_1 = require("../util");
+const tmp = (0, util_1.createTmpHelper)();
+test("generate provider functions for the time provider (real terraform 1.15.6 schema fragment)", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("provider-functions.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "provider-functions.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const providerFunctionsOutput = fs.readFileSync(path.join(workdir, "providers/time/provider-functions/index.ts"), "utf-8");
+    expect(providerFunctionsOutput).toMatchSnapshot("time-provider-functions");
+    const providerOutput = fs.readFileSync(path.join(workdir, "providers/time/provider/index.ts"), "utf-8");
+    expect(providerOutput).toMatchSnapshot("time-provider");
+    const providerIndex = fs.readFileSync(path.join(workdir, "providers/time/index.ts"), "utf-8");
+    expect(providerIndex).toMatchSnapshot("provider-index");
+    const providerLazyIndex = fs.readFileSync(path.join(workdir, "providers/time/lazy-index.ts"), "utf-8");
+    expect(providerLazyIndex).toMatchSnapshot("provider-lazy-index");
+});
+describe("generate provider functions covering variadic parameters, primitive/list returns, and a 'default' parameter name", () => {
+    let providerFunctionsOutput;
+    let providerIndex;
+    let providerLazyIndex;
+    beforeAll(async () => {
+        const code = new codemaker_1.CodeMaker();
+        const workdir = tmp("provider-functions-synthetic.test");
+        const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "provider-functions-synthetic.test.fixture.json"), "utf-8"));
+        new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+        await code.save(workdir);
+        providerFunctionsOutput = fs.readFileSync(path.join(workdir, "providers/example/provider-functions/index.ts"), "utf-8");
+        providerIndex = fs.readFileSync(path.join(workdir, "providers/example/index.ts"), "utf-8");
+        providerLazyIndex = fs.readFileSync(path.join(workdir, "providers/example/lazy-index.ts"), "utf-8");
+    });
+    test("matches the snapshot", () => {
+        expect(providerFunctionsOutput).toMatchSnapshot("example-provider-functions");
+        expect(providerIndex).toMatchSnapshot("provider-index");
+        expect(providerLazyIndex).toMatchSnapshot("provider-lazy-index");
+    });
+    test("nested collection docstrings use the compact recursive Array/Set notation", () => {
+        // list(set(string)): notation carries the structure; a plain Terraform
+        // list needs no prose note.
+        expect(providerFunctionsOutput).toContain("@param {Array<Set<string>>} nameGroups");
+        expect(providerFunctionsOutput).toContain("@returns {Array<Set<string>>}");
+        // set(list(string)): Set<...> notation plus the set-semantics prose note
+        // (the jsii type is still an array - the note keeps a reader from
+        // literally passing a JS Set).
+        expect(providerFunctionsOutput).toContain("@param {Set<Array<string>>} nameLists - Terraform set; ordering is not guaranteed and duplicate values are removed.");
+        expect(providerFunctionsOutput).toContain("@returns {Set<Array<string>>} Terraform set; ordering is not guaranteed and duplicate values are removed.");
+    });
+    // This package has no TypeScript-compiling harness
+    // for generated output (no fixture/test anywhere generates a snippet and
+    // feeds it through `tsc`/`ts.transpileModule`, and `cdktn` itself isn't a
+    // dependency of this package to typecheck against), so these are
+    // structural assertions on the emitted declaration text rather than an
+    // actual compile - see also the runtime-level proof in
+    // packages/cdktn/test/provider-functions.test.ts, which exercises the
+    // same union/token mechanics these signatures rely on.
+    describe("composition: a function's return type is directly assignable to another function's parameter of the 'same' Terraform type", () => {
+        test("flagsForSeed()'s set(bool) return type (cdktn.IResolvable) is one of the exact union members flagSet()'s set(bool) parameter declares", () => {
+            expect(providerFunctionsOutput).toContain("public flagsForSeed(seed: string): cdktn.IResolvable {");
+            expect(providerFunctionsOutput).toContain("public flagSet(flags: Array<boolean | cdktn.IResolvable> | cdktn.IResolvable): cdktn.IResolvable {");
+        });
+        test("defaultTags()'s map(string) return type is textually identical to tagMap()'s map(string) parameter type", () => {
+            expect(providerFunctionsOutput).toContain("public defaultTags(prefix: string): { [key: string]: string } {");
+            expect(providerFunctionsOutput).toContain("public tagMap(tags: { [key: string]: string }): string {");
+        });
+    });
+    test("a list(bool) parameter (not just set(bool)) also accepts a whole-collection token", () => {
+        expect(providerFunctionsOutput).toContain("public flagsOrdered(flags: Array<boolean | cdktn.IResolvable> | cdktn.IResolvable): cdktn.IResolvable {");
+    });
+    test("a list(object) parameter widens to any[] | cdktn.IResolvable (whole-collection token accepted)", () => {
+        expect(providerFunctionsOutput).toContain("public describeConfigs(configs: any[] | cdktn.IResolvable): string {");
+    });
+});
+test("buildProviderFunctionsModel throws when two function names collapse to the same generated method name", () => {
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        foo_bar: { return_type: "string", parameters: [] },
+        foo__bar: { return_type: "string", parameters: [] },
+    })).toThrow(/foo_bar/);
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        foo_bar: { return_type: "string", parameters: [] },
+        foo__bar: { return_type: "string", parameters: [] },
+    })).toThrow(/foo__bar/);
+});
+test("buildProviderFunctionsModel throws when two parameter names collapse within one function", () => {
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        my_function: {
+            return_type: "string",
+            parameters: [
+                { name: "some_value", type: "string" },
+                { name: "some__value", type: "string" },
+            ],
+        },
+    })).toThrow(/some_value/);
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        my_function: {
+            return_type: "string",
+            parameters: [
+                { name: "some_value", type: "string" },
+                { name: "some__value", type: "string" },
+            ],
+        },
+    })).toThrow(/some__value/);
+});
+// Both of these assert the model-level throw happens before any file is
+// generated: buildProviderFunctionsModel is called directly, with no
+// CodeMaker/generator involved, so there is no emission step to reach.
+test("buildProviderFunctionsModel throws when a function name sanitizes to 'constructor'", () => {
+    // The nested signature literal is cast to `FunctionSignature` (rather than
+    // relying on contextual typing from the surrounding index signature)
+    // because TypeScript special-cases a property literally named
+    // "constructor" - contextually typing it against `Function` (from
+    // `Object.prototype`) instead of the index signature's `FunctionSignature`,
+    // and spuriously flagging `return_type: "string"` as an error. See
+    // https://github.com/microsoft/TypeScript/issues/40776.
+    const signature = {
+        return_type: "string",
+        parameters: [],
+    };
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        constructor: signature,
+    })).toThrow(/constructor/);
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        constructor: signature,
+    })).toThrow(/example/);
+});
+test("buildProviderFunctionsModel throws when a function name sanitizes to 'providerLocalName'", () => {
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        provider_local_name: { return_type: "string", parameters: [] },
+    })).toThrow(/provider_local_name/);
+    expect(() => (0, provider_function_model_1.buildProviderFunctionsModel)("example", {
+        provider_local_name: { return_type: "string", parameters: [] },
+    })).toThrow(/providerLocalName/);
+});
+test("assertNoFunctionsGetterCollision throws when the provider's own config schema would generate a 'functions' property", () => {
+    expect(() => (0, provider_function_model_1.assertNoFunctionsGetterCollision)("example", ["alias", "functions"])).toThrow(/"functions"/);
+});
+test("assertNoFunctionsGetterCollision does not throw when there is no colliding attribute", () => {
+    expect(() => (0, provider_function_model_1.assertNoFunctionsGetterCollision)("example", ["alias"])).not.toThrow();
+});
+test("generation throws when a provider's config attribute collides with the generated 'functions' getter", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "provider-functions-collision.test.fixture.json"), "utf-8"));
+    expect(() => new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll()).toThrow(/"functions"/);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider-functions.test.js","sourceRoot":"","sources":["../../../../src/get/__tests__/generator/provider-functions.test.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport { TerraformProviderGenerator } from \"../../generator/provider-generator\";\nimport {\n  assertNoFunctionsGetterCollision,\n  buildProviderFunctionsModel,\n} from \"../../generator/models/provider-function-model\";\nimport { CodeMaker } from \"codemaker\";\nimport { FunctionSignature } from \"@cdktn/commons\";\nimport { createTmpHelper } from \"../util\";\n\nconst tmp = createTmpHelper();\n\ntest(\"generate provider functions for the time provider (real terraform 1.15.6 schema fragment)\", async () => {\n  const code = new CodeMaker();\n  const workdir = tmp(\"provider-functions.test\");\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(__dirname, \"fixtures\", \"provider-functions.test.fixture.json\"),\n      \"utf-8\",\n    ),\n  );\n  new TerraformProviderGenerator(code, spec).generateAll();\n  await code.save(workdir);\n\n  const providerFunctionsOutput = fs.readFileSync(\n    path.join(workdir, \"providers/time/provider-functions/index.ts\"),\n    \"utf-8\",\n  );\n  expect(providerFunctionsOutput).toMatchSnapshot(\"time-provider-functions\");\n\n  const providerOutput = fs.readFileSync(\n    path.join(workdir, \"providers/time/provider/index.ts\"),\n    \"utf-8\",\n  );\n  expect(providerOutput).toMatchSnapshot(\"time-provider\");\n\n  const providerIndex = fs.readFileSync(\n    path.join(workdir, \"providers/time/index.ts\"),\n    \"utf-8\",\n  );\n  expect(providerIndex).toMatchSnapshot(\"provider-index\");\n\n  const providerLazyIndex = fs.readFileSync(\n    path.join(workdir, \"providers/time/lazy-index.ts\"),\n    \"utf-8\",\n  );\n  expect(providerLazyIndex).toMatchSnapshot(\"provider-lazy-index\");\n});\n\ndescribe(\"generate provider functions covering variadic parameters, primitive/list returns, and a 'default' parameter name\", () => {\n  let providerFunctionsOutput: string;\n  let providerIndex: string;\n  let providerLazyIndex: string;\n\n  beforeAll(async () => {\n    const code = new CodeMaker();\n    const workdir = tmp(\"provider-functions-synthetic.test\");\n    const spec = JSON.parse(\n      fs.readFileSync(\n        path.join(\n          __dirname,\n          \"fixtures\",\n          \"provider-functions-synthetic.test.fixture.json\",\n        ),\n        \"utf-8\",\n      ),\n    );\n    new TerraformProviderGenerator(code, spec).generateAll();\n    await code.save(workdir);\n\n    providerFunctionsOutput = fs.readFileSync(\n      path.join(workdir, \"providers/example/provider-functions/index.ts\"),\n      \"utf-8\",\n    );\n    providerIndex = fs.readFileSync(\n      path.join(workdir, \"providers/example/index.ts\"),\n      \"utf-8\",\n    );\n    providerLazyIndex = fs.readFileSync(\n      path.join(workdir, \"providers/example/lazy-index.ts\"),\n      \"utf-8\",\n    );\n  });\n\n  test(\"matches the snapshot\", () => {\n    expect(providerFunctionsOutput).toMatchSnapshot(\n      \"example-provider-functions\",\n    );\n    expect(providerIndex).toMatchSnapshot(\"provider-index\");\n    expect(providerLazyIndex).toMatchSnapshot(\"provider-lazy-index\");\n  });\n\n  test(\"nested collection docstrings use the compact recursive Array/Set notation\", () => {\n    // list(set(string)): notation carries the structure; a plain Terraform\n    // list needs no prose note.\n    expect(providerFunctionsOutput).toContain(\n      \"@param {Array<Set<string>>} nameGroups\",\n    );\n    expect(providerFunctionsOutput).toContain(\"@returns {Array<Set<string>>}\");\n    // set(list(string)): Set<...> notation plus the set-semantics prose note\n    // (the jsii type is still an array - the note keeps a reader from\n    // literally passing a JS Set).\n    expect(providerFunctionsOutput).toContain(\n      \"@param {Set<Array<string>>} nameLists - Terraform set; ordering is not guaranteed and duplicate values are removed.\",\n    );\n    expect(providerFunctionsOutput).toContain(\n      \"@returns {Set<Array<string>>} Terraform set; ordering is not guaranteed and duplicate values are removed.\",\n    );\n  });\n\n  // This package has no TypeScript-compiling harness\n  // for generated output (no fixture/test anywhere generates a snippet and\n  // feeds it through `tsc`/`ts.transpileModule`, and `cdktn` itself isn't a\n  // dependency of this package to typecheck against), so these are\n  // structural assertions on the emitted declaration text rather than an\n  // actual compile - see also the runtime-level proof in\n  // packages/cdktn/test/provider-functions.test.ts, which exercises the\n  // same union/token mechanics these signatures rely on.\n  describe(\"composition: a function's return type is directly assignable to another function's parameter of the 'same' Terraform type\", () => {\n    test(\"flagsForSeed()'s set(bool) return type (cdktn.IResolvable) is one of the exact union members flagSet()'s set(bool) parameter declares\", () => {\n      expect(providerFunctionsOutput).toContain(\n        \"public flagsForSeed(seed: string): cdktn.IResolvable {\",\n      );\n      expect(providerFunctionsOutput).toContain(\n        \"public flagSet(flags: Array<boolean | cdktn.IResolvable> | cdktn.IResolvable): cdktn.IResolvable {\",\n      );\n    });\n\n    test(\"defaultTags()'s map(string) return type is textually identical to tagMap()'s map(string) parameter type\", () => {\n      expect(providerFunctionsOutput).toContain(\n        \"public defaultTags(prefix: string): { [key: string]: string } {\",\n      );\n      expect(providerFunctionsOutput).toContain(\n        \"public tagMap(tags: { [key: string]: string }): string {\",\n      );\n    });\n  });\n\n  test(\"a list(bool) parameter (not just set(bool)) also accepts a whole-collection token\", () => {\n    expect(providerFunctionsOutput).toContain(\n      \"public flagsOrdered(flags: Array<boolean | cdktn.IResolvable> | cdktn.IResolvable): cdktn.IResolvable {\",\n    );\n  });\n\n  test(\"a list(object) parameter widens to any[] | cdktn.IResolvable (whole-collection token accepted)\", () => {\n    expect(providerFunctionsOutput).toContain(\n      \"public describeConfigs(configs: any[] | cdktn.IResolvable): string {\",\n    );\n  });\n});\n\ntest(\"buildProviderFunctionsModel throws when two function names collapse to the same generated method name\", () => {\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      foo_bar: { return_type: \"string\", parameters: [] },\n      foo__bar: { return_type: \"string\", parameters: [] },\n    }),\n  ).toThrow(/foo_bar/);\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      foo_bar: { return_type: \"string\", parameters: [] },\n      foo__bar: { return_type: \"string\", parameters: [] },\n    }),\n  ).toThrow(/foo__bar/);\n});\n\ntest(\"buildProviderFunctionsModel throws when two parameter names collapse within one function\", () => {\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      my_function: {\n        return_type: \"string\",\n        parameters: [\n          { name: \"some_value\", type: \"string\" },\n          { name: \"some__value\", type: \"string\" },\n        ],\n      },\n    }),\n  ).toThrow(/some_value/);\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      my_function: {\n        return_type: \"string\",\n        parameters: [\n          { name: \"some_value\", type: \"string\" },\n          { name: \"some__value\", type: \"string\" },\n        ],\n      },\n    }),\n  ).toThrow(/some__value/);\n});\n\n// Both of these assert the model-level throw happens before any file is\n// generated: buildProviderFunctionsModel is called directly, with no\n// CodeMaker/generator involved, so there is no emission step to reach.\ntest(\"buildProviderFunctionsModel throws when a function name sanitizes to 'constructor'\", () => {\n  // The nested signature literal is cast to `FunctionSignature` (rather than\n  // relying on contextual typing from the surrounding index signature)\n  // because TypeScript special-cases a property literally named\n  // \"constructor\" - contextually typing it against `Function` (from\n  // `Object.prototype`) instead of the index signature's `FunctionSignature`,\n  // and spuriously flagging `return_type: \"string\"` as an error. See\n  // https://github.com/microsoft/TypeScript/issues/40776.\n  const signature: FunctionSignature = {\n    return_type: \"string\",\n    parameters: [],\n  };\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      constructor: signature,\n    }),\n  ).toThrow(/constructor/);\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      constructor: signature,\n    }),\n  ).toThrow(/example/);\n});\n\ntest(\"buildProviderFunctionsModel throws when a function name sanitizes to 'providerLocalName'\", () => {\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      provider_local_name: { return_type: \"string\", parameters: [] },\n    }),\n  ).toThrow(/provider_local_name/);\n  expect(() =>\n    buildProviderFunctionsModel(\"example\", {\n      provider_local_name: { return_type: \"string\", parameters: [] },\n    }),\n  ).toThrow(/providerLocalName/);\n});\n\ntest(\"assertNoFunctionsGetterCollision throws when the provider's own config schema would generate a 'functions' property\", () => {\n  expect(() =>\n    assertNoFunctionsGetterCollision(\"example\", [\"alias\", \"functions\"]),\n  ).toThrow(/\"functions\"/);\n});\n\ntest(\"assertNoFunctionsGetterCollision does not throw when there is no colliding attribute\", () => {\n  expect(() =>\n    assertNoFunctionsGetterCollision(\"example\", [\"alias\"]),\n  ).not.toThrow();\n});\n\ntest(\"generation throws when a provider's config attribute collides with the generated 'functions' getter\", async () => {\n  const code = new CodeMaker();\n  const spec = JSON.parse(\n    fs.readFileSync(\n      path.join(\n        __dirname,\n        \"fixtures\",\n        \"provider-functions-collision.test.fixture.json\",\n      ),\n      \"utf-8\",\n    ),\n  );\n  expect(() =>\n    new TerraformProviderGenerator(code, spec).generateAll(),\n  ).toThrow(/\"functions\"/);\n});\n"]}

package/build/get/__tests__/generator/provider.test.js

@@ -39,6 +39,10 @@ test("generate provider", async () => {
     await code.save(workdir);
     const output = fs.readFileSync(path.join(workdir, "providers/aws/provider/index.ts"), "utf-8");
     expect(output).toMatchSnapshot();
+    // aws has no provider-defined functions in this fixture - no getter, no
+    // cross-directory import should be emitted.
+    expect(output).not.toContain("public get functions()");
+    expect(output).not.toContain("provider-functions");
 });
 test("generate provider with only block_types", async () => {
     const code = new codemaker_1.CodeMaker();
@@ -48,5 +52,9 @@ test("generate provider with only block_types", async () => {
     await code.save(workdir);
     const output = fs.readFileSync(path.join(workdir, "providers/elasticstack/provider/index.ts"), "utf-8");
     expect(output).toMatchSnapshot();
+    // elasticstack has no provider-defined functions in this fixture - no
+    // getter, no cross-directory import should be emitted.
+    expect(output).not.toContain("public get functions()");
+    expect(output).not.toContain("provider-functions");
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/get/__tests__/generator/write-only.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=write-only.test.d.ts.map

package/build/get/__tests__/generator/write-only.test.js

@@ -0,0 +1,65 @@
+"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 });
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const provider_generator_1 = require("../../generator/provider-generator");
+const codemaker_1 = require("codemaker");
+const util_1 = require("../util");
+const tmp = (0, util_1.createTmpHelper)();
+test("generate a vault_alicloud_secret_backend resource with a write-only attribute", async () => {
+    const code = new codemaker_1.CodeMaker();
+    const workdir = tmp("write-only.test");
+    const spec = JSON.parse(fs.readFileSync(path.join(__dirname, "fixtures", "write-only.test.fixture.json"), "utf-8"));
+    new provider_generator_1.TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+    const output = fs.readFileSync(path.join(workdir, "providers/vault/alicloud-secret-backend/index.ts"), "utf-8");
+    expect(output).toMatchSnapshot();
+    // The write-only attribute's getter is deprecated ...
+    expect(output).toMatch(/@deprecated Write-only: the provider never returns this value[\s\S]*?public get secretKeyWo\(\)/);
+    // ... its setter is a plain assignment ...
+    expect(output).toMatch(/public set secretKeyWo\(value: string\) \{\n\s*this\._secretKeyWo = value;\n\s*\}/);
+    // ... and usage registration happens at resolve time, from inside
+    // synthesizeAttributes()/synthesizeHclAttributes(), by wrapping the
+    // mapped value in markWriteOnlyAttribute() ...
+    expect(output).toMatch(/secret_key_wo: this\.markWriteOnlyAttribute\(cdktn\.stringToTerraform\(this\._secretKeyWo\)\),/);
+    expect(output).toMatch(/value: this\.markWriteOnlyAttribute\(cdktn\.stringToHclTerraform\(this\._secretKeyWo\)\),/);
+    // The required write-only attribute gets no reset method (required
+    // attributes never do) ...
+    expect(output).not.toMatch(/resetSecretKeyWo\b/);
+    // ... but the OPTIONAL write-only sibling does, exercising the reset ->
+    // clear -> synth-passes path end to end at the generator level.
+    expect(output).toMatch(/public resetSecondarySecretKeyWo\(\) \{\n\s*this\._secondarySecretKeyWo = undefined;\n\s*\}/);
+    expect(output).toMatch(/secondary_secret_key_wo: this\.markWriteOnlyAttribute\(cdktn\.stringToTerraform\(this\._secondarySecretKeyWo\)\),/);
+    // The non-write-only sibling attribute is untouched: its getter is
+    // emitted directly (no @deprecated JSDoc immediately above), its setter
+    // has no registration call, and its synthesis isn't wrapped.
+    expect(output).toMatch(/private _secretKeyWoVersion\?: number; \n\s*public get secretKeyWoVersion\(\)/);
+    expect(output).toMatch(/public set secretKeyWoVersion\(value: number\) \{\n\s*this\._secretKeyWoVersion = value;\n\s*\}/);
+    expect(output).toMatch(/secret_key_wo_version: cdktn\.numberToTerraform\(this\._secretKeyWoVersion\),/);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/get/__tests__/target-versions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=target-versions.test.d.ts.map

package/build/get/__tests__/target-versions.test.js

@@ -0,0 +1,171 @@
+"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 });
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const commons_1 = require("@cdktn/commons");
+const util_1 = require("./util");
+const mockReadSchema = jest.fn();
+jest.mock("@cdktn/provider-schema", () => ({
+    readSchema: (...args) => mockReadSchema(...args),
+}));
+// Imported after the mock so ConstructsMaker picks up the mocked readSchema.
+const constructs_maker_1 = require("../constructs-maker");
+const tmp = (0, util_1.createTmpHelper)();
+const constraint = {
+    fqn: "hashicorp/random",
+    name: "random",
+    source: "hashicorp/random",
+    version: "3.1.3",
+};
+// Minimal schema - no resources/data sources - so generation stays within
+// pure TypeScript emission (no jsii-pacmak invocation), mirroring the
+// "empty-provider-resources" fixture used elsewhere in this package.
+const fakeSchema = {
+    providerSchema: {
+        format_version: "0.2",
+        provider_schemas: {
+            "registry.terraform.io/hashicorp/random": {
+                resource_schemas: null,
+                data_source_schemas: null,
+            },
+        },
+        provider_versions: {
+            "registry.terraform.io/hashicorp/random": "3.1.3",
+        },
+        cli_name: "terraform",
+        cli_version: "1.7.5",
+    },
+};
+describe("targetVersions threading through 'cdktn get'", () => {
+    beforeEach(() => {
+        mockReadSchema.mockReset();
+        mockReadSchema.mockResolvedValue(fakeSchema);
+    });
+    it("passes GetOptions.targetVersions through to readSchema", async () => {
+        const workdir = tmp("target-versions-thread.test");
+        const targetVersions = { terraform: ">=1.5.7" };
+        const options = {
+            codeMakerOutput: workdir,
+            targetLanguage: commons_1.Language.TYPESCRIPT,
+            targetVersions,
+        };
+        const maker = new constructs_maker_1.ConstructsMaker(options, "/some/cache/path");
+        await maker.generate([constraint]);
+        expect(mockReadSchema).toHaveBeenCalledWith([constraint], "/some/cache/path", targetVersions);
+    });
+    it("omits targetVersions from the readSchema call when not configured", async () => {
+        const workdir = tmp("target-versions-absent.test");
+        const options = {
+            codeMakerOutput: workdir,
+            targetLanguage: commons_1.Language.TYPESCRIPT,
+        };
+        const maker = new constructs_maker_1.ConstructsMaker(options);
+        await maker.generate([constraint]);
+        expect(mockReadSchema).toHaveBeenCalledWith([constraint], undefined, undefined);
+    });
+    it("stamps constraints.json with targetVersions + cli identity, and older constraints.json files without those fields are still treated as fresh (no forced regeneration)", async () => {
+        const workdir = tmp("target-versions-stamp.test");
+        const targetVersions = { terraform: ">=1.5.7" };
+        const options = {
+            codeMakerOutput: workdir,
+            targetLanguage: commons_1.Language.TYPESCRIPT,
+            targetVersions,
+        };
+        const maker = new constructs_maker_1.ConstructsMaker(options);
+        await maker.generate([constraint]);
+        const constraintsFile = JSON.parse(await fs.readFile(path.join(workdir, "constraints.json"), "utf8"));
+        expect(constraintsFile.targetVersions).toEqual(targetVersions);
+        expect(constraintsFile.cli).toEqual({
+            name: "terraform",
+            version: "1.7.5",
+        });
+        // Rewrite constraints.json as it would have looked before this feature
+        // landed (no targetVersions/cli fields), keeping the rest identical -
+        // this simulates re-running `cdktn get` against an output directory
+        // generated by an older cdktn version.
+        const { targetVersions: _tv, cli: _cli, ...legacyConstraints } = constraintsFile;
+        await fs.writeFile(path.join(workdir, "constraints.json"), JSON.stringify(legacyConstraints, null, 2));
+        const maker2 = new constructs_maker_1.ConstructsMaker(options);
+        const toGenerate = await maker2.filterAlreadyGenerated([constraint]);
+        expect(toGenerate).toEqual([]);
+    });
+    it("threads a partial targetVersions (single product) through unchanged and stamps it verbatim", async () => {
+        const workdir = tmp("target-versions-partial.test");
+        const targetVersions = { opentofu: ">=1.11.0" };
+        const options = {
+            codeMakerOutput: workdir,
+            targetLanguage: commons_1.Language.TYPESCRIPT,
+            targetVersions,
+        };
+        const maker = new constructs_maker_1.ConstructsMaker(options);
+        await maker.generate([constraint]);
+        expect(mockReadSchema).toHaveBeenCalledWith([constraint], undefined, targetVersions);
+        // The stamp records exactly what the project declared - no terraform
+        // default is injected at get-time (defaulting for the undeclared
+        // product happens only at synth-time, in resolveTargetVersions).
+        const constraintsFile = JSON.parse(await fs.readFile(path.join(workdir, "constraints.json"), "utf8"));
+        expect(constraintsFile.targetVersions).toEqual({ opentofu: ">=1.11.0" });
+    });
+    it("omits the cli stamp when the fetched schema carries no CLI version metadata", async () => {
+        const workdir = tmp("target-versions-no-cli.test");
+        const { cli_name: _cliName, cli_version: _cliVersion, ...schemaWithoutCli } = fakeSchema.providerSchema;
+        mockReadSchema.mockResolvedValue({ providerSchema: schemaWithoutCli });
+        const targetVersions = { terraform: ">=1.5.7" };
+        const options = {
+            codeMakerOutput: workdir,
+            targetLanguage: commons_1.Language.TYPESCRIPT,
+            targetVersions,
+        };
+        const maker = new constructs_maker_1.ConstructsMaker(options);
+        await maker.generate([constraint]);
+        const constraintsFile = JSON.parse(await fs.readFile(path.join(workdir, "constraints.json"), "utf8"));
+        expect(constraintsFile.cli).toBeUndefined();
+        expect(constraintsFile.targetVersions).toEqual(targetVersions);
+    });
+    it("does not force regeneration when targetVersions change between runs", async () => {
+        // The stamp is diagnostic-only: per the GetOptions.targetVersions doc,
+        // targetVersions never filters codegen (the full schema surface is
+        // always generated), so freshness only compares the providers map and
+        // the cdktf version.
+        const workdir = tmp("target-versions-change.test");
+        const options = {
+            codeMakerOutput: workdir,
+            targetLanguage: commons_1.Language.TYPESCRIPT,
+            targetVersions: { terraform: ">=1.5.7" },
+        };
+        const maker = new constructs_maker_1.ConstructsMaker(options);
+        await maker.generate([constraint]);
+        const maker2 = new constructs_maker_1.ConstructsMaker({
+            ...options,
+            targetVersions: { terraform: ">=1.11.0" },
+        });
+        const toGenerate = await maker2.filterAlreadyGenerated([constraint]);
+        expect(toGenerate).toEqual([]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"target-versions.test.js","sourceRoot":"","sources":["../../../src/get/__tests__/target-versions.test.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport * as fs from \"fs-extra\";\nimport * as path from \"path\";\nimport {\n  Language,\n  TerraformDependencyConstraint,\n  TerraformTargetVersions,\n} from \"@cdktn/commons\";\nimport { createTmpHelper } from \"./util\";\n\nconst mockReadSchema = jest.fn();\njest.mock(\"@cdktn/provider-schema\", () => ({\n  readSchema: (...args: unknown[]) => mockReadSchema(...args),\n}));\n\n// Imported after the mock so ConstructsMaker picks up the mocked readSchema.\nimport { ConstructsMaker, GetOptions } from \"../constructs-maker\";\n\nconst tmp = createTmpHelper();\n\nconst constraint: TerraformDependencyConstraint = {\n  fqn: \"hashicorp/random\",\n  name: \"random\",\n  source: \"hashicorp/random\",\n  version: \"3.1.3\",\n};\n\n// Minimal schema - no resources/data sources - so generation stays within\n// pure TypeScript emission (no jsii-pacmak invocation), mirroring the\n// \"empty-provider-resources\" fixture used elsewhere in this package.\nconst fakeSchema = {\n  providerSchema: {\n    format_version: \"0.2\" as const,\n    provider_schemas: {\n      \"registry.terraform.io/hashicorp/random\": {\n        resource_schemas: null,\n        data_source_schemas: null,\n      },\n    },\n    provider_versions: {\n      \"registry.terraform.io/hashicorp/random\": \"3.1.3\",\n    },\n    cli_name: \"terraform\",\n    cli_version: \"1.7.5\",\n  },\n};\n\ndescribe(\"targetVersions threading through 'cdktn get'\", () => {\n  beforeEach(() => {\n    mockReadSchema.mockReset();\n    mockReadSchema.mockResolvedValue(fakeSchema);\n  });\n\n  it(\"passes GetOptions.targetVersions through to readSchema\", async () => {\n    const workdir = tmp(\"target-versions-thread.test\");\n    const targetVersions: TerraformTargetVersions = { terraform: \">=1.5.7\" };\n    const options: GetOptions = {\n      codeMakerOutput: workdir,\n      targetLanguage: Language.TYPESCRIPT,\n      targetVersions,\n    };\n\n    const maker = new ConstructsMaker(options, \"/some/cache/path\");\n    await maker.generate([constraint]);\n\n    expect(mockReadSchema).toHaveBeenCalledWith(\n      [constraint],\n      \"/some/cache/path\",\n      targetVersions,\n    );\n  });\n\n  it(\"omits targetVersions from the readSchema call when not configured\", async () => {\n    const workdir = tmp(\"target-versions-absent.test\");\n    const options: GetOptions = {\n      codeMakerOutput: workdir,\n      targetLanguage: Language.TYPESCRIPT,\n    };\n\n    const maker = new ConstructsMaker(options);\n    await maker.generate([constraint]);\n\n    expect(mockReadSchema).toHaveBeenCalledWith(\n      [constraint],\n      undefined,\n      undefined,\n    );\n  });\n\n  it(\"stamps constraints.json with targetVersions + cli identity, and older constraints.json files without those fields are still treated as fresh (no forced regeneration)\", async () => {\n    const workdir = tmp(\"target-versions-stamp.test\");\n    const targetVersions: TerraformTargetVersions = { terraform: \">=1.5.7\" };\n    const options: GetOptions = {\n      codeMakerOutput: workdir,\n      targetLanguage: Language.TYPESCRIPT,\n      targetVersions,\n    };\n\n    const maker = new ConstructsMaker(options);\n    await maker.generate([constraint]);\n\n    const constraintsFile = JSON.parse(\n      await fs.readFile(path.join(workdir, \"constraints.json\"), \"utf8\"),\n    );\n    expect(constraintsFile.targetVersions).toEqual(targetVersions);\n    expect(constraintsFile.cli).toEqual({\n      name: \"terraform\",\n      version: \"1.7.5\",\n    });\n\n    // Rewrite constraints.json as it would have looked before this feature\n    // landed (no targetVersions/cli fields), keeping the rest identical -\n    // this simulates re-running `cdktn get` against an output directory\n    // generated by an older cdktn version.\n    const {\n      targetVersions: _tv,\n      cli: _cli,\n      ...legacyConstraints\n    } = constraintsFile;\n    await fs.writeFile(\n      path.join(workdir, \"constraints.json\"),\n      JSON.stringify(legacyConstraints, null, 2),\n    );\n\n    const maker2 = new ConstructsMaker(options);\n    const toGenerate = await maker2.filterAlreadyGenerated([constraint]);\n    expect(toGenerate).toEqual([]);\n  });\n\n  it(\"threads a partial targetVersions (single product) through unchanged and stamps it verbatim\", async () => {\n    const workdir = tmp(\"target-versions-partial.test\");\n    const targetVersions: TerraformTargetVersions = { opentofu: \">=1.11.0\" };\n    const options: GetOptions = {\n      codeMakerOutput: workdir,\n      targetLanguage: Language.TYPESCRIPT,\n      targetVersions,\n    };\n\n    const maker = new ConstructsMaker(options);\n    await maker.generate([constraint]);\n\n    expect(mockReadSchema).toHaveBeenCalledWith(\n      [constraint],\n      undefined,\n      targetVersions,\n    );\n\n    // The stamp records exactly what the project declared - no terraform\n    // default is injected at get-time (defaulting for the undeclared\n    // product happens only at synth-time, in resolveTargetVersions).\n    const constraintsFile = JSON.parse(\n      await fs.readFile(path.join(workdir, \"constraints.json\"), \"utf8\"),\n    );\n    expect(constraintsFile.targetVersions).toEqual({ opentofu: \">=1.11.0\" });\n  });\n\n  it(\"omits the cli stamp when the fetched schema carries no CLI version metadata\", async () => {\n    const workdir = tmp(\"target-versions-no-cli.test\");\n    const {\n      cli_name: _cliName,\n      cli_version: _cliVersion,\n      ...schemaWithoutCli\n    } = fakeSchema.providerSchema;\n    mockReadSchema.mockResolvedValue({ providerSchema: schemaWithoutCli });\n\n    const targetVersions: TerraformTargetVersions = { terraform: \">=1.5.7\" };\n    const options: GetOptions = {\n      codeMakerOutput: workdir,\n      targetLanguage: Language.TYPESCRIPT,\n      targetVersions,\n    };\n\n    const maker = new ConstructsMaker(options);\n    await maker.generate([constraint]);\n\n    const constraintsFile = JSON.parse(\n      await fs.readFile(path.join(workdir, \"constraints.json\"), \"utf8\"),\n    );\n    expect(constraintsFile.cli).toBeUndefined();\n    expect(constraintsFile.targetVersions).toEqual(targetVersions);\n  });\n\n  it(\"does not force regeneration when targetVersions change between runs\", async () => {\n    // The stamp is diagnostic-only: per the GetOptions.targetVersions doc,\n    // targetVersions never filters codegen (the full schema surface is\n    // always generated), so freshness only compares the providers map and\n    // the cdktf version.\n    const workdir = tmp(\"target-versions-change.test\");\n    const options: GetOptions = {\n      codeMakerOutput: workdir,\n      targetLanguage: Language.TYPESCRIPT,\n      targetVersions: { terraform: \">=1.5.7\" },\n    };\n\n    const maker = new ConstructsMaker(options);\n    await maker.generate([constraint]);\n\n    const maker2 = new ConstructsMaker({\n      ...options,\n      targetVersions: { terraform: \">=1.11.0\" },\n    });\n    const toGenerate = await maker2.filterAlreadyGenerated([constraint]);\n    expect(toGenerate).toEqual([]);\n  });\n});\n"]}

package/build/get/constructs-maker.d.ts

@@ -1,5 +1,5 @@
 import { CodeMaker } from "codemaker";
-import { TerraformDependencyConstraint, type LanguageOptions } from "@cdktn/commons";
+import { TerraformDependencyConstraint, type LanguageOptions, type TerraformTargetVersions } from "@cdktn/commons";
 import { Language } from "@cdktn/commons";
 export interface GenerateJSIIOptions {
     entrypoint: string;
@@ -55,6 +55,13 @@ export interface GetOptions {
      * Language-specific code generation options.
      */
     readonly languageOptions?: LanguageOptions;
+    /**
+     * The project's declared targetVersions (cdktf.json). Used to drive the
+     * fetch-time emission-gap warning in @cdktn/provider-schema and to stamp
+     * the generated constraints.json for diagnostics. Does NOT filter codegen:
+     * the full surface is always generated, narrowing happens at synth.
+     */
+    readonly targetVersions?: TerraformTargetVersions;
 }
 export declare class ConstructsMaker {
     private readonly options;