@cdktn/hcl2cdk 0.21.0

package/lib/references.js

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

package/lib/schema.d.ts

@@ -0,0 +1,297 @@
+import * as z from "zod";
+declare const outputConfig: z.ZodArray<z.ZodObject<{
+    value: z.ZodOptional<z.ZodAny>;
+    description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    sensitive: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    depends_on: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    value?: any;
+    description?: string | undefined;
+    sensitive?: boolean | undefined;
+    depends_on?: string | undefined;
+}, {
+    value?: any;
+    description?: string | undefined;
+    sensitive?: boolean | undefined;
+    depends_on?: string | undefined;
+}>, "many">;
+export type Output = z.infer<typeof outputConfig>;
+declare const variableConfig: z.ZodArray<z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodAny>;
+    description: z.ZodOptional<z.ZodString>;
+    sensitive: z.ZodOptional<z.ZodBoolean>;
+    nullable: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    validation: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        error_message: z.ZodString;
+        condition: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        error_message: string;
+        condition?: any;
+    }, {
+        error_message: string;
+        condition?: any;
+    }>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    type?: string | undefined;
+    default?: any;
+    description?: string | undefined;
+    sensitive?: boolean | undefined;
+    nullable?: boolean | undefined;
+    validation?: {
+        error_message: string;
+        condition?: any;
+    }[] | undefined;
+}, {
+    type?: string | undefined;
+    default?: any;
+    description?: string | undefined;
+    sensitive?: boolean | undefined;
+    nullable?: boolean | undefined;
+    validation?: {
+        error_message: string;
+        condition?: any;
+    }[] | undefined;
+}>, "many">;
+export type Variable = z.infer<typeof variableConfig>;
+declare const providerConfig: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">;
+export type Provider = z.infer<typeof providerConfig>;
+declare const moduleConfig: z.ZodArray<z.ZodObject<{
+    source: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    source: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    source: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>, "many">;
+export type Module = z.infer<typeof moduleConfig>;
+declare const resourceConfig: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">;
+export type Resource = z.infer<typeof resourceConfig>;
+export type Data = Resource;
+declare const importConfig: z.ZodObject<{
+    to: z.ZodString;
+    id: z.ZodString;
+    provider: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    to: string;
+    id: string;
+    provider?: any;
+}, {
+    to: string;
+    id: string;
+    provider?: any;
+}>;
+export type Import = z.infer<typeof importConfig>;
+declare const terraformConfig: z.ZodObject<{
+    required_version: z.ZodOptional<z.ZodString>;
+    required_providers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        source?: string | undefined;
+        version?: string | undefined;
+    }, {
+        source?: string | undefined;
+        version?: string | undefined;
+    }>, z.ZodString]>>, "many">>;
+    backend: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    backend?: Record<string, Record<string, any>[]> | undefined;
+    required_providers?: Record<string, string | {
+        source?: string | undefined;
+        version?: string | undefined;
+    }>[] | undefined;
+    required_version?: string | undefined;
+}, {
+    backend?: Record<string, Record<string, any>[]> | undefined;
+    required_providers?: Record<string, string | {
+        source?: string | undefined;
+        version?: string | undefined;
+    }>[] | undefined;
+    required_version?: string | undefined;
+}>;
+export type TerraformConfig = z.infer<typeof terraformConfig>;
+export declare const schema: z.ZodObject<{
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>>>;
+    import: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        to: z.ZodString;
+        id: z.ZodString;
+        provider: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        to: string;
+        id: string;
+        provider?: any;
+    }, {
+        to: string;
+        id: string;
+        provider?: any;
+    }>, "many">>;
+    locals: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>;
+    module: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>, "many">>>;
+    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        value: z.ZodOptional<z.ZodAny>;
+        description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        sensitive: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        depends_on: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        value?: any;
+        description?: string | undefined;
+        sensitive?: boolean | undefined;
+        depends_on?: string | undefined;
+    }, {
+        value?: any;
+        description?: string | undefined;
+        sensitive?: boolean | undefined;
+        depends_on?: string | undefined;
+    }>, "many">>>;
+    provider: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>>;
+    resource: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>>>;
+    terraform: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        required_version: z.ZodOptional<z.ZodString>;
+        required_providers: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+            source: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            source?: string | undefined;
+            version?: string | undefined;
+        }, {
+            source?: string | undefined;
+            version?: string | undefined;
+        }>, z.ZodString]>>, "many">>;
+        backend: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        backend?: Record<string, Record<string, any>[]> | undefined;
+        required_providers?: Record<string, string | {
+            source?: string | undefined;
+            version?: string | undefined;
+        }>[] | undefined;
+        required_version?: string | undefined;
+    }, {
+        backend?: Record<string, Record<string, any>[]> | undefined;
+        required_providers?: Record<string, string | {
+            source?: string | undefined;
+            version?: string | undefined;
+        }>[] | undefined;
+        required_version?: string | undefined;
+    }>, "many">>;
+    variable: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+        type: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodAny>;
+        description: z.ZodOptional<z.ZodString>;
+        sensitive: z.ZodOptional<z.ZodBoolean>;
+        nullable: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        validation: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+            error_message: z.ZodString;
+            condition: z.ZodAny;
+        }, "strip", z.ZodTypeAny, {
+            error_message: string;
+            condition?: any;
+        }, {
+            error_message: string;
+            condition?: any;
+        }>, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: string | undefined;
+        default?: any;
+        description?: string | undefined;
+        sensitive?: boolean | undefined;
+        nullable?: boolean | undefined;
+        validation?: {
+            error_message: string;
+            condition?: any;
+        }[] | undefined;
+    }, {
+        type?: string | undefined;
+        default?: any;
+        description?: string | undefined;
+        sensitive?: boolean | undefined;
+        nullable?: boolean | undefined;
+        validation?: {
+            error_message: string;
+            condition?: any;
+        }[] | undefined;
+    }>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    terraform?: {
+        backend?: Record<string, Record<string, any>[]> | undefined;
+        required_providers?: Record<string, string | {
+            source?: string | undefined;
+            version?: string | undefined;
+        }>[] | undefined;
+        required_version?: string | undefined;
+    }[] | undefined;
+    provider?: Record<string, Record<string, any>[]> | undefined;
+    module?: Record<string, z.objectOutputType<{
+        source: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[]> | undefined;
+    resource?: Record<string, Record<string, Record<string, any>[]>> | undefined;
+    data?: Record<string, Record<string, Record<string, any>[]>> | undefined;
+    output?: Record<string, {
+        value?: any;
+        description?: string | undefined;
+        sensitive?: boolean | undefined;
+        depends_on?: string | undefined;
+    }[]> | undefined;
+    variable?: Record<string, {
+        type?: string | undefined;
+        default?: any;
+        description?: string | undefined;
+        sensitive?: boolean | undefined;
+        nullable?: boolean | undefined;
+        validation?: {
+            error_message: string;
+            condition?: any;
+        }[] | undefined;
+    }[]> | undefined;
+    import?: {
+        to: string;
+        id: string;
+        provider?: any;
+    }[] | undefined;
+    locals?: Record<string, any>[] | undefined;
+}, {
+    terraform?: {
+        backend?: Record<string, Record<string, any>[]> | undefined;
+        required_providers?: Record<string, string | {
+            source?: string | undefined;
+            version?: string | undefined;
+        }>[] | undefined;
+        required_version?: string | undefined;
+    }[] | undefined;
+    provider?: Record<string, Record<string, any>[]> | undefined;
+    module?: Record<string, z.objectInputType<{
+        source: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[]> | undefined;
+    resource?: Record<string, Record<string, Record<string, any>[]>> | undefined;
+    data?: Record<string, Record<string, Record<string, any>[]>> | undefined;
+    output?: Record<string, {
+        value?: any;
+        description?: string | undefined;
+        sensitive?: boolean | undefined;
+        depends_on?: string | undefined;
+    }[]> | undefined;
+    variable?: Record<string, {
+        type?: string | undefined;
+        default?: any;
+        description?: string | undefined;
+        sensitive?: boolean | undefined;
+        nullable?: boolean | undefined;
+        validation?: {
+            error_message: string;
+            condition?: any;
+        }[] | undefined;
+    }[]> | undefined;
+    import?: {
+        to: string;
+        id: string;
+        provider?: any;
+    }[] | undefined;
+    locals?: Record<string, any>[] | undefined;
+}>;
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/lib/schema.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const z = __importStar(require("zod"));
+const tfObject = (config) => 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(),
+});
+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(),
+});
+const providerConfig = z.array(z.record(z.any()));
+const moduleConfig = z.array(z.object({ source: z.string() }).nonstrict());
+const resourceConfig = z.array(z.record(z.any()));
+const importConfig = z.object({
+    to: z.string(),
+    id: z.string(),
+    provider: z.any().optional(),
+});
+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();
+exports.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();
+//# sourceMappingURL=data:application/json;base64,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

package/lib/telemetryAllowList.json

@@ -0,0 +1,24 @@
+{
+    "providers": [
+        "aws",
+        "datadog",
+        "pagerduty",
+        "azurerm",
+        "google",
+        "docker",
+        "random",
+        "kubernetes",
+        "null",
+        "vault",
+        "github",
+        "azuread",
+        "archive",
+        "google-beta",
+        "kubectl",
+        "cloudflare",
+        "signalfx",
+        "openstack",
+        "external",
+        "template"
+    ]
+}

package/lib/terraformSchema.d.ts

@@ -0,0 +1,6 @@
+import { ProviderSchema, BlockType, AttributeType, Schema } from "@cdktn/commons";
+import { ProgramScope } from "./types";
+export declare function getTypeAtPath(schema: ProviderSchema, path: string): Schema | BlockType | AttributeType | null;
+export declare const isMapAttribute: (attribute: Schema | AttributeType | BlockType | null) => boolean;
+export declare function getDesiredType(scope: ProgramScope, path: string): AttributeType;
+//# sourceMappingURL=terraformSchema.d.ts.map