@cdktn/provider-generator 0.24.0-pre.5 → 0.24.0-pre.51

package/src/__tests__/edge-provider-schema/builder.ts

@@ -0,0 +1,185 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { ProviderSchema, Schema, AttributeType, Block } from "@cdktn/commons";
+
+type ResourceSchema = { [type: string]: Schema };
+export function schema({
+  name,
+  provider,
+  resources = {},
+  dataSources = {},
+}: {
+  name: string;
+  provider: Schema;
+  resources: ResourceSchema;
+  dataSources: ResourceSchema;
+}): ProviderSchema {
+  return {
+    format_version: "0.2",
+    provider_schemas: {
+      [`registry.terraform.io/cdktf/${name}`]: {
+        provider: provider,
+        resource_schemas: resources,
+        data_source_schemas: dataSources,
+      },
+    },
+  };
+}
+
+export class SchemaBuilder {
+  private schema: Schema;
+
+  constructor() {
+    this.schema = {
+      version: 0,
+      block: {
+        attributes: {},
+        block_types: {},
+      },
+    };
+  }
+
+  public attribute({
+    name,
+    type,
+    required = false,
+    computed = false,
+    optional = !required,
+  }: {
+    name: string;
+    type: AttributeType;
+    required?: boolean;
+    computed?: boolean;
+    optional?: boolean;
+  }): SchemaBuilder {
+    this.schema.block.attributes[name] = {
+      type,
+      optional,
+      computed,
+      required,
+    };
+    return this;
+  }
+
+  public listBlock({
+    name,
+    block,
+    minItems,
+    maxItems,
+  }: {
+    name: string;
+    block: Block;
+    minItems: number;
+    maxItems: number;
+  }): SchemaBuilder {
+    this.schema.block.block_types[name] = {
+      nesting_mode: "list",
+      block,
+      min_items: minItems,
+      max_items: maxItems,
+    };
+    return this;
+  }
+
+  public mapBlock({
+    name,
+    block,
+  }: {
+    name: string;
+    block: Block;
+  }): SchemaBuilder {
+    this.schema.block.block_types[name] = { nesting_mode: "map", block };
+    return this;
+  }
+
+  public setBlock({
+    name,
+    block,
+  }: {
+    name: string;
+    block: Block;
+  }): SchemaBuilder {
+    this.schema.block.block_types[name] = { nesting_mode: "set", block };
+    return this;
+  }
+  public singleBlock({
+    name,
+    block,
+  }: {
+    name: string;
+    block: Block;
+  }): SchemaBuilder {
+    this.schema.block.block_types[name] = { nesting_mode: "single", block };
+    return this;
+  }
+
+  public build(): Schema {
+    return this.schema;
+  }
+
+  public asBlock(): Block {
+    return this.schema.block;
+  }
+
+  public addAllPrimitiveTypes({
+    required,
+    computed,
+    prefix = "",
+  }: {
+    required: boolean;
+    computed: boolean;
+    prefix?: string;
+  }): SchemaBuilder {
+    this.attribute({ name: prefix + "str", type: "string", required, computed })
+      .attribute({ name: prefix + "num", type: "number", required, computed })
+      .attribute({ name: prefix + "bool", type: "bool", required, computed });
+
+    return this;
+  }
+
+  public addAllPrimitivePermutations(): SchemaBuilder {
+    this.addAllPrimitiveTypes({
+      required: false,
+      computed: false,
+      prefix: "opt",
+    })
+      .addAllPrimitiveTypes({ required: true, computed: false, prefix: "req" })
+      .addAllPrimitiveTypes({
+        required: false,
+        computed: true,
+        prefix: "computed",
+      });
+    return this;
+  }
+
+  public addAllPrimitiveListTypes({
+    required,
+    computed,
+    prefix = "",
+  }: {
+    required: boolean;
+    computed: boolean;
+    prefix?: string;
+  }): SchemaBuilder {
+    this.attribute({
+      name: prefix + "strList",
+      type: ["list", "string"],
+      required,
+      computed,
+    })
+      .attribute({
+        name: prefix + "numList",
+        type: ["list", "number"],
+        required,
+        computed,
+      })
+      .attribute({
+        name: prefix + "boolList",
+        type: ["list", "bool"],
+        required,
+        computed,
+      });
+
+    return this;
+  }
+}

