parse-hcl 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const terraformParser_1 = require("./services/terraformParser");
+const artifactParsers_1 = require("./services/artifactParsers");
+const serializer_1 = require("./utils/serialization/serializer");
+function parseArgs(argv) {
+    const opts = { format: 'json', graph: false, prune: true };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === '--file' && argv[i + 1]) {
+            opts.file = argv[++i];
+        }
+        else if (arg === '--dir' && argv[i + 1]) {
+            opts.dir = argv[++i];
+        }
+        else if (arg === '--format' && argv[i + 1]) {
+            const fmt = argv[++i];
+            if (fmt === 'json' || fmt === 'yaml') {
+                opts.format = fmt;
+            }
+        }
+        else if (arg === '--graph') {
+            opts.graph = true;
+        }
+        else if (arg === '--no-prune') {
+            opts.prune = false;
+        }
+    }
+    return opts;
+}
+function main() {
+    const opts = parseArgs(process.argv.slice(2));
+    const parser = new terraformParser_1.TerraformParser();
+    if (!opts.file && !opts.dir) {
+        console.error('Usage: parse-hcl --file <path> | --dir <path> [--format json|yaml] [--graph] [--no-prune]');
+        process.exit(1);
+    }
+    if (opts.file) {
+        const filePath = path_1.default.resolve(opts.file);
+        const ext = path_1.default.extname(filePath);
+        if (ext.includes('tfvars')) {
+            emit(tfvarsParse(filePath), opts);
+            return;
+        }
+        if (ext === '.tfstate') {
+            emit(new artifactParsers_1.TfStateParser().parseFile(filePath), opts);
+            return;
+        }
+        if (ext === '.json' && filePath.endsWith('plan.json')) {
+            emit(new artifactParsers_1.TfPlanParser().parseFile(filePath), opts);
+            return;
+        }
+        const doc = parser.parseFile(filePath);
+        emit(doc, opts);
+        return;
+    }
+    if (opts.dir) {
+        const dirPath = path_1.default.resolve(opts.dir);
+        const result = parser.parseDirectory(dirPath);
+        const combined = result.combined ?? parser.combine(result.files.map((f) => f.document));
+        emit(opts.graph ? (0, serializer_1.toExport)(combined, { pruneEmpty: opts.prune }) : result, opts);
+    }
+}
+function tfvarsParse(filePath) {
+    return new artifactParsers_1.TfVarsParser().parseFile(filePath);
+}
+function emit(data, opts) {
+    if (opts.graph && !isTerraformDoc(data)) {
+        console.warn('Graph export requested but input is not a Terraform document; emitting raw output.');
+    }
+    if (opts.format === 'yaml') {
+        console.info((0, serializer_1.toYamlDocument)(data, { pruneEmpty: opts.prune }));
+        return;
+    }
+    if (opts.graph && isTerraformDoc(data)) {
+        console.info((0, serializer_1.toJsonExport)(data, { pruneEmpty: opts.prune }));
+        return;
+    }
+    console.info((0, serializer_1.toJson)(data, { pruneEmpty: opts.prune }));
+}
+function isTerraformDoc(data) {
+    return Boolean(data && typeof data === 'object' && 'resource' in data);
+}
+if (require.main === module) {
+    main();
+}

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * parse-hcl - Lightweight Terraform HCL Parser
+ *
+ * A TypeScript library for parsing Terraform configuration files (.tf, .tf.json)
+ * and related artifacts (tfvars, tfstate, plan.json).
+ *
+ * @packageDocumentation
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { TerraformParser, toJson, buildDependencyGraph } from 'parse-hcl';
+ *
+ * const parser = new TerraformParser();
+ *
+ * // Parse a single file
+ * const doc = parser.parseFile('main.tf');
+ *
+ * // Parse a directory
+ * const result = parser.parseDirectory('./terraform');
+ *
+ * // Build dependency graph
+ * const graph = buildDependencyGraph(doc);
+ *
+ * // Serialize to JSON
+ * const json = toJson(doc);
+ * ```
+ *
+ * @example Working with Artifacts
+ * ```typescript
+ * import { TfVarsParser, TfStateParser, TfPlanParser } from 'parse-hcl';
+ *
+ * // Parse tfvars
+ * const tfvars = new TfVarsParser().parseFile('terraform.tfvars');
+ *
+ * // Parse state
+ * const state = new TfStateParser().parseFile('terraform.tfstate');
+ *
+ * // Parse plan
+ * const plan = new TfPlanParser().parseFile('plan.json');
+ * ```
+ */
+export * from './types/blocks';
+export * from './types/artifacts';
+export * from './services/terraformParser';
+export * from './services/artifactParsers';
+export * from './services/terraformJsonParser';
+export * from './utils/serialization/serializer';
+export * from './utils/graph/graphBuilder';
+export * from './utils/common/errors';
+export { classifyValue } from './utils/parser/valueClassifier';
+export { parseTypeConstraint } from './parsers/variableParser';

package/dist/index.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * parse-hcl - Lightweight Terraform HCL Parser
+ *
+ * A TypeScript library for parsing Terraform configuration files (.tf, .tf.json)
+ * and related artifacts (tfvars, tfstate, plan.json).
+ *
+ * @packageDocumentation
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { TerraformParser, toJson, buildDependencyGraph } from 'parse-hcl';
+ *
+ * const parser = new TerraformParser();
+ *
+ * // Parse a single file
+ * const doc = parser.parseFile('main.tf');
+ *
+ * // Parse a directory
+ * const result = parser.parseDirectory('./terraform');
+ *
+ * // Build dependency graph
+ * const graph = buildDependencyGraph(doc);
+ *
+ * // Serialize to JSON
+ * const json = toJson(doc);
+ * ```
+ *
+ * @example Working with Artifacts
+ * ```typescript
+ * import { TfVarsParser, TfStateParser, TfPlanParser } from 'parse-hcl';
+ *
+ * // Parse tfvars
+ * const tfvars = new TfVarsParser().parseFile('terraform.tfvars');
+ *
+ * // Parse state
+ * const state = new TfStateParser().parseFile('terraform.tfstate');
+ *
+ * // Parse plan
+ * const plan = new TfPlanParser().parseFile('plan.json');
+ * ```
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTypeConstraint = exports.classifyValue = void 0;
+// Type definitions
+__exportStar(require("./types/blocks"), exports);
+__exportStar(require("./types/artifacts"), exports);
+// Main parsers
+__exportStar(require("./services/terraformParser"), exports);
+__exportStar(require("./services/artifactParsers"), exports);
+__exportStar(require("./services/terraformJsonParser"), exports);
+// Utilities
+__exportStar(require("./utils/serialization/serializer"), exports);
+__exportStar(require("./utils/graph/graphBuilder"), exports);
+__exportStar(require("./utils/common/errors"), exports);
+// Re-export commonly used utilities
+var valueClassifier_1 = require("./utils/parser/valueClassifier");
+Object.defineProperty(exports, "classifyValue", { enumerable: true, get: function () { return valueClassifier_1.classifyValue; } });
+var variableParser_1 = require("./parsers/variableParser");
+Object.defineProperty(exports, "parseTypeConstraint", { enumerable: true, get: function () { return variableParser_1.parseTypeConstraint; } });

