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

package/src/iteration.ts

@@ -0,0 +1,156 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import { DirectedGraph } from "graphology";
+import { providers as telemetryAllowedProviders } from "./telemetryAllowList.json";
+import { ProgramScope } from "./types";
+import { Import } from "./schema";
+
+// locals, variables, and outputs are global key value maps
+export function forEachGlobal<T, R>(
+  scope: ProgramScope,
+  prefix: string,
+  record: Record<string, T> | undefined,
+  iterator: (
+    scope: ProgramScope,
+    key: string,
+    id: string,
+    value: T,
+    graph: DirectedGraph,
+  ) => Promise<R>,
+): Record<string, { code: (graph: DirectedGraph) => Promise<R>; value: T }> {
+  return Object.entries(record || {}).reduce((carry, [key, item]) => {
+    const id = `${prefix}.${key}`;
+    return {
+      ...carry,
+      [id]: {
+        code: async (graph: DirectedGraph) =>
+          await iterator(scope, key, id, item, graph),
+        value: item,
+      },
+    };
+  }, {});
+}
+
+export function forEachImport<R>(
+  scope: ProgramScope,
+  prefix: string,
+  record: Import[] | undefined,
+  iterator: (
+    scope: ProgramScope,
+    id: string,
+    value: Import,
+    graph: DirectedGraph,
+  ) => Promise<R>,
+): Record<
+  string,
+  { code: (graph: DirectedGraph) => Promise<R>; value: Import }
+> {
+  return (record || []).reduce((carry, item) => {
+    const target =
+      item.to.startsWith("${") && item.to.endsWith("}")
+        ? item.to.substring(2, item.to.length - 1)
+        : item.to;
+
+    const id = `${prefix}.${target}`;
+    return {
+      ...carry,
+      [id]: {
+        code: async (graph: DirectedGraph) =>
+          await iterator(scope, id, item, graph),
+        value: item,
+      },
+    };
+  }, {});
+}
+
+export function forEachProvider<T extends { alias?: string }, R>(
+  scope: ProgramScope,
+  record: Record<string, T[]> | undefined,
+  iterator: (
+    scope: ProgramScope,
+    key: string,
+    id: string,
+    value: T,
+    graph: DirectedGraph,
+  ) => Promise<R>,
+): Record<string, { code: (graph: DirectedGraph) => Promise<R>; value: T }> {
+  return Object.entries(record || {}).reduce((carry, [key, items]) => {
+    return {
+      ...carry,
+      ...items.reduce((innerCarry, item: T) => {
+        const id = item.alias ? `${key}.${item.alias}` : `${key}`;
+        return {
+          ...innerCarry,
+          [id]: {
+            code: async (graph: DirectedGraph) =>
+              await iterator(scope, key, id, item, graph),
+            value: item,
+          },
+        };
+      }, {}),
+    };
+  }, {});
+}
+
+// data and resource are namespaced key value maps
+export function forEachNamespaced<T, R>(
+  scope: ProgramScope,
+  record: Record<string, Record<string, T>> | undefined,
+  iterator: (
+    scope: ProgramScope,
+    type: string,
+    key: string,
+    id: string,
+    value: T,
+    graph: DirectedGraph,
+  ) => Promise<R>,
+  prefix?: string,
+): Record<string, { code: (graph: DirectedGraph) => Promise<R>; value: T }> {
+  return Object.entries(record || {}).reduce(
+    (outerCarry, [type, items]) => ({
+      ...outerCarry,
+      ...Object.entries(items).reduce(
+        (innerCarry, [key, item]) => {
+          const prefixedType = prefix ? `${prefix}.${type}` : type;
+          const id = prefix ? `${prefix}.${type}.${key}` : `${type}.${key}`;
+          return {
+            ...innerCarry,
+            [id]: {
+              code: async (graph: DirectedGraph) =>
+                await iterator(scope, prefixedType, key, id, item, graph),
+              value: item,
+            },
+          };
+        },
+        {} as Record<
+          string,
+          { code: (graph: DirectedGraph) => Promise<R>; value: T }
+        >,
+      ),
+    }),
+    {} as Record<
+      string,
+      { code: (graph: DirectedGraph) => Promise<R>; value: T }
+    >,
+  );
+}
+
+export function resourceStats(obj: Record<string, Record<string, unknown>>) {
+  return Object.entries(obj).reduce(
+    (carry, [key, value]) => {
+      const [provider, ...resourceParts] = key.split("_");
+      const shouldBeTracked = telemetryAllowedProviders.includes(provider);
+      const providerKey = shouldBeTracked ? provider : "other";
+      const resourceName = shouldBeTracked ? resourceParts.join("_") : "other";
+
+      return {
+        ...carry,
+        [providerKey]: {
+          ...(carry[providerKey] || {}),
+          [resourceName]: Object.keys(value).length,
+        },
+      };
+    },
+    {} as Record<string, Record<string, number>>,
+  );
+}

