@cdktn/hcl2cdk 0.22.0-pre.2

package/README.md

@@ -0,0 +1,95 @@
+# @cdktn/hcl2cdk
+
+Uses `@cdktn/hcl2cdk` to transform HCL configuration to CDK constructs.
+
+## Usage
+
+```sh
+yarn add @cdktn/hcl2cdk
+```
+
+### Convert HCL strings to Constructs
+
+```ts
+import { convert } from "@cdktn/hcl2cdk";
+
+const hcl = `
+  variable "name" {
+    description = "Name to be used on all the resources as identifier"
+    type        = string
+    default     = ""
+  }
+`(async () => {
+  const ts = await convert(hcl, { language: "typescript" });
+  console.log(ts.imports); // just the necessary imports
+  console.log(ts.code); // just the constructs
+  console.log(ts.all); // code with imports
+})();
+
+// =>
+import * as cdktn from "cdktn";
+
+new cdktn.TerraformVariable(this, "imageId", {
+  type: "string",
+  default: "ami-abcde123",
+  description: "What AMI to use to create an instance",
+});
+```
+
+### Convert a project
+
+```ts
+import * as hcl2cdk from "@cdktn/hcl2cdk";
+import {
+  readSchema,
+  ConstructsMakerProviderTarget,
+  LANGUAGES,
+  config,
+} from "@cdktn/provider-generator";
+
+(async () => {
+  const hcl = hcl2cdk.getTerraformConfigFromDir("/path/to/terraform/project");
+  const providerRequirements = await hcl2cdk.parseProviderRequirements(hcl);
+  const targets = Object.entries(providerRequirements).map(([name, version]) =>
+    ConstructsMakerProviderTarget.from(
+      new config.TerraformProviderConstraint(`${name}@ ${version}`),
+      LANGUAGES[0],
+    ),
+  );
+  // Get all the provider schemas, making the conversion more precise
+  const { providerSchema } = await readSchema(targets);
+
+  const mainTs = await hcl2cdk.convert(hcl, {
+    language: "typescript",
+    providerSchema: providerSchema,
+  });
+
+  await hcl2cdk.convertProject(
+    hcl,
+    mainTs.code,
+    require("../cdktf.json"),
+    { language: "typescript", providerSchema }, // Currently we only support Typescript for project conversion
+  );
+})();
+```
+
+This transforms your Terraform project into a CDK Terrain project, besides the resource naming within Terraform the deployed resources should not differ between `terraform plan` and `cdktn plan`.
+
+## Known Limitations
+
+### Providers guessed can be not functional
+
+If your HCL includes providers that are not mentioned under `required_providers` we infer the name, e.g. if you use the `datadog_dashboard` resource we infer the provider `datadog` which is right, but the namespace is missing, for DataDog it would be `datadog/datadog`. Instead we will try to use `hashicorp/datadog` and fail because this provider is not known to the registry.
+Please see the [required providers docs](https://www.terraform.io/docs/language/providers/requirements.html#requiring-providers) for more information on how to specify providers.
+
+### Local Modules and Files
+
+We don't move modules or files for you, if you reference local modules you have to move them so that the relative paths are correct. If you want to make use of files you need to wrap them in a [`TerraformAsset`](../../docs/working-with-cdk-for-terraform/terraform-assets.md) before using them.
+
+### Development
+
+We have two types of test cases, one within `lib` that are on the unit level and one within `test` that are testing the entire package at once by converting and then synthesizing the resulting code.
+
+In general, both test types can be run by `npx jest <pathToTestCase>`. You can add `-u` to update the snapshots and `--watch` to run the tests in watch mode.
+
+To make the tests inside `test` faster we disable synthesizing and multi-language snapshots by default. You can enable them by setting the envinronment variable `CI=true`. Another way of improving the performance significantly is setting the `TF_PLUGIN_CACHE_DIR` to a valid directory in order to cache the provider binaries used within the tests. E.g. by running `TF_PLUGIN_CACHE_DIR=(mktemp -d) npx jest <pathToTestCase> --watch`.

package/ambient.d.ts

@@ -0,0 +1,14 @@
+// Copyright (c) HashiCorp, Inc
+// Licensed under the Mozilla Public License 2.0
+declare module '@skorfmann/ink-confirm-input';
+declare module '@npmcli/ci-detect';
+
+declare module 'child_process' {
+    interface SpawnOptions  {
+        signal?: AbortSignal;
+    }
+}
+
+declare module 'tunnel-agent';
+declare module 'deep-equal';
+declare module "archiver";

package/jest.config.js

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+module.exports = {
+  testMatch: ['**/*.test.ts', '**/*.test.tsx'],
+  "transform": {
+    "^.+\\.tsx?$": "ts-jest"
+  },
+  moduleFileExtensions: [
+    "js",
+    "ts",
+    "tsx"
+  ],
+}

package/lib/__tests__/coerceType.test.d.ts

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

package/lib/__tests__/coerceType.test.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const coerceType_1 = require("../coerceType");
+const template_1 = __importDefault(require("@babel/template"));
+const generator_1 = __importDefault(require("@babel/generator"));
+function expressionify(code) {
+    return template_1.default.ast(code).expression;
+}
+function generateCode(ast) {
+    return (0, generator_1.default)(ast).code;
+}
+const scope = {
+    importables: [],
+    variables: {
+        a_user_defined_variable: {
+            resource: "var",
+            variableName: "aUserDefinedVariable",
+        },
+        a_user_defined_local: {
+            resource: "var",
+            variableName: "aUserDefinedTerraformLocal",
+        },
+    },
+};
+describe("coerceType", () => {
+    it.each([
+        { code: `"hello-world"`, type: "string", targetType: undefined },
+        { code: `"hello-world"`, type: "string", targetType: "string" },
+    ])("should change nothing for %p ", ({ code, type, targetType }) => {
+        expect(generateCode((0, coerceType_1.coerceType)(scope, expressionify(code), type, targetType))).toEqual(code);
+    });
+    it.each([
+        {
+            code: `"300"`,
+            type: "string",
+            targetType: "number",
+            expectedCode: `Token.asNumber("300")`,
+        },
+        {
+            code: `300`,
+            type: "number",
+            targetType: "string",
+            expectedCode: `Token.asString(300)`,
+        },
+        {
+            code: `"['foo', 'bar']"`,
+            type: "string",
+            targetType: ["list", "string"],
+            expectedCode: `Token.asList("['foo', 'bar']")`,
+        },
+        {
+            code: `"[1,2,3]"`,
+            type: "string",
+            targetType: ["list", "number"],
+            expectedCode: `Token.asNumberList("[1,2,3]")`,
+        },
+        {
+            code: `"['foo', 'bar']"`,
+            type: "string",
+            targetType: ["set", "string"],
+            expectedCode: `Token.asList("['foo', 'bar']")`,
+        },
+        {
+            code: `"[1,2,3]"`,
+            type: "string",
+            targetType: ["set", "number"],
+            expectedCode: `Token.asNumberList("[1,2,3]")`,
+        },
+        // We don't have a token function for boolean lists, so we need to take an asAny
+        {
+            code: `"[true,false,true]"`,
+            type: "string",
+            targetType: ["list", "bool"],
+            expectedCode: `Token.asAny("[true,false,true]")`,
+        },
+        {
+            code: `"{ foo: 'bar' }"`,
+            type: "string",
+            targetType: ["map", "string"],
+            expectedCode: `Token.asStringMap("{ foo: 'bar' }")`,
+        },
+        {
+            code: `"{ foo: 1 }"`,
+            type: "string",
+            targetType: ["map", "number"],
+            expectedCode: `Token.asNumberMap("{ foo: 1 }")`,
+        },
+        {
+            code: `"{ foo: true }"`,
+            type: "string",
+            targetType: ["map", "bool"],
+            expectedCode: `Token.asBooleanMap("{ foo: true }")`,
+        },
+        {
+            code: `"{ foo: {bar: true} }"`,
+            type: "string",
+            targetType: ["map", ["map", "boolean"]],
+            expectedCode: `Token.asAnyMap("{ foo: {bar: true} }")`,
+        },
+    ])("should use Token functions %p", ({ code, type, targetType, expectedCode }) => {
+        expect(generateCode((0, coerceType_1.coerceType)(scope, expressionify(code), type, targetType))).toEqual(expectedCode);
+    });
+    it.each([
+        {
+            code: `aUserDefinedVariable.value`,
+            type: "dynamic",
+            targetType: "string",
+            expectedCode: `aUserDefinedVariable.stringValue`,
+        },
+        {
+            code: `aUserDefinedVariable.value`,
+            type: "dynamic",
+            targetType: "number",
+            expectedCode: `aUserDefinedVariable.numberValue`,
+        },
+        {
+            code: `aUserDefinedVariable.value`,
+            type: "dynamic",
+            targetType: ["list", "string"],
+            expectedCode: `aUserDefinedVariable.listValue`,
+        },
+        {
+            code: `aUserDefinedVariable.value`,
+            type: "dynamic",
+            targetType: "bool",
+            expectedCode: `aUserDefinedVariable.booleanValue`,
+        },
+    ])("should use TerraformVariables accessors %p", ({ code, type, targetType, expectedCode }) => {
+        expect(generateCode((0, coerceType_1.coerceType)(scope, expressionify(code), type, targetType))).toEqual(expectedCode);
+    });
+    it.each([
+        {
+            code: `aUserDefinedTerraformLocal.value`,
+            type: "dynamic",
+            targetType: "string",
+            expectedCode: `aUserDefinedTerraformLocal.stringValue`,
+        },
+        {
+            code: `aUserDefinedTerraformLocal.value`,
+            type: "dynamic",
+            targetType: "number",
+            expectedCode: `aUserDefinedTerraformLocal.numberValue`,
+        },
+        {
+            code: `aUserDefinedTerraformLocal.value`,
+            type: "dynamic",
+            targetType: ["list", "string"],
+            expectedCode: `aUserDefinedTerraformLocal.listValue`,
+        },
+        {
+            code: `aUserDefinedTerraformLocal.value`,
+            type: "dynamic",
+            targetType: "bool",
+            expectedCode: `aUserDefinedTerraformLocal.booleanValue`,
+        },
+    ])("should use TerraformLocal accessors %p", ({ code, type, targetType, expectedCode }) => {
+        expect(generateCode((0, coerceType_1.coerceType)(scope, expressionify(code), type, targetType))).toEqual(expectedCode);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"coerceType.test.js","sourceRoot":"","sources":["coerceType.test.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { coerceType } from \"../coerceType\";\nimport template from \"@babel/template\";\nimport generate from \"@babel/generator\";\n\nfunction expressionify(code: string) {\n  return (template.ast(code) as any).expression;\n}\nfunction generateCode(ast: any) {\n  return generate(ast).code;\n}\n\nconst scope: any = {\n  importables: [],\n  variables: {\n    a_user_defined_variable: {\n      resource: \"var\",\n      variableName: \"aUserDefinedVariable\",\n    },\n    a_user_defined_local: {\n      resource: \"var\",\n      variableName: \"aUserDefinedTerraformLocal\",\n    },\n  },\n};\n\ndescribe(\"coerceType\", () => {\n  it.each([\n    { code: `\"hello-world\"`, type: \"string\", targetType: undefined },\n    { code: `\"hello-world\"`, type: \"string\", targetType: \"string\" },\n  ])(\"should change nothing for %p \", ({ code, type, targetType }) => {\n    expect(\n      generateCode(\n        coerceType(scope, expressionify(code), type as any, targetType as any),\n      ),\n    ).toEqual(code);\n  });\n\n  it.each([\n    {\n      code: `\"300\"`,\n      type: \"string\",\n      targetType: \"number\",\n      expectedCode: `Token.asNumber(\"300\")`,\n    },\n    {\n      code: `300`,\n      type: \"number\",\n      targetType: \"string\",\n      expectedCode: `Token.asString(300)`,\n    },\n    {\n      code: `\"['foo', 'bar']\"`,\n      type: \"string\",\n      targetType: [\"list\", \"string\"],\n      expectedCode: `Token.asList(\"['foo', 'bar']\")`,\n    },\n    {\n      code: `\"[1,2,3]\"`,\n      type: \"string\",\n      targetType: [\"list\", \"number\"],\n      expectedCode: `Token.asNumberList(\"[1,2,3]\")`,\n    },\n    {\n      code: `\"['foo', 'bar']\"`,\n      type: \"string\",\n      targetType: [\"set\", \"string\"],\n      expectedCode: `Token.asList(\"['foo', 'bar']\")`,\n    },\n    {\n      code: `\"[1,2,3]\"`,\n      type: \"string\",\n      targetType: [\"set\", \"number\"],\n      expectedCode: `Token.asNumberList(\"[1,2,3]\")`,\n    },\n    // We don't have a token function for boolean lists, so we need to take an asAny\n    {\n      code: `\"[true,false,true]\"`,\n      type: \"string\",\n      targetType: [\"list\", \"bool\"],\n      expectedCode: `Token.asAny(\"[true,false,true]\")`,\n    },\n    {\n      code: `\"{ foo: 'bar' }\"`,\n      type: \"string\",\n      targetType: [\"map\", \"string\"],\n      expectedCode: `Token.asStringMap(\"{ foo: 'bar' }\")`,\n    },\n    {\n      code: `\"{ foo: 1 }\"`,\n      type: \"string\",\n      targetType: [\"map\", \"number\"],\n      expectedCode: `Token.asNumberMap(\"{ foo: 1 }\")`,\n    },\n\n    {\n      code: `\"{ foo: true }\"`,\n      type: \"string\",\n      targetType: [\"map\", \"bool\"],\n      expectedCode: `Token.asBooleanMap(\"{ foo: true }\")`,\n    },\n\n    {\n      code: `\"{ foo: {bar: true} }\"`,\n      type: \"string\",\n      targetType: [\"map\", [\"map\", \"boolean\"]],\n      expectedCode: `Token.asAnyMap(\"{ foo: {bar: true} }\")`,\n    },\n  ])(\n    \"should use Token functions %p\",\n    ({ code, type, targetType, expectedCode }) => {\n      expect(\n        generateCode(\n          coerceType(\n            scope,\n            expressionify(code),\n            type as any,\n            targetType as any,\n          ),\n        ),\n      ).toEqual(expectedCode);\n    },\n  );\n\n  it.each([\n    {\n      code: `aUserDefinedVariable.value`,\n      type: \"dynamic\",\n      targetType: \"string\",\n      expectedCode: `aUserDefinedVariable.stringValue`,\n    },\n    {\n      code: `aUserDefinedVariable.value`,\n      type: \"dynamic\",\n      targetType: \"number\",\n      expectedCode: `aUserDefinedVariable.numberValue`,\n    },\n    {\n      code: `aUserDefinedVariable.value`,\n      type: \"dynamic\",\n      targetType: [\"list\", \"string\"],\n      expectedCode: `aUserDefinedVariable.listValue`,\n    },\n    {\n      code: `aUserDefinedVariable.value`,\n      type: \"dynamic\",\n      targetType: \"bool\",\n      expectedCode: `aUserDefinedVariable.booleanValue`,\n    },\n  ])(\n    \"should use TerraformVariables accessors %p\",\n    ({ code, type, targetType, expectedCode }) => {\n      expect(\n        generateCode(\n          coerceType(\n            scope,\n            expressionify(code),\n            type as any,\n            targetType as any,\n          ),\n        ),\n      ).toEqual(expectedCode);\n    },\n  );\n\n  it.each([\n    {\n      code: `aUserDefinedTerraformLocal.value`,\n      type: \"dynamic\",\n      targetType: \"string\",\n      expectedCode: `aUserDefinedTerraformLocal.stringValue`,\n    },\n    {\n      code: `aUserDefinedTerraformLocal.value`,\n      type: \"dynamic\",\n      targetType: \"number\",\n      expectedCode: `aUserDefinedTerraformLocal.numberValue`,\n    },\n    {\n      code: `aUserDefinedTerraformLocal.value`,\n      type: \"dynamic\",\n      targetType: [\"list\", \"string\"],\n      expectedCode: `aUserDefinedTerraformLocal.listValue`,\n    },\n    {\n      code: `aUserDefinedTerraformLocal.value`,\n      type: \"dynamic\",\n      targetType: \"bool\",\n      expectedCode: `aUserDefinedTerraformLocal.booleanValue`,\n    },\n  ])(\n    \"should use TerraformLocal accessors %p\",\n    ({ code, type, targetType, expectedCode }) => {\n      expect(\n        generateCode(\n          coerceType(\n            scope,\n            expressionify(code),\n            type as any,\n            targetType as any,\n          ),\n        ),\n      ).toEqual(expectedCode);\n    },\n  );\n});\n"]}

package/lib/__tests__/expressionToTs.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+export {};
+//# sourceMappingURL=expressionToTs.test.d.ts.map