package/dist/parsers/genericParser.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Generic parsers for Terraform blocks.
+ * Handles resource, data, provider, module, terraform settings, and unknown block types.
+ */
+import { DataBlock, GenericBlock, ModuleBlock, ProviderBlock, ResourceBlock, TerraformSettingsBlock } from '../types/blocks';
+import { HclBlock } from '../types/blocks';
+/**
+ * Parser for terraform settings blocks.
+ *
+ * @example
+ * ```hcl
+ * terraform {
+ *   required_version = ">= 1.0.0"
+ *   required_providers {
+ *     aws = {
+ *       source  = "hashicorp/aws"
+ *       version = "~> 4.0"
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class TerraformSettingsParser {
+    /**
+     * Parses a terraform settings block.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed TerraformSettingsBlock
+     */
+    parse(block: HclBlock): TerraformSettingsBlock;
+}
+/**
+ * Parser for provider configuration blocks.
+ *
+ * @example
+ * ```hcl
+ * provider "aws" {
+ *   alias  = "west"
+ *   region = "us-west-2"
+ * }
+ * ```
+ */
+export declare class ProviderParser {
+    /**
+     * Parses a provider configuration block.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed ProviderBlock with name, alias, and properties
+     */
+    parse(block: HclBlock): ProviderBlock;
+}
+/**
+ * Parser for module call blocks.
+ *
+ * @example
+ * ```hcl
+ * module "vpc" {
+ *   source  = "terraform-aws-modules/vpc/aws"
+ *   version = "3.0.0"
+ *
+ *   name = "my-vpc"
+ *   cidr = "10.0.0.0/16"
+ * }
+ * ```
+ */
+export declare class ModuleParser {
+    /**
+     * Parses a module call block.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed ModuleBlock with name and all properties
+     */
+    parse(block: HclBlock): ModuleBlock;
+}
+/**
+ * Parser for resource definition blocks.
+ * Separates meta-arguments (count, for_each, depends_on, etc.) from resource properties.
+ *
+ * @example
+ * ```hcl
+ * resource "aws_instance" "web" {
+ *   count         = 3
+ *   ami           = var.ami_id
+ *   instance_type = "t2.micro"
+ *
+ *   tags = {
+ *     Name = "web-${count.index}"
+ *   }
+ *
+ *   dynamic "ebs_block_device" {
+ *     for_each = var.ebs_volumes
+ *     content {
+ *       device_name = ebs_block_device.value.device_name
+ *       volume_size = ebs_block_device.value.size
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class ResourceParser {
+    /**
+     * Parses a resource block, separating properties, meta-arguments, and dynamic blocks.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed ResourceBlock with separated concerns
+     */
+    parse(block: HclBlock): ResourceBlock;
+    /**
+     * Extracts dynamic blocks from nested blocks.
+     * @param blocks - Nested blocks from the resource body
+     * @returns Array of DynamicBlock objects
+     */
+    private extractDynamicBlocks;
+}
+/**
+ * Parser for data source blocks.
+ *
+ * @example
+ * ```hcl
+ * data "aws_ami" "ubuntu" {
+ *   most_recent = true
+ *
+ *   filter {
+ *     name   = "name"
+ *     values = ["ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*"]
+ *   }
+ *
+ *   owners = ["099720109477"]
+ * }
+ * ```
+ */
+export declare class DataParser {
+    /**
+     * Parses a data source block.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed DataBlock with type, name, properties, and nested blocks
+     */
+    parse(block: HclBlock): DataBlock;
+}
+/**
+ * Parser for generic/unknown block types.
+ * Used for moved, import, check, terraform_data, and unrecognized blocks.
+ *
+ * @example
+ * ```hcl
+ * moved {
+ *   from = aws_instance.old
+ *   to   = aws_instance.new
+ * }
+ *
+ * import {
+ *   to = aws_instance.example
+ *   id = "i-1234567890abcdef0"
+ * }
+ *
+ * check "health" {
+ *   assert {
+ *     condition     = data.http.health.status_code == 200
+ *     error_message = "Health check failed"
+ *   }
+ * }
+ * ```
+ */
+export declare class GenericBlockParser {
+    /**
+     * Parses a generic block into a GenericBlock structure.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed GenericBlock with type, labels, properties, and nested blocks
+     */
+    parse(block: HclBlock): GenericBlock;
+}

