@cdktn/hcl2cdk 0.24.0-pre.43 → 0.24.0-pre.47

package/src/schema.ts

@@ -0,0 +1,74 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as z from "zod";
+
+const tfObject = <T extends z.ZodRawShape>(config: T) =>
+  z.array(z.object(config).partial());
+
+const outputConfig = tfObject({
+  value: z.any(),
+  description: z.string().optional(),
+  sensitive: z.boolean().optional(),
+  depends_on: z.string().optional(),
+});
+export type Output = z.infer<typeof outputConfig>;
+
+const validationConfig = z.object({
+  error_message: z.string(),
+  condition: z.any(),
+});
+
+const variableConfig = tfObject({
+  type: z.string(),
+  default: z.any(),
+  description: z.string(),
+  sensitive: z.boolean(),
+  nullable: z.boolean().optional(),
+  validation: z.array(validationConfig).optional(),
+});
+export type Variable = z.infer<typeof variableConfig>;
+
+const providerConfig = z.array(z.record(z.any()));
+export type Provider = z.infer<typeof providerConfig>;
+
+const moduleConfig = z.array(z.object({ source: z.string() }).nonstrict());
+export type Module = z.infer<typeof moduleConfig>;
+
+const resourceConfig = z.array(z.record(z.any()));
+export type Resource = z.infer<typeof resourceConfig>;
+export type Data = Resource;
+
+const importConfig = z.object({
+  to: z.string(),
+  id: z.string(),
+  provider: z.any().optional(),
+});
+export type Import = z.infer<typeof importConfig>;
+
+const providerSpecification = z.union([
+  z.object({ source: z.string(), version: z.string() }).partial(),
+  z.string(),
+]);
+
+const terraformConfig = z
+  .object({
+    required_version: z.string(),
+    required_providers: z.array(z.record(providerSpecification)),
+    backend: z.record(z.array(z.record(z.any()))),
+  })
+  .partial();
+export type TerraformConfig = z.infer<typeof terraformConfig>;
+
+export const schema = z
+  .object({
+    data: z.record(z.record(resourceConfig)),
+    import: z.array(importConfig),
+    locals: z.array(z.record(z.any())),
+    module: z.record(moduleConfig),
+    output: z.record(outputConfig),
+    provider: z.record(providerConfig),
+    resource: z.record(z.record(resourceConfig)),
+    terraform: z.array(terraformConfig),
+    variable: z.record(variableConfig),
+  })
+  .partial();

package/src/terraformSchema.ts