package/src/jsii-rosetta-workarounds.ts

@@ -0,0 +1,145 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+
+export function replacePythonImports(code: string) {
+  return code
+    .split("\n")
+    .map((line) => {
+      // Replace from-import lines with lib
+      const fromImportLibRegex =
+        /from \.\.\.gen\.providers\.([^.]+)(?:\.lib)?\.(.*) import/;
+      if (fromImportLibRegex.test(line)) {
+        return line.replace(fromImportLibRegex, "from imports.$1.$2 import");
+      }
+
+      // Replace import lines with lib
+      const importLibRegex =
+        /import \.\.\.gen\.providers\.([^.]+)(?:\.lib)?\.(.*) as (.*)/;
+      if (importLibRegex.test(line)) {
+        return line.replace(importLibRegex, "import imports.$1.$2 as $3");
+      }
+
+      // Replace from-import lines
+      if (line.startsWith("from ...gen.providers.")) {
+        return line.replace("from ...gen.providers.", "from imports.");
+      }
+      // Replace import lines
+      if (line.startsWith("import ...gen.providers.")) {
+        return line.replace("import ...gen.providers.", "import imports.");
+      }
+
+      // Replace modules
+      if (line.startsWith("import ...gen.modules.")) {
+        return line.replace("import ...gen.modules.", "import imports.");
+      }
+
+      return line;
+    })
+    .join("\n");
+}
+
+export function replaceJavaImports(code: string) {
+  return code
+    .split("\n")
+    .map((line) => {
+      // Replace using lines with lib and precices import
+      const importWithLib =
+        /import gen\.providers\.([^.]+)(?:\.lib)?\.([^.]+)\.(.*);/;
+      const matchWithLib = line.match(importWithLib);
+      if (matchWithLib) {
+        const [, provider, resource, className] = matchWithLib;
+        return `import imports.${provider}.${resource}.${className};`;
+      }
+
+      // Replace using lines
+      const importWithoutLib = /import gen\.providers\.([^.]+)\.([^.]+)\.\*;/;
+      const matchWithoutLib = line.match(importWithoutLib);
+      if (matchWithoutLib) {
+        const [, provider, resource] = matchWithoutLib;
+        return `import imports.${provider}.${resource}.*;`;
+      }
+
+      // Replace using lines
+      const importModules = /import gen\.modules\.(.+)\.\*;/;
+      const importModulesMatch = line.match(importModules);
+      if (importModulesMatch) {
+        const [, module] = importModulesMatch;
+        return `import imports.${module}.*;`;
+      }
+
+      return line;
+    })
+    .join("\n");
+}
+
+export function replaceCsharpImports(code: string) {
+  return code
+    .split("\n")
+    .map((line) => {
+      // Replace using lines with lib
+      const fromImportLibRegex =
+        /using Gen\.Providers\.([^.]*)(?:\.Lib)?\.(.*);/;
+      const match = line.match(fromImportLibRegex);
+      if (match) {
+        const [, provider, resource] = match;
+        return `using ${lowercaseFirstChar(provider)}.${resource};`;
+      }
+
+      // Replace using lines
+      if (line.startsWith("using Gen.Providers.")) {
+        const importLine = line.replace("using Gen.Providers.", "");
+
+        return `using ${importLine
+          .substring(0, 1)
+          .toLocaleLowerCase()}${importLine.substring(1)}`;
+      }
+
+      if (line.startsWith("using Gen.Modules.")) {
+        const importLine = line.replace("using Gen.Modules.", "");
+
+        return `using ${importLine}`;
+      }
+
+      return line;
+    })
+    .join("\n");
+}
+
+export function replaceGoImports(code: string) {
+  return code
+    .split("\n")
+    .map((line) => {
+      // Replace using lines with lib
+      const fromImportLibRegex =
+        /import "github.com\/aws-samples\/dummy\/gen\/providers\/([^/]*)(?:\/lib)?\/(.*)"/;
+      const matchLib = line.match(fromImportLibRegex);
+      if (matchLib) {
+        const [, provider, resource] = matchLib;
+        return `import "cdk.tf/go/stack/generated/${provider}/${resource}"`;
+      }
+
+      // Replace using lines
+      const fromImportRegex =
+        /import "github.com\/aws-samples\/dummy\/gen\/providers\/([^/]+)\/(.*)"/;
+      const match = line.match(fromImportRegex);
+      if (match) {
+        const [, provider, resource] = match;
+        return `import "cdk.tf/go/stack/generated/${provider}/${resource}"`;
+      }
+
+      const importModulesRegex =
+        /import (.*) "github.com\/aws-samples\/dummy\/gen\/modules\/(.*)"/;
+      const matchModules = line.match(importModulesRegex);
+      if (matchModules) {
+        const [, name, module] = matchModules;
+        return `import ${name} "cdk.tf/go/stack/generated/${module}"`;
+      }
+
+      return line;
+    })
+    .join("\n");
+}
+
+function lowercaseFirstChar(str: string) {
+  return str.substring(0, 1).toLocaleLowerCase() + str.substring(1);
+}