package/dist/parsers/genericParser.js

@@ -0,0 +1,268 @@
+"use strict";
+/**
+ * Generic parsers for Terraform blocks.
+ * Handles resource, data, provider, module, terraform settings, and unknown block types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericBlockParser = exports.DataParser = exports.ResourceParser = exports.ModuleParser = exports.ProviderParser = exports.TerraformSettingsParser = void 0;
+const bodyParser_1 = require("../utils/parser/bodyParser");
+const valueHelpers_1 = require("../utils/common/valueHelpers");
+/** Meta-argument keys that are separated from resource properties */
+const META_KEYS = new Set(['count', 'for_each', 'provider', 'depends_on', 'lifecycle']);
+/**
+ * Parser for terraform settings blocks.
+ *
+ * @example
+ * ```hcl
+ * terraform {
+ *   required_version = ">= 1.0.0"
+ *   required_providers {
+ *     aws = {
+ *       source  = "hashicorp/aws"
+ *       version = "~> 4.0"
+ *     }
+ *   }
+ * }
+ * ```
+ */
+class TerraformSettingsParser {
+    /**
+     * Parses a terraform settings block.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed TerraformSettingsBlock
+     */
+    parse(block) {
+        const parsed = (0, bodyParser_1.parseBlockBody)(block.body);
+        return {
+            properties: parsed.attributes,
+            raw: block.raw,
+            source: block.source
+        };
+    }
+}
+exports.TerraformSettingsParser = TerraformSettingsParser;
+/**
+ * Parser for provider configuration blocks.
+ *
+ * @example
+ * ```hcl
+ * provider "aws" {
+ *   alias  = "west"
+ *   region = "us-west-2"
+ * }
+ * ```
+ */
+class ProviderParser {
+    /**
+     * Parses a provider configuration block.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed ProviderBlock with name, alias, and properties
+     */
+    parse(block) {
+        const name = block.labels[0] || 'default';
+        const parsed = (0, bodyParser_1.parseBlockBody)(block.body);
+        return {
+            name,
+            alias: (0, valueHelpers_1.literalString)(parsed.attributes.alias) ?? parsed.attributes.alias?.raw,
+            properties: parsed.attributes,
+            raw: block.raw,
+            source: block.source
+        };
+    }
+}
+exports.ProviderParser = ProviderParser;
+/**
+ * Parser for module call blocks.
+ *
+ * @example
+ * ```hcl
+ * module "vpc" {
+ *   source  = "terraform-aws-modules/vpc/aws"
+ *   version = "3.0.0"
+ *
+ *   name = "my-vpc"
+ *   cidr = "10.0.0.0/16"
+ * }
+ * ```
+ */
+class ModuleParser {
+    /**
+     * Parses a module call block.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed ModuleBlock with name and all properties
+     */
+    parse(block) {
+        const name = block.labels[0] || 'unnamed';
+        const parsed = (0, bodyParser_1.parseBlockBody)(block.body);
+        return {
+            name,
+            properties: parsed.attributes,
+            raw: block.raw,
+            source: block.source
+        };
+    }
+}
+exports.ModuleParser = ModuleParser;
+/**
+ * Parser for resource definition blocks.
+ * Separates meta-arguments (count, for_each, depends_on, etc.) from resource properties.
+ *
+ * @example
+ * ```hcl
+ * resource "aws_instance" "web" {
+ *   count         = 3
+ *   ami           = var.ami_id
+ *   instance_type = "t2.micro"
+ *
+ *   tags = {
+ *     Name = "web-${count.index}"
+ *   }
+ *
+ *   dynamic "ebs_block_device" {
+ *     for_each = var.ebs_volumes
+ *     content {
+ *       device_name = ebs_block_device.value.device_name
+ *       volume_size = ebs_block_device.value.size
+ *     }
+ *   }
+ * }
+ * ```
+ */
+class ResourceParser {
+    /**
+     * Parses a resource block, separating properties, meta-arguments, and dynamic blocks.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed ResourceBlock with separated concerns
+     */
+    parse(block) {
+        const [type, name] = block.labels;
+        const parsed = (0, bodyParser_1.parseBlockBody)(block.body);
+        const meta = {};
+        const properties = {};
+        // Separate meta-arguments from properties
+        for (const [key, value] of Object.entries(parsed.attributes)) {
+            if (META_KEYS.has(key)) {
+                meta[key] = value;
+            }
+            else {
+                properties[key] = value;
+            }
+        }
+        return {
+            type: type || 'unknown',
+            name: name || 'unnamed',
+            properties,
+            blocks: parsed.blocks.filter((child) => child.type !== 'dynamic'),
+            dynamic_blocks: this.extractDynamicBlocks(parsed.blocks),
+            meta,
+            raw: block.raw,
+            source: block.source
+        };
+    }
+    /**
+     * Extracts dynamic blocks from nested blocks.
+     * @param blocks - Nested blocks from the resource body
+     * @returns Array of DynamicBlock objects
+     */
+    extractDynamicBlocks(blocks) {
+        const dynamicBlocks = [];
+        for (const block of blocks) {
+            if (block.type !== 'dynamic') {
+                continue;
+            }
+            const label = block.labels[0] || 'dynamic';
+            const for_each = block.attributes.for_each;
+            const iterator = (0, valueHelpers_1.literalString)(block.attributes.iterator);
+            const contentBlock = block.blocks.find((child) => child.type === 'content');
+            dynamicBlocks.push({
+                label,
+                for_each,
+                iterator,
+                content: contentBlock?.attributes || {},
+                raw: block.raw
+            });
+        }
+        return dynamicBlocks;
+    }
+}
+exports.ResourceParser = ResourceParser;
+/**
+ * Parser for data source blocks.
+ *
+ * @example
+ * ```hcl
+ * data "aws_ami" "ubuntu" {
+ *   most_recent = true
+ *
+ *   filter {
+ *     name   = "name"
+ *     values = ["ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*"]
+ *   }
+ *
+ *   owners = ["099720109477"]
+ * }
+ * ```
+ */
+class DataParser {
+    /**
+     * Parses a data source block.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed DataBlock with type, name, properties, and nested blocks
+     */
+    parse(block) {
+        const [dataType, name] = block.labels;
+        const parsed = (0, bodyParser_1.parseBlockBody)(block.body);
+        return {
+            dataType: dataType || 'unknown',
+            name: name || 'unnamed',
+            properties: parsed.attributes,
+            blocks: parsed.blocks,
+            raw: block.raw,
+            source: block.source
+        };
+    }
+}
+exports.DataParser = DataParser;
+/**
+ * Parser for generic/unknown block types.
+ * Used for moved, import, check, terraform_data, and unrecognized blocks.
+ *
+ * @example
+ * ```hcl
+ * moved {
+ *   from = aws_instance.old
+ *   to   = aws_instance.new
+ * }
+ *
+ * import {
+ *   to = aws_instance.example
+ *   id = "i-1234567890abcdef0"
+ * }
+ *
+ * check "health" {
+ *   assert {
+ *     condition     = data.http.health.status_code == 200
+ *     error_message = "Health check failed"
+ *   }
+ * }
+ * ```
+ */
+class GenericBlockParser {
+    /**
+     * Parses a generic block into a GenericBlock structure.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed GenericBlock with type, labels, properties, and nested blocks
+     */
+    parse(block) {
+        const parsed = (0, bodyParser_1.parseBlockBody)(block.body);
+        return {
+            type: block.keyword,
+            labels: block.labels,
+            properties: parsed.attributes,
+            blocks: parsed.blocks,
+            raw: block.raw,
+            source: block.source
+        };
+    }
+}
+exports.GenericBlockParser = GenericBlockParser;

package/dist/parsers/localsParser.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Parser for Terraform locals blocks.
+ * Extracts local value definitions from locals blocks.
+ */
+import { HclBlock, LocalValue } from '../types/blocks';
+/**
+ * Parser for Terraform locals definition blocks.
+ * Converts a single locals block into multiple LocalValue entries.
+ *
+ * @example
+ * ```hcl
+ * locals {
+ *   environment = "production"
+ *   tags = {
+ *     Name = "example"
+ *     Env  = local.environment
+ *   }
+ * }
+ * ```
+ */
+export declare class LocalsParser {
+    /**
+     * Parses a locals block into an array of LocalValue objects.
+     * Each attribute in the locals block becomes a separate LocalValue.
+     *
+     * @param block - The raw HCL block to parse
+     * @returns Array of LocalValue objects, one per local definition
+     */
+    parse(block: HclBlock): LocalValue[];
+}