@@ -0,0 +1,182 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import {
+  ProviderSchema,
+  BlockType,
+  AttributeType,
+  Schema,
+} from "@cdktn/commons";
+import { getFullProviderName } from "./provider";
+import { ProgramScope } from "./types";
+
+function getResourceAtPath(schema: ProviderSchema, path: string) {
+  const parts = path.split(".");
+
+  if (parts.length < 2) {
+    // Too short to be a valid path
+    return null;
+  }
+
+  const isDataSource = parts[0] === "data";
+  if (isDataSource) {
+    parts.shift();
+  }
+
+  const providerName = parts.shift() as string;
+  const resourceName = parts.shift() as string;
+
+  const fullProviderName = getFullProviderName(schema, providerName);
+  // Hack: In the case of 'external', the name of the data source 'external' doesn't have a prefix
+  // so we repeat the name as both provider prefix and the data source name
+  const fullResourceName =
+    providerName === resourceName
+      ? providerName
+      : `${providerName}_${resourceName}`;
+
+  if (!fullProviderName) {
+    // No provider found with that name
+    return null;
+  }
+
+  const provider = schema.provider_schemas?.[fullProviderName];
+
+  if (!provider) {
+    // Could not find provider
+    return null;
+  }
+
+  if (resourceName.endsWith("Provider")) {
+    // This is a provider
+    return { resource: provider.provider, parts };
+  }
+
+  const resources = isDataSource
+    ? provider.data_source_schemas
+    : provider.resource_schemas;
+
+  const resource = resources[fullResourceName];
+  if (!resource) {
+    // Could not find resource
+    return null;
+  }
+
+  return { resource, parts };
+}
+
+function findType(
+  item: Schema | BlockType | AttributeType,
+  parts: string[],
+): Schema | BlockType | AttributeType | null {
+  if (!parts.length) {
+    return item;
+  }
+
+  const [currentPart, ...otherParts] = parts;
+
+  // Promitive attributes can be returned directly
+  if (typeof item === "string") {
+    return item;
+  }
+
+  // Complex attributes
+  if (Array.isArray(item)) {
+    if (item[0] === "set" || item[0] === "list") {
+      if (currentPart === "[]") {
+        return findType(item[1], otherParts);
+      }
+      // Trying to access a property on a list
+      return null;
+    }
+
+    if (item[0] === "object") {
+      if (currentPart === "[]") {
+        // Trying to access a property on a list
+        return null;
+      }
+
+      return findType(item[1][currentPart], otherParts);
+    }
+
+    if (item[0] === "map") {
+      // We don't care what the key is
+      return findType(item[1], otherParts);
+    }
+
+    // Unknown type
+    return null;
+  }
+
+  // If we are not in an attribute, we can ignore the [] (since max_item=1 parts don't have [], so we just ignore it)
+  if (currentPart === "[]") {
+    return findType(item, otherParts);
+  }
+
+  // Block
+  if (item.block) {
+    // Find block type in block
+    if (item.block.block_types) {
+      const blockType = item.block.block_types[currentPart];
+      if (blockType) {
+        return findType(blockType, otherParts);
+      }
+    }
+
+    // Find attribute in block
+    if (item.block.attributes) {
+      const attribute = item.block.attributes[currentPart];
+      if (attribute && attribute.type) {
+        return findType(attribute.type, otherParts);
+      }
+    }
+  }
+
+  // Could not find the type
+  return null;
+}
+
+export function getTypeAtPath(
+  schema: ProviderSchema,
+  path: string,
+): Schema | BlockType | AttributeType | null {
+  const resourceSchema = getResourceAtPath(schema, path);
+
+  if (!resourceSchema) {
+    return null;
+  }
+  const { resource, parts } = resourceSchema;
+  return findType(resource, parts);
+}
+
+export const isMapAttribute = (
+  attribute: Schema | AttributeType | BlockType | null,
+) => (Array.isArray(attribute) ? attribute[0] === "map" : false);
+
+export function getDesiredType(
+  scope: ProgramScope,
+  path: string,
+): AttributeType {
+  const attributeOrBlockType = getTypeAtPath(scope.providerSchema, path);
+
+  // Attribute type is not defined
+  if (!attributeOrBlockType) {
+    return "dynamic";
+  }
+
+  // Primitive attribute type
+  if (typeof attributeOrBlockType === "string") {
+    return attributeOrBlockType;
+  }
+
+  // Complex attribute type
+  if (Array.isArray(attributeOrBlockType)) {
+    return attributeOrBlockType;
+  }
+
+  // Schema
+  if ("version" in attributeOrBlockType) {
+    return "dynamic";
+  }
+
+  // Block type
+  return "dynamic";
+}

package/src/types.ts