package/src/partialCode.ts

@@ -0,0 +1,132 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import { getTypeAtPath } from "./terraformSchema";
+import { ResourceScope, TerraformResourceBlock } from "./types";
+import * as t from "@babel/types";
+import { camelCase } from "./utils";
+
+function getConfigFieldName(
+  topLevelConfig: Record<string, unknown>,
+  name: string,
+) {
+  const sanitizedName = camelCase(name);
+  return deduplicateName(Object.keys(topLevelConfig), sanitizedName);
+}
+
+function deduplicateName(existingNames: string[], name: string) {
+  let newName = name;
+  let i = 1;
+  while (existingNames.includes(newName)) {
+    newName = `${name}${i}`;
+    i++;
+  }
+  return newName;
+}
+
+export function fillWithConfigAccessors(
+  scope: ResourceScope,
+  config: TerraformResourceBlock,
+  path: string,
+): any {
+  if (Array.isArray(config)) {
+    return config.map((c) => fillWithConfigAccessors(scope, c, `${path}.[]`));
+  }
+
+  if (typeof config === "object" && config !== null) {
+    const mutated = Object.entries(config).reduce(
+      (acc, [key, value]) => ({
+        ...acc,
+        [key]: fillWithConfigAccessors(scope, value, `${path}.${key}`),
+      }),
+      {} as Record<string, TerraformResourceBlock>,
+    );
+
+    // Get type of this part of the config
+    const attributeType = getTypeAtPath(scope.providerSchema, path);
+    const requiredAttributes = getRequiredAttributes(attributeType);
+
+    // Add accessors for all required attributes that are missing
+    requiredAttributes.forEach((key) => {
+      const value = mutated[key];
+      const isNotDirectlyAccessible = value === undefined;
+      const isReplacedByAst =
+        (t.isNode(mutated) && t.isExpression(mutated)) ||
+        t.isExpression(value as any);
+      const isEmptyArray = Array.isArray(value) && value.length === 0;
+
+      // If this was already replaced by an AST node, we don't need to do anything
+      // We assume all fields are filled in by the AST
+      if (isReplacedByAst) {
+        return;
+      }
+
+      if (isNotDirectlyAccessible || isEmptyArray) {
+        const fieldName = getConfigFieldName(scope.topLevelConfig, key);
+        mutated[key] = t.memberExpression(
+          t.identifier("config"),
+          t.identifier(fieldName),
+        );
+        scope.topLevelConfig[fieldName] = `${path}.${key}`;
+      }
+    });
+
+    return mutated;
+  } else {
+    return config;
+  }
+}
+
+type Key = string;
+export function getRequiredAttributes(
+  attributeType: ReturnType<typeof getTypeAtPath>,
+): Key[] {
+  if (!attributeType) {
+    return [];
+  }
+  if (
+    typeof attributeType !== "object" ||
+    Array.isArray(attributeType) ||
+    attributeType === null ||
+    attributeType === undefined ||
+    !("block" in attributeType)
+  ) {
+    return [];
+  }
+
+  const requiredAttributes = Object.entries(
+    attributeType.block.attributes || {},
+  ).reduce(
+    (acc, [key, value]) => (value.required ? [...acc, key] : acc),
+    [] as string[],
+  );
+
+  // Logic taken from (and should be shared with) provider generator resource parser: attributeForBlockType
+  const requiredBlockTypes = Object.entries(
+    attributeType.block.block_types || {},
+  ).reduce((acc, [key, value]) => {
+    if (
+      value.nesting_mode === "single" &&
+      !Object.values(value.block.attributes || {}).some((x) => !x.required)
+    ) {
+      return [...acc, key];
+    }
+    if (value.nesting_mode === "map") {
+      return acc;
+    }
+
+    if (
+      (value.nesting_mode === "list" || value.nesting_mode === "set") &&
+      value.min_items === undefined
+        ? false
+        : (value as any).min_items > 0
+    ) {
+      return [...acc, key];
+    }
+
+    return acc;
+  }, [] as string[]);
+  return [...requiredAttributes, ...requiredBlockTypes].sort();
+}