package/src/__tests__/edge-provider-schema/cli.ts

@@ -0,0 +1,51 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as path from "path";
+import * as fs from "fs-extra";
+import { edgeSchema } from ".";
+import { generateProviderBindingsFromSchema } from "../..";
+
+// This script builds the schema for the edge provider into the given directory for all languages.
+const args = process.argv.slice(2);
+const targetPath = args[0];
+
+if (!targetPath) {
+  console.error("No target path specified");
+  process.exit(1);
+}
+
+// Clear / Create path
+fs.mkdirpSync(targetPath);
+fs.emptyDirSync(targetPath);
+
+// Static require.resolve calls so knip / pnpm strict isolation can see the deps.
+const deps = [
+  path.dirname(require.resolve("@types/node/package.json")),
+  path.dirname(require.resolve("constructs/package.json")),
+  path.dirname(require.resolve("cdktn/package.json")),
+];
+
+(async () => {
+  await generateProviderBindingsFromSchema(targetPath, edgeSchema, {
+    entrypoint: path.join("providers", "edge", "index.ts"),
+    deps,
+    moduleKey: "edge",
+    python: {
+      outdir: path.resolve(targetPath, "python"),
+      moduleName: "edge",
+    },
+    java: {
+      outdir: path.resolve(targetPath, "java"),
+      package: `imports.edgeprovider`,
+    },
+    csharp: {
+      outdir: path.resolve(targetPath, "csharp"),
+      namespace: "Providers.Edge",
+    },
+    golang: {
+      outdir: path.resolve(targetPath, "go"),
+      moduleName: "cdk.tf/go/stack/generated/hashicorp",
+      packageName: "edge",
+    },
+  });
+})();

package/src/__tests__/edge-provider-schema/index.ts

@@ -0,0 +1,161 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { ProviderSchema } from "@cdktn/commons";
+import { schema, SchemaBuilder as S } from "./builder";
+
+const required_attribute_resource = new S()
+  .addAllPrimitiveTypes({ required: true, computed: false })
+  .addAllPrimitiveListTypes({ required: true, computed: false })
+  .build();
+
+const optional_attribute_resource = new S()
+  .addAllPrimitiveTypes({ required: false, computed: false })
+  .addAllPrimitiveListTypes({ required: false, computed: false })
+  .build();
+
+const optional_computed_attribute_resource = new S()
+  .addAllPrimitiveTypes({ required: false, computed: true })
+  .addAllPrimitiveListTypes({ required: false, computed: true })
+  .build();
+
+const list_block_resource = new S()
+  .listBlock({
+    name: "opt",
+    block: new S().addAllPrimitivePermutations().asBlock(),
+    minItems: 0,
+    maxItems: 42,
+  })
+  .listBlock({
+    name: "req",
+    block: new S().addAllPrimitivePermutations().asBlock(),
+    minItems: 1,
+    maxItems: 42,
+  })
+  .listBlock({
+    name: "singleopt",
+    block: new S().addAllPrimitivePermutations().asBlock(),
+    minItems: 0,
+    maxItems: 1,
+  })
+  .listBlock({
+    name: "singlereq",
+    block: new S().addAllPrimitivePermutations().asBlock(),
+    minItems: 1,
+    maxItems: 1,
+  })
+  .listBlock({
+    name: "singleComputedBlock",
+    block: new S()
+      .attribute({
+        computed: true,
+        name: "computed",
+        type: "string",
+        required: false,
+        optional: false,
+      })
+      .attribute({
+        computed: false,
+        name: "configured",
+        type: "string",
+        required: false,
+      })
+      .asBlock(),
+    minItems: 0,
+    maxItems: 1,
+  })
+  .attribute({
+    name: "computedListOfObject",
+    type: [
+      "list",
+      [
+        "object",
+        {
+          str: "string",
+        },
+      ],
+    ],
+    computed: true,
+    optional: false,
+  })
+  .attribute({
+    name: "computedListOfMapOfObject",
+    type: [
+      "list",
+      [
+        "map",
+        [
+          "object",
+          {
+            str: "string",
+            other: "string",
+          },
+        ],
+      ],
+    ],
+    computed: true,
+    optional: false,
+  })
+  .build();
+
+const map_list_resource = new S()
+  .attribute({
+    name: "mapListOfObject",
+    type: [
+      "map",
+      [
+        "list",
+        [
+          "object",
+          {
+            hello: "string",
+          },
+        ],
+      ],
+    ],
+    computed: false,
+    optional: false,
+  })
+  .build();
+
+const map_resource = new S()
+  .attribute({
+    name: "optMap",
+    type: ["map", "string"],
+    required: false,
+    computed: false,
+  })
+  .attribute({
+    name: "reqMap",
+    type: ["map", "bool"],
+    required: true,
+    computed: false,
+  })
+  .attribute({
+    name: "computedMap",
+    type: ["map", "number"],
+    required: false,
+    computed: true,
+  })
+  .build();
+
+const set_block_resource = new S()
+  .setBlock({
+    name: "set",
+    block: new S().addAllPrimitivePermutations().asBlock(),
+  })
+  .build();
+
+export const edgeSchema: ProviderSchema = schema({
+  name: "edge",
+  provider: new S().addAllPrimitivePermutations().build(),
+  resources: {
+    required_attribute_resource,
+    optional_attribute_resource,
+    optional_computed_attribute_resource,
+    list_block_resource,
+    map_resource,
+    set_block_resource,
+    map_list_resource,
+  },
+  dataSources: {},
+});