@@ -0,0 +1,58 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { TerraformProviderGenerator } from "@cdktn/provider-generator";
+import { ProviderSchema } from "@cdktn/commons";
+
+export type TerraformResourceBlock = unknown;
+export type AttributePath = string;
+export type ProgramScope = {
+  providerSchema: ProviderSchema;
+  providerGenerator: Record<string, TerraformProviderGenerator>;
+  constructs: Set<string>;
+  variables: Record<
+    string,
+    {
+      resource: string;
+      variableName: string;
+    }
+  >;
+  // Temporary flag to indicate if we need to import the cdktf library to access the token class
+  hasTokenBasedTypeCoercion: boolean;
+  nodeIds: string[]; // temporarily added until replaced
+  importables: ImportableConstruct[]; // records all imports for the conversion
+  topLevelConfig: Record<string, AttributePath>;
+};
+
+export type ResourceScope = ProgramScope & {
+  forEachIteratorName?: string; // set if a for_each is used in this resource
+  countIteratorName?: string; // set if a count is used in this resource
+  withinOverrideExpression?: boolean; // set if we are currently within an override expression
+  scopedVariables?: Record<string, string>; // set if we are currently within an dynamic block expression
+};
+
+export type Reference = {
+  start: number;
+  end: number;
+  referencee: { id: string; full: string }; // identifier for resource
+  useFqn?: boolean;
+  isVariable?: boolean;
+};
+
+export type DynamicBlock = {
+  path: string;
+  for_each: string;
+  content: TerraformResourceBlock;
+  scopedVar: string;
+};
+
+export type IteratorVariableReference = {
+  start: number;
+  end: number;
+  value: string;
+};
+
+export type ImportableConstruct = {
+  provider: string;
+  constructName: string;
+  namespace?: string;
+};

package/src/utils.ts

@@ -0,0 +1,19 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import camelcase from "camelcase";
+
+export { logger } from "@cdktn/commons";
+
+export const fileBugCommentText = `This is likely a bug in cdktn. Please report it at https://github.com/open-constructs/cdk-terrain/issues/new?assignees=&labels=bug&template=bug-report.md&title=.`;
+
+export const camelCase = (str: string) => camelcase(str.replace(/[-/]/g, "_"));
+export const pascalCase = (str: string) =>
+  camelcase(str.replace(/[-/]/g, "_"), { pascalCase: true });
+
+export function uniqueId(set: Set<string>, key: string): string {
+  if (set.has(key)) {
+    return uniqueId(set, `${key}_${set.size}`);
+  }
+  set.add(key);
+  return key;
+}

package/src/variables.ts