package/src/provider.ts

@@ -0,0 +1,60 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as z from "zod";
+import { ProviderSchema, BlockType, Attribute } from "@cdktn/commons";
+import { schema } from "./schema";
+
+export { BlockType, Attribute };
+
+export function getFullProviderName(
+  schema: ProviderSchema,
+  providerName: string,
+) {
+  return Object.keys(schema.provider_schemas || {}).find((name) =>
+    name.endsWith(providerName),
+  );
+}
+
+type Plan = z.infer<typeof schema>;
+export function getProviderRequirements(plan: Plan) {
+  // In Terraform one can implicitly define the provider by using resources of that type
+  const explicitProviders = Object.keys(plan.provider || {});
+  const implicitProviders = Object.keys({ ...plan.resource, ...plan.data })
+    .filter((type) => type !== "terraform_remote_state")
+    .filter((type) => type !== "terraform_data")
+    .map((type) => type.split("_")[0]);
+
+  const providerRequirements = Array.from(
+    new Set([...explicitProviders, ...implicitProviders]),
+  ).reduce(
+    (carry, req) => ({ ...carry, [req]: "*" }),
+    {} as Record<string, string>,
+  );
+
+  plan.terraform?.forEach(({ required_providers }) =>
+    (required_providers || []).forEach((providerBlock) =>
+      Object.entries(providerBlock).forEach(([key, value]) => {
+        let name, version;
+        if (typeof value === "string") {
+          name = key;
+          version = value;
+        } else {
+          name = value.source;
+          version = value.version;
+        }
+
+        if (!name) {
+          return;
+        }
+        // implicitly only the last part of the path is used (e.g. docker for kreuzwerker/docker)
+        const parts = name.split("/");
+        if (parts.length > 1) {
+          delete providerRequirements[parts.pop() || ""];
+        }
+        providerRequirements[name] = version || "*";
+      }),
+    ),
+  );
+
+  return providerRequirements;
+}

package/src/references.ts