package/src/__tests__/edge-provider-schema.test.ts

@@ -0,0 +1,24 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs-extra";
+import * as path from "path";
+import { generateProviderBindingsFromSchema } from "..";
+import { mkdtemp } from "@cdktn/commons";
+import { edgeSchema } from "./edge-provider-schema";
+
+describe("Edge Provider Schema", () => {
+  it("compiles to Typescript", async () => {
+    return mkdtemp(async (dir) => {
+      await generateProviderBindingsFromSchema(dir, edgeSchema);
+
+      fs.readdirSync(path.join(dir, "providers", "edge")).forEach((file) => {
+        if (!file.endsWith(".ts")) {
+          return;
+        }
+        expect(
+          fs.readFileSync(path.join(dir, "providers", "edge", file), "utf8"),
+        ).toMatchSnapshot(file);
+      });
+    });
+  });
+});

package/src/__tests__/provider.test.ts

@@ -0,0 +1,180 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as path from "path";
+import * as fs from "fs-extra";
+import { glob } from "glob";
+import { mkdtemp } from "@cdktn/commons";
+import { ConstructsMaker } from "../get/constructs-maker";
+import { Language, TerraformProviderConstraint } from "@cdktn/commons";
+
+interface SynthOutput {
+  [filePath: string]: any;
+}
+
+function directorySnapshot(root: string) {
+  const output: SynthOutput = {};
+
+  const files = glob.sync("**", {
+    ignore: [".git/**", ".jsii"],
+    cwd: root,
+    nodir: true,
+    dot: true,
+  });
+
+  for (const file of files) {
+    const filePath = path.join(root, file);
+
+    let content;
+
+    if (path.extname(filePath) === ".json") {
+      content = fs.readJsonSync(filePath);
+
+      if (path.basename(filePath) === "constraints.json") {
+        delete content.cdktf;
+      }
+    } else {
+      content = fs.readFileSync(filePath, "utf-8");
+    }
+
+    output[file] = content;
+  }
+
+  return output;
+}
+
+function resourceTypesPresentInSnapshot(
+  snapshot: SynthOutput,
+  providerNameInPath: string,
+) {
+  const resources: string[] = [];
+  const files = Object.keys(snapshot);
+  for (const file of files) {
+    const match = file.match(
+      `/providers/${providerNameInPath}/(.*?)/index.ts/`,
+    );
+    // avoids any not resources from being pushed
+    if (
+      match &&
+      !match[1].includes("/") &&
+      !match[1].includes("data-") &&
+      !match[1].includes("provider")
+    ) {
+      resources.push(match[1]);
+    }
+  }
+  return resources;
+}
+
+describe("Provider", () => {
+  it("generates a provider", async () => {
+    const constraint = new TerraformProviderConstraint(
+      "DataDog/datadog@= 3.12.0",
+    );
+    return await mkdtemp(async (workdir) => {
+      const jsiiPath = path.join(workdir, ".jsii");
+      const maker = new ConstructsMaker(
+        {
+          codeMakerOutput: workdir,
+          outputJsii: jsiiPath,
+          targetLanguage: Language.TYPESCRIPT,
+        },
+        process.env.CDKTF_EXPERIMENTAL_PROVIDER_SCHEMA_CACHE_PATH,
+      );
+      await maker.generate([constraint]);
+      const snapshot = directorySnapshot(workdir);
+      expect(snapshot).toMatchSnapshot();
+    });
+  }, 600_000);
+
+  it("has generated provider that includes static import functions", async () => {
+    const constraint = new TerraformProviderConstraint(
+      "DataDog/datadog@= 3.12.0",
+    );
+    return await mkdtemp(async (workdir) => {
+      const jsiiPath = path.join(workdir, ".jsii");
+      const maker = new ConstructsMaker({
+        codeMakerOutput: workdir,
+        outputJsii: jsiiPath,
+        targetLanguage: Language.TYPESCRIPT,
+      });
+      await maker.generate([constraint]);
+      const snapshot = directorySnapshot(workdir);
+
+      const terraformResourceTypesPresent: string[] =
+        resourceTypesPresentInSnapshot(snapshot, "datadog");
+
+      terraformResourceTypesPresent.forEach((resource) => {
+        let terraformResourceType = resource.replace(/-/g, "_");
+        if (!terraformResourceType.includes("datadog")) {
+          terraformResourceType = `datadog_${terraformResourceType}`;
+        }
+        expect(snapshot[`providers/datadog/${resource}/index.ts`]).toContain(
+          `public static generateConfigForImport(scope: Construct, importToId: string, importFromId: string, provider?: cdktn.TerraformProvider) {`,
+        );
+        expect(snapshot[`providers/datadog/${resource}/index.ts`]).toContain(
+          `return new cdktn.ImportableResource(scope, importToId, { terraformResourceType: "${terraformResourceType}", importId: importFromId, provider });`,
+        );
+      });
+    });
+  }, 600_000);
+
+  it("has name in constraint that does not match resolved name in fqpn", async () => {
+    const constraint = new TerraformProviderConstraint({
+      name: "dockerr",
+      source: "registry.terraform.io/kreuzwerker/docker",
+      version: "3.0.2",
+    });
+    return await mkdtemp(async (workdir) => {
+      const jsiiPath = path.join(workdir, ".jsii");
+      const maker = new ConstructsMaker(
+        {
+          codeMakerOutput: workdir,
+          outputJsii: jsiiPath,
+          targetLanguage: Language.TYPESCRIPT,
+        },
+        process.env.CDKTF_EXPERIMENTAL_PROVIDER_SCHEMA_CACHE_PATH,
+      );
+      await maker.generate([constraint]);
+      const snapshot = directorySnapshot(workdir);
+
+      const terraformResourceTypesPresent: string[] =
+        resourceTypesPresentInSnapshot(snapshot, "dockerr");
+
+      terraformResourceTypesPresent.forEach((resource) => {
+        expect(
+          snapshot[`providers/dockerr/${resource}/index.ts`],
+        ).toBeDefined();
+      });
+    });
+  }, 600_000);
+
+  it("generates constructs for two providers with same name", async () => {
+    const constraint = new TerraformProviderConstraint({
+      name: "bitbucket",
+      namespace: "DrFaust92",
+      version: "2.51.0",
+      source: "DrFaust92/bitbucket",
+    });
+    const constraint2 = new TerraformProviderConstraint({
+      name: "abitbucket",
+      namespace: "andsafe-AG",
+      version: "2.5.0",
+      source: "andsafe-AG/bitbucket",
+    });
+    return await mkdtemp(async (workdir) => {
+      const jsiiPath = path.join(workdir, ".jsii");
+      const maker = new ConstructsMaker(
+        {
+          codeMakerOutput: workdir,
+          outputJsii: jsiiPath,
+          targetLanguage: Language.TYPESCRIPT,
+        },
+        process.env.CDKTF_EXPERIMENTAL_PROVIDER_SCHEMA_CACHE_PATH,
+      );
+      await maker.generate([constraint, constraint2]);
+      console.log("workdir", workdir);
+      const snapshot = directorySnapshot(workdir);
+      expect(snapshot).toMatchSnapshot();
+    });
+  }, 600_000);
+});