@@ -0,0 +1,214 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import * as t from "@babel/types";
+import { ProgramScope, Reference } from "./types";
+import { camelCase, pascalCase } from "./utils";
+import { sanitizeClassOrNamespaceName } from "@cdktn/provider-generator";
+import { getFullProviderName } from "./provider";
+import reservedWords from "reserved-words";
+
+export function referenceToVariableName(
+  scope: ProgramScope,
+  ref: Reference,
+): string {
+  const parts = ref.referencee.id.split(".");
+  const resource = parts[0] === "data" ? `${parts[0]}.${parts[1]}` : parts[0];
+  const name = parts[0] === "data" ? parts[2] : parts[1];
+  return variableName(scope, resource, name);
+}
+
+function validVarName(name: string) {
+  if (reservedWords.check(name)) {
+    return `${name}Var`;
+  }
+
+  if (!Number.isNaN(parseInt(name[0], 10))) {
+    return `d${name}`;
+  }
+
+  return name;
+}
+
+function getUniqueName(scope: ProgramScope, provider: string, type: string) {
+  // early abort on cdktf
+  if (provider === "cdktf") {
+    return pascalCase(type.replace("cdktf_", ""));
+  }
+  // early abort on cdktn
+  if (provider === "cdktn") {
+    return pascalCase(type.replace("cdktn_", ""));
+  }
+
+  if (provider === "NullProvider") {
+    return pascalCase(type.replace("NullProvider_", ""));
+  }
+
+  // Special handling for provider blocks, e.g. aws_AwsProvider
+  if (type === `${pascalCase(provider)}Provider`) {
+    return sanitizeClassOrNamespaceName(type, true);
+  }
+
+  const fullProviderName = getFullProviderName(scope.providerSchema, provider);
+  if (fullProviderName && scope.providerGenerator[fullProviderName]) {
+    return scope.providerGenerator[fullProviderName]?.getClassNameForResource(
+      type,
+    );
+  } else {
+    // If we can not find the class name for a resource the caller needs to find a sensible default
+    return null;
+  }
+}
+
+function getResourceNamespace(
+  scope: ProgramScope,
+  provider: string,
+  resource: string,
+  isDataSource: boolean,
+  type: string,
+) {
+  // happens e.g. for references to cdktn.TerraformStack (and similar) in generated code
+  if (provider === "cdktn") {
+    return undefined;
+  }
+
+  // e.g. awsProvider -> provider
+  if (
+    resource === pascalCase(`${provider}_provider`) ||
+    (provider === "NullProvider" && resource === "NullProvider")
+  ) {
+    return "provider";
+  }
+
+  const fullProviderName = getFullProviderName(scope.providerSchema, provider);
+
+  if (fullProviderName && scope.providerGenerator[fullProviderName]) {
+    return camelCase(
+      scope.providerGenerator[fullProviderName]?.getNamespaceNameForResource(
+        type.replace(/\./g, "_"),
+      ),
+    );
+  }
+
+  if (isDataSource) {
+    return camelCase(
+      sanitizeClassOrNamespaceName(`data_${provider}_${resource}`),
+    );
+  }
+
+  return camelCase(sanitizeClassOrNamespaceName(resource));
+}
+
+export function constructAst(
+  scope: ProgramScope,
+  type: string,
+  isModuleImport: boolean,
+) {
+  if (isModuleImport) {
+    return t.memberExpression(t.identifier(type), t.identifier(type));
+  }
+
+  if (type.startsWith("var.")) {
+    scope.importables.push({
+      provider: "cdktn",
+      constructName: "TerraformVariable",
+    });
+
+    return t.identifier("TerraformVariable");
+  }
+
+  if (type === "terraform.data") {
+    scope.importables.push({
+      constructName: "DataResource",
+      provider: "cdktn",
+    });
+    return t.identifier("DataResource");
+  }
+
+  // resources or data sources
+  if (!type.includes("./") && type.includes(".")) {
+    const parts = type.split(".");
+    if (parts[0] === "data") {
+      const [, provider, resource] = parts;
+
+      const namespace = getResourceNamespace(
+        scope,
+        provider,
+        resource,
+        true,
+        type,
+      );
+      const resourceName =
+        getUniqueName(scope, provider, parts.join("_")) ||
+        pascalCase(
+          sanitizeClassOrNamespaceName(`data_${provider}_${resource}`),
+        );
+
+      scope.importables.push({
+        provider: provider,
+        constructName: resourceName,
+        namespace,
+      });
+
+      if (namespace) {
+        return t.identifier(resourceName); // e.g. DataAwsInstance
+      }
+
+      return t.identifier(resourceName); // e.g. DataAwsNatGateway
+    }
+
+    const [provider, resource] = parts;
+    const namespace = getResourceNamespace(
+      scope,
+      provider,
+      resource,
+      false,
+      type,
+    );
+    const resourceName =
+      getUniqueName(scope, provider, parts.join("_")) ||
+      pascalCase(sanitizeClassOrNamespaceName(resource));
+
+    scope.importables.push({
+      provider: provider,
+      constructName: resourceName,
+      namespace,
+    });
+
+    if (namespace) {
+      return t.identifier(resourceName); // e.g. Instance
+    }
+
+    return t.identifier(resourceName); // e.g. BigQueryTable
+  }
+
+  return t.identifier(pascalCase(type));
+}
+
+export function variableName(
+  scope: ProgramScope,
+  resource: string,
+  name: string,
+): string {
+  const consistentResourceName = resource.replace(/\./g, "_");
+  // name collision, we need to prefix the name
+  if (scope.variables[name]) {
+    if (consistentResourceName === scope.variables[name].resource) {
+      return scope.variables[name].variableName;
+    }
+
+    // we only cache one per name
+    return validVarName(camelCase([resource, name].join("_")));
+  }
+
+  const variableName = validVarName(camelCase(name));
+
+  scope.variables[name] = {
+    variableName,
+    resource: consistentResourceName,
+  };
+
+  return variableName;
+}

