@cdktn/provider-generator 0.24.0-pre.9 → 0.24.0-pre.90

package/src/get/__tests__/generator/provider-functions.test.ts

@@ -0,0 +1,262 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import {
+  assertNoFunctionsGetterCollision,
+  buildProviderFunctionsModel,
+} from "../../generator/models/provider-function-model";
+import { CodeMaker } from "codemaker";
+import { FunctionSignature } from "@cdktn/commons";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("generate provider functions for the time provider (real terraform 1.15.6 schema fragment)", async () => {
+  const code = new 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 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: string;
+  let providerIndex: string;
+  let providerLazyIndex: string;
+
+  beforeAll(async () => {
+    const code = new 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 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(() =>
+    buildProviderFunctionsModel("example", {
+      foo_bar: { return_type: "string", parameters: [] },
+      foo__bar: { return_type: "string", parameters: [] },
+    }),
+  ).toThrow(/foo_bar/);
+  expect(() =>
+    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(() =>
+    buildProviderFunctionsModel("example", {
+      my_function: {
+        return_type: "string",
+        parameters: [
+          { name: "some_value", type: "string" },
+          { name: "some__value", type: "string" },
+        ],
+      },
+    }),
+  ).toThrow(/some_value/);
+  expect(() =>
+    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: FunctionSignature = {
+    return_type: "string",
+    parameters: [],
+  };
+  expect(() =>
+    buildProviderFunctionsModel("example", {
+      constructor: signature,
+    }),
+  ).toThrow(/constructor/);
+  expect(() =>
+    buildProviderFunctionsModel("example", {
+      constructor: signature,
+    }),
+  ).toThrow(/example/);
+});
+
+test("buildProviderFunctionsModel throws when a function name sanitizes to 'providerLocalName'", () => {
+  expect(() =>
+    buildProviderFunctionsModel("example", {
+      provider_local_name: { return_type: "string", parameters: [] },
+    }),
+  ).toThrow(/provider_local_name/);
+  expect(() =>
+    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(() =>
+    assertNoFunctionsGetterCollision("example", ["alias", "functions"]),
+  ).toThrow(/"functions"/);
+});
+
+test("assertNoFunctionsGetterCollision does not throw when there is no colliding attribute", () => {
+  expect(() =>
+    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();
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "provider-functions-collision.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  expect(() =>
+    new TerraformProviderGenerator(code, spec).generateAll(),
+  ).toThrow(/"functions"/);
+});

package/src/get/__tests__/generator/provider-source-matching.test.ts

@@ -0,0 +1,84 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import {
+  ConstructsMakerProviderTarget,
+  Language,
+  ProviderSchema,
+  TerraformProviderConstraint,
+} from "@cdktn/commons";
+import { CodeMaker } from "codemaker";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+
+// Builds a minimal provider schema keyed by a single FQPN. The provider body is
+// intentionally empty (like the empty-provider-resources fixture) since these
+// tests only exercise the schema-key <-> target-source matching logic.
+const schemaWithKey = (fqpn: string): ProviderSchema => ({
+  provider_schemas: {
+    [fqpn]: { resource_schemas: null } as any,
+  },
+  provider_versions: {
+    [fqpn]: "1.84.0",
+  },
+});
+
+const targetForSource = (source: string) =>
+  new ConstructsMakerProviderTarget(
+    new TerraformProviderConstraint(`${source}@1.84.0`),
+    Language.TYPESCRIPT,
+  );
+
+const generateFor = (schemaKey: string, source: string) => {
+  const generator = new TerraformProviderGenerator(
+    new CodeMaker(),
+    schemaWithKey(schemaKey),
+  );
+  generator.generate(targetForSource(source));
+  return generator;
+};
+
+describe("provider source matching against schema keys", () => {
+  it("matches a shorthand source against an OpenTofu registry schema key", () => {
+    // Regression test for #216: `tofu providers schema` returns keys under
+    // registry.opentofu.org, so a shorthand source must not assume
+    // registry.terraform.io.
+    const generator = generateFor(
+      "registry.opentofu.org/hashicorp/awscc",
+      "hashicorp/awscc",
+    );
+
+    expect(Object.keys(generator.versions)).toContain(
+      "registry.opentofu.org/hashicorp/awscc",
+    );
+  });
+
+  it("matches a shorthand source against a Terraform registry schema key", () => {
+    const generator = generateFor(
+      "registry.terraform.io/hashicorp/awscc",
+      "hashicorp/awscc",
+    );
+
+    expect(Object.keys(generator.versions)).toContain(
+      "registry.terraform.io/hashicorp/awscc",
+    );
+  });
+
+  it("keeps an explicit hostname strict and does not cross registries", () => {
+    expect(() =>
+      generateFor(
+        "registry.opentofu.org/hashicorp/awscc",
+        "registry.terraform.io/hashicorp/awscc",
+      ),
+    ).toThrow(/Could not find provider with constraint/);
+  });
+
+  it("matches an explicit hostname when it agrees with the schema key", () => {
+    const generator = generateFor(
+      "registry.opentofu.org/hashicorp/awscc",
+      "registry.opentofu.org/hashicorp/awscc",
+    );
+
+    expect(Object.keys(generator.versions)).toContain(
+      "registry.opentofu.org/hashicorp/awscc",
+    );
+  });
+});

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

@@ -0,0 +1,59 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { CodeMaker } from "codemaker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("generate provider", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("provider.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "aws-provider.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  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();
+  const workdir = tmp("provider.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "elasticstack-provider.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  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");
+});

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

@@ -0,0 +1,118 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { CodeMaker } from "codemaker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("generate a cloudfront distribution resource", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("cloudfront.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "aws_cloudfront_distribution.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/cloudfront-distribution/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot("cloudfront");
+});
+
+test("generate a s3 bucket resource", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("s3.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "aws_s3_bucket.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/s3-bucket/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("generate a fms admin account with an empty options interface", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("fms.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "aws_fms_admin_account.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/fms-admin-account/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("generate a security group", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("sg.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "aws_security_group.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/security-group/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+});
+
+test("generate a datadog spans metric", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("sg.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "datadog_spans_metric.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/datadog/spans-metric/index.ts"),
+    "utf-8",
+  );
+
+  expect(output).toMatchSnapshot();
+});

package/src/get/__tests__/generator/skipped-attributes.test.ts

@@ -0,0 +1,72 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { CodeMaker } from "codemaker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("skips block type attributes in the disallow list", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("skip-attributes.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "aws_quicksight_template.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/quicksight-template/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot(`quicksight-template`);
+
+  // There should also be no index structs
+  expect(
+    fs.existsSync(
+      path.join(workdir, "providers/aws/quicksight-template/index-structs"),
+    ),
+  ).toBe(false);
+});
+
+test("skips attribute type attributes in the disallow list", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("skip-attributes.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "data_aws_quicksight_analysis.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/aws/data-aws-quicksight-analysis/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot(`data-quicksight-analysis`);
+
+  // There should also be no index structs
+  expect(
+    fs.existsSync(
+      path.join(
+        workdir,
+        "providers/aws/data-aws-quicksight-analysis/index-structs",
+      ),
+    ),
+  ).toBe(false);
+});