@@ -0,0 +1,193 @@
+/**
+ * Copyright (c) HashiCorp, Inc.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+import {
+  getReferencesInExpression,
+  TFExpressionSyntaxTree as tex,
+} from "@cdktn/hcl2json";
+import { logger } from "./utils";
+import { ProgramScope, Reference, TerraformResourceBlock } from "./types";
+import { variableName } from "./variables";
+
+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);
+}
+
+export function containsReference(expression: tex.ExpressionType) {
+  if (!tex.isScopeTraversalExpression(expression)) {
+    return false;
+  }
+
+  const segments = expression.meta.traversal;
+  const rootSegment = segments[0].segment;
+  const fullAccessor = expression.meta.fullAccessor;
+
+  if (
+    rootSegment === "count" || // count variable
+    rootSegment === "each" || // each variable
+    // https://www.terraform.io/docs/language/expressions/references.html#filesystem-and-workspace-info
+    fullAccessor.startsWith("path.module") ||
+    fullAccessor.startsWith("path.root") ||
+    fullAccessor.startsWith("path.cwd") ||
+    fullAccessor.startsWith("terraform.workspace") ||
+    fullAccessor.startsWith("self.") // block local value
+  ) {
+    logger.debug(`skipping ${fullAccessor}`);
+    return false;
+  }
+
+  return true;
+}
+
+export async function extractReferencesFromExpression(
+  input: string,
+  nodeIds: readonly string[],
+  scopedIds: readonly string[] = [], // dynamics introduce new scoped variables that are not the globally accessible ids
+): Promise<Reference[]> {
+  logger.debug(`extractReferencesFromExpression(${input})`);
+  const possibleVariableSpots = await getReferencesInExpression(
+    "main.tf",
+    input,
+  );
+
+  logger.debug(
+    `found possible variable spots: ${JSON.stringify(possibleVariableSpots)}`,
+  );
+
+  return possibleVariableSpots.reduce((carry, spot) => {
+    const { value, startPosition, endPosition } = spot;
+    // no reference
+    if (
+      !value.includes(".") || // just a literal
+      value.startsWith(".") || // dangling property access
+      value.endsWith("...") || // spread (likely in for loop)
+      value.startsWith("count.") || // count variable
+      value.startsWith("each.") || // each variable
+      // https://www.terraform.io/docs/language/expressions/references.html#filesystem-and-workspace-info
+      value.startsWith("path.module") ||
+      value.startsWith("path.root") ||
+      value.startsWith("path.cwd") ||
+      value.startsWith("terraform.workspace") ||
+      value.startsWith("self.") // block local value
+    ) {
+      logger.debug(`skipping ${value}`);
+      return carry;
+    }
+
+    const referenceParts = value.split(".");
+
+    logger.debug(
+      `Searching for node id '${value}' in ${JSON.stringify(nodeIds)}`,
+    );
+    const corespondingNodeId = [...nodeIds, ...scopedIds].find((id) => {
+      const parts = id.split(".");
+      const matchesFirst = parts[0] === referenceParts[0];
+      const matchesFirstTwo =
+        matchesFirst &&
+        (parts[1] === referenceParts[1] || referenceParts.length === 1);
+
+      return (
+        matchesFirstTwo &&
+        (parts[0] === "data" ? parts[2] === referenceParts[2] : true)
+      );
+    });
+
+    if (!corespondingNodeId) {
+      // This is most likely a false positive, so we just ignore it
+      // We include the log below to help debugging
+      logger.error(
+        `Found a reference that is unknown: ${input} has reference "${value}". The id was not found in ${JSON.stringify(
+          nodeIds,
+        )} with temporary values ${JSON.stringify(scopedIds)}.`,
+      );
+      return carry;
+    }
+
+    if (scopedIds.includes(corespondingNodeId)) {
+      logger.debug(`skipping '${value}' since it's a scoped variable`);
+      return carry;
+    }
+    logger.debug(`Found node id '${corespondingNodeId}'`);
+
+    const spotParts = value.split(".");
+    let isThereANumericAccessor = false;
+    const referenceSpotParts = spotParts.filter((part) => {
+      if (!Number.isNaN(parseInt(part, 10))) {
+        isThereANumericAccessor = true;
+        return false;
+      }
+
+      return !isThereANumericAccessor;
+    });
+    const fullReference = isThereANumericAccessor
+      ? referenceSpotParts.slice(0, 2).join(".")
+      : value;
+
+    const isVariable = value.startsWith("var.");
+    const useFqn =
+      // Can not use FQN on vars
+      !isVariable &&
+      // Can not use FQN on locals
+      !value.startsWith("local.") &&
+      // If the following character is
+      (input.substr(endPosition + 1, 1) === "*" || // a * (splat) we need to use the FQN
+        input.substr(endPosition, 1) === "[" || // a property access
+        isThereANumericAccessor); // a numeric access
+
+    const ref: Reference = {
+      start: startPosition,
+      end: endPosition,
+      referencee: {
+        id: corespondingNodeId,
+        full: fullReference,
+      },
+      useFqn,
+      isVariable,
+    };
+    logger.debug(`Found reference ${JSON.stringify(ref)}`);
+    return [...carry, ref];
+  }, [] as Reference[]);
+}
+
+export async function findUsedReferences(
+  nodeIds: string[],
+  item: TerraformResourceBlock,
+): Promise<Reference[]> {
+  logger.debug(`findUsedReferences(${nodeIds}, ${item})`);
+  if (typeof item === "string") {
+    return await extractReferencesFromExpression(item, nodeIds, []);
+  }
+
+  if (typeof item !== "object" || item === null || item === undefined) {
+    return [];
+  }
+
+  if (Array.isArray(item)) {
+    return (
+      await Promise.all(item.map((i) => findUsedReferences(nodeIds, i)))
+    ).flat();
+  }
+
+  if (item && "dynamic" in item) {
+    const dyn = (item as any)["dynamic"];
+    const { for_each: _for_each, ...others } = dyn;
+    const dynamicRef = Object.keys(others)[0];
+    return await findUsedReferences([...nodeIds, dynamicRef], dyn);
+  }
+
+  return (
+    await Promise.all(
+      Object.values(item as Record<string, any>).map((i) =>
+        findUsedReferences(nodeIds, i),
+      ),
+    )
+  ).flat();
+}