package/test/__snapshots__/backends.test.ts.snap

@@ -0,0 +1,70 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`backends local backend snapshot typescript 1`] = `
+"import { Construct } from "constructs";
+import { LocalBackend, TerraformStack } from "cdktn";
+class MyConvertedCode extends TerraformStack {
+  constructor(scope: Construct, name: string) {
+    super(scope, name);
+    new LocalBackend(this, {
+      path: "relative/path/to/terraform.tfstate",
+    });
+  }
+}
+"
+`;
+
+exports[`backends remote backend snapshot typescript 1`] = `
+"import { Construct } from "constructs";
+import { RemoteBackend, TerraformStack } from "cdktn";
+class MyConvertedCode extends TerraformStack {
+  constructor(scope: Construct, name: string) {
+    super(scope, name);
+    new RemoteBackend(this, {
+      hostname: "app.terraform.io",
+      organization: "company",
+      workspaces: [
+        {
+          name: "my-app-prod",
+        },
+      ],
+    });
+  }
+}
+"
+`;
+
+exports[`backends remote state snapshot typescript 1`] = `
+"import { Construct } from "constructs";
+import { DataTerraformRemoteState, TerraformStack } from "cdktn";
+class MyConvertedCode extends TerraformStack {
+  constructor(scope: Construct, name: string) {
+    super(scope, name);
+    new DataTerraformRemoteState(this, "vpc", {
+      organization: "hashicorp",
+      workspaces: [
+        {
+          name: "vpc-prod",
+        },
+      ],
+    });
+  }
+}
+"
+`;
+
+exports[`backends remote state types snapshot typescript 1`] = `
+"import { Construct } from "constructs";
+import { DataTerraformRemoteStateS3, TerraformStack } from "cdktn";
+class MyConvertedCode extends TerraformStack {
+  constructor(scope: Construct, name: string) {
+    super(scope, name);
+    new DataTerraformRemoteStateS3(this, "s3", {
+      bucket: "mybucket",
+      key: "path/to/my/key",
+      region: "us-east-1",
+    });
+  }
+}
+"
+`;

package/test/__snapshots__/externals.test.ts.snap

@@ -0,0 +1,37 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`externals handle simple external data snapshot typescript 1`] = `
+"import { Construct } from "constructs";
+import {
+  VariableType,
+  TerraformVariable,
+  TerraformOutput,
+  Fn,
+  TerraformStack,
+} from "cdktn";
+/*
+ * Provider bindings are generated by running \`cdktn get\`.
+ * See https://cdktn.io/docs/concepts/providers#import-providers for more details.
+ */
+import { DataExternal } from "./.gen/providers/external/data-external";
+import { ExternalProvider } from "./.gen/providers/external/provider";
+class MyConvertedCode extends TerraformStack {
+  constructor(scope: Construct, name: string) {
+    super(scope, name);
+    /*Terraform Variables are not always the best fit for getting inputs in the context of Terraform CDK.
+    You can read more about this at https://cdktn.io/docs/concepts/variables-and-outputs#input-variables*/
+    new ExternalProvider(this, "external", {});
+    const fargateRegion = new TerraformVariable(this, "fargate_region", {
+      default: "us-east-1",
+      type: VariableType.STRING,
+    });
+    const dataExternalThumbprint = new DataExternal(this, "thumbprint", {
+      program: ["\${path.module}/oidc_thumbprint.sh", fargateRegion.value],
+    });
+    new TerraformOutput(this, "foo", {
+      value: Fn.lookupNested(dataExternalThumbprint, ["result", "thumbprint"]),
+    });
+  }
+}
+"
+`;