parse-hcl 0.1.0

package/dist/parsers/localsParser.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Parser for Terraform locals blocks.
+ * Extracts local value definitions from locals blocks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalsParser = void 0;
+const bodyParser_1 = require("../utils/parser/bodyParser");
+/**
+ * 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
+ *   }
+ * }
+ * ```
+ */
+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) {
+        const parsed = (0, bodyParser_1.parseBlockBody)(block.body);
+        return Object.entries(parsed.attributes).map(([name, value]) => ({
+            name,
+            type: value.type,
+            value,
+            raw: value.raw,
+            source: block.source
+        }));
+    }
+}
+exports.LocalsParser = LocalsParser;

package/dist/parsers/outputParser.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Parser for Terraform output blocks.
+ * Extracts output value declarations with their expressions and metadata.
+ */
+import { HclBlock, OutputBlock } from '../types/blocks';
+/**
+ * Parser for Terraform output definition blocks.
+ *
+ * @example
+ * ```hcl
+ * output "instance_ip" {
+ *   description = "The public IP of the instance"
+ *   value       = aws_instance.web.public_ip
+ *   sensitive   = false
+ * }
+ * ```
+ */
+export declare class OutputParser {
+    /**
+     * Parses an output block into a structured OutputBlock.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed OutputBlock with all extracted fields
+     */
+    parse(block: HclBlock): OutputBlock;
+}

package/dist/parsers/outputParser.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Parser for Terraform output blocks.
+ * Extracts output value declarations with their expressions and metadata.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputParser = void 0;
+const bodyParser_1 = require("../utils/parser/bodyParser");
+const valueHelpers_1 = require("../utils/common/valueHelpers");
+/**
+ * Parser for Terraform output definition blocks.
+ *
+ * @example
+ * ```hcl
+ * output "instance_ip" {
+ *   description = "The public IP of the instance"
+ *   value       = aws_instance.web.public_ip
+ *   sensitive   = false
+ * }
+ * ```
+ */
+class OutputParser {
+    /**
+     * Parses an output block into a structured OutputBlock.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed OutputBlock with all extracted fields
+     */
+    parse(block) {
+        const name = block.labels[0] || 'unknown';
+        const parsed = (0, bodyParser_1.parseBlockBody)(block.body);
+        const description = (0, valueHelpers_1.literalString)(parsed.attributes.description) ?? parsed.attributes.description?.raw;
+        const value = parsed.attributes.value;
+        const sensitive = (0, valueHelpers_1.literalBoolean)(parsed.attributes.sensitive);
+        return {
+            name,
+            description,
+            value,
+            sensitive,
+            raw: block.raw,
+            source: block.source
+        };
+    }
+}
+exports.OutputParser = OutputParser;

package/dist/parsers/variableParser.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Parser for Terraform variable blocks.
+ * Extracts variable declarations with type constraints, defaults, and validations.
+ */
+import { HclBlock, TypeConstraint, VariableBlock } from '../types/blocks';
+/**
+ * Parser for Terraform variable definition blocks.
+ *
+ * @example
+ * ```hcl
+ * variable "instance_type" {
+ *   type        = string
+ *   default     = "t2.micro"
+ *   description = "EC2 instance type"
+ *   sensitive   = false
+ *
+ *   validation {
+ *     condition     = can(regex("^t[23]\\.", var.instance_type))
+ *     error_message = "Must be a t2 or t3 instance type."
+ *   }
+ * }
+ * ```
+ */
+export declare class VariableParser {
+    /**
+     * Parses a variable block into a structured VariableBlock.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed VariableBlock with all extracted fields
+     */
+    parse(block: HclBlock): VariableBlock;
+    /**
+     * Extracts validation rules from nested validation blocks.
+     * @param blocks - Nested blocks from the variable body
+     * @returns VariableValidation if a validation block exists
+     */
+    private extractValidation;
+}
+/**
+ * Parses a Terraform type constraint expression into a structured TypeConstraint.
+ *
+ * Supports:
+ * - Primitive types: string, number, bool, any
+ * - Collection types: list(T), set(T), map(T)
+ * - Structural types: object({ attr = type, ... }), tuple([type, ...])
+ * - Optional attributes: optional(type)
+ *
+ * @param raw - The raw type expression string
+ * @returns Parsed TypeConstraint
+ *
+ * @example
+ * ```typescript
+ * parseTypeConstraint('string')
+ * // { base: 'string', raw: 'string' }
+ *
+ * parseTypeConstraint('list(string)')
+ * // { base: 'list', element: { base: 'string', raw: 'string' }, raw: 'list(string)' }
+ *
+ * parseTypeConstraint('object({ name = string, age = optional(number) })')
+ * // { base: 'object', attributes: { name: {...}, age: {...} }, raw: '...' }
+ * ```
+ */
+export declare function parseTypeConstraint(raw: string): TypeConstraint;

package/dist/parsers/variableParser.js

@@ -0,0 +1,249 @@
+"use strict";
+/**
+ * Parser for Terraform variable blocks.
+ * Extracts variable declarations with type constraints, defaults, and validations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableParser = void 0;
+exports.parseTypeConstraint = parseTypeConstraint;
+const bodyParser_1 = require("../utils/parser/bodyParser");
+const valueHelpers_1 = require("../utils/common/valueHelpers");
+/**
+ * Parser for Terraform variable definition blocks.
+ *
+ * @example
+ * ```hcl
+ * variable "instance_type" {
+ *   type        = string
+ *   default     = "t2.micro"
+ *   description = "EC2 instance type"
+ *   sensitive   = false
+ *
+ *   validation {
+ *     condition     = can(regex("^t[23]\\.", var.instance_type))
+ *     error_message = "Must be a t2 or t3 instance type."
+ *   }
+ * }
+ * ```
+ */
+class VariableParser {
+    /**
+     * Parses a variable block into a structured VariableBlock.
+     * @param block - The raw HCL block to parse
+     * @returns Parsed VariableBlock with all extracted fields
+     */
+    parse(block) {
+        const name = block.labels[0] || 'unknown';
+        const parsed = (0, bodyParser_1.parseBlockBody)(block.body);
+        const description = (0, valueHelpers_1.literalString)(parsed.attributes.description) ?? parsed.attributes.description?.raw;
+        const typeRaw = (0, valueHelpers_1.literalString)(parsed.attributes.type) ?? parsed.attributes.type?.raw;
+        const sensitive = (0, valueHelpers_1.literalBoolean)(parsed.attributes.sensitive);
+        const nullable = (0, valueHelpers_1.literalBoolean)(parsed.attributes.nullable);
+        const validation = this.extractValidation(parsed.blocks);
+        // Parse type constraint if present
+        const typeConstraint = typeRaw ? parseTypeConstraint(typeRaw) : undefined;
+        return {
+            name,
+            description,
+            type: typeRaw,
+            typeConstraint,
+            default: parsed.attributes.default,
+            validation,
+            sensitive,
+            nullable,
+            raw: block.raw,
+            source: block.source
+        };
+    }
+    /**
+     * Extracts validation rules from nested validation blocks.
+     * @param blocks - Nested blocks from the variable body
+     * @returns VariableValidation if a validation block exists
+     */
+    extractValidation(blocks) {
+        const validationBlock = blocks.find((child) => child.type === 'validation');
+        if (!validationBlock) {
+            return undefined;
+        }
+        const condition = validationBlock.attributes.condition;
+        const errorMessage = validationBlock.attributes.error_message;
+        if (!condition && !errorMessage) {
+            return undefined;
+        }
+        return {
+            condition,
+            error_message: errorMessage
+        };
+    }
+}
+exports.VariableParser = VariableParser;
+/**
+ * Parses a Terraform type constraint expression into a structured TypeConstraint.
+ *
+ * Supports:
+ * - Primitive types: string, number, bool, any
+ * - Collection types: list(T), set(T), map(T)
+ * - Structural types: object({ attr = type, ... }), tuple([type, ...])
+ * - Optional attributes: optional(type)
+ *
+ * @param raw - The raw type expression string
+ * @returns Parsed TypeConstraint
+ *
+ * @example
+ * ```typescript
+ * parseTypeConstraint('string')
+ * // { base: 'string', raw: 'string' }
+ *
+ * parseTypeConstraint('list(string)')
+ * // { base: 'list', element: { base: 'string', raw: 'string' }, raw: 'list(string)' }
+ *
+ * parseTypeConstraint('object({ name = string, age = optional(number) })')
+ * // { base: 'object', attributes: { name: {...}, age: {...} }, raw: '...' }
+ * ```
+ */
+function parseTypeConstraint(raw) {
+    const trimmed = raw.trim();
+    // Primitive types
+    const primitives = ['string', 'number', 'bool', 'any'];
+    if (primitives.includes(trimmed)) {
+        return { base: trimmed, raw: trimmed };
+    }
+    // Check for collection types: list(T), set(T), map(T)
+    const collectionMatch = trimmed.match(/^(list|set|map)\s*\(\s*([\s\S]*)\s*\)$/);
+    if (collectionMatch) {
+        const [, base, inner] = collectionMatch;
+        return {
+            base,
+            element: parseTypeConstraint(inner),
+            raw: trimmed
+        };
+    }
+    // Check for optional(T)
+    const optionalMatch = trimmed.match(/^optional\s*\(\s*([\s\S]*)\s*\)$/);
+    if (optionalMatch) {
+        const inner = parseTypeConstraint(optionalMatch[1]);
+        return {
+            ...inner,
+            optional: true,
+            raw: trimmed
+        };
+    }
+    // Check for tuple([T1, T2, ...])
+    const tupleMatch = trimmed.match(/^tuple\s*\(\s*\[([\s\S]*)\]\s*\)$/);
+    if (tupleMatch) {
+        const elements = parseTupleElements(tupleMatch[1]);
+        const result = {
+            base: 'tuple',
+            raw: trimmed
+        };
+        if (elements.length > 0) {
+            result.elements = elements;
+        }
+        return result;
+    }
+    // Check for object({ attr = type, ... })
+    const objectMatch = trimmed.match(/^object\s*\(\s*\{([\s\S]*)\}\s*\)$/);
+    if (objectMatch) {
+        const attributes = parseObjectTypeAttributes(objectMatch[1]);
+        return {
+            base: 'object',
+            attributes,
+            raw: trimmed
+        };
+    }
+    // Default: treat as unknown/complex type expression
+    return { base: trimmed, raw: trimmed };
+}
+/**
+ * Parses tuple element types from the inner content of a tuple type.
+ * @param inner - The content inside tuple([ ... ])
+ * @returns Array of TypeConstraints for each element
+ */
+function parseTupleElements(inner) {
+    const elements = [];
+    const trimmed = inner.trim();
+    if (!trimmed) {
+        return elements;
+    }
+    // Split by commas, respecting nested structures
+    let depth = 0;
+    let current = '';
+    const entries = [];
+    for (let i = 0; i < trimmed.length; i++) {
+        const char = trimmed[i];
+        if (char === '(' || char === '{' || char === '[') {
+            depth++;
+            current += char;
+        }
+        else if (char === ')' || char === '}' || char === ']') {
+            depth--;
+            current += char;
+        }
+        else if (char === ',' && depth === 0) {
+            const entry = current.trim();
+            if (entry) {
+                entries.push(entry);
+            }
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    // Don't forget the last entry
+    const final = current.trim();
+    if (final) {
+        entries.push(final);
+    }
+    // Parse each element type
+    for (const entry of entries) {
+        elements.push(parseTypeConstraint(entry));
+    }
+    return elements;
+}
+/**
+ * Parses object type attributes from the inner content of an object type.
+ * @param inner - The content inside object({ ... })
+ * @returns Record of attribute names to their TypeConstraints
+ */
+function parseObjectTypeAttributes(inner) {
+    const attributes = {};
+    const trimmed = inner.trim();
+    if (!trimmed) {
+        return attributes;
+    }
+    // Simple parsing: split by commas (handling nested parentheses)
+    let depth = 0;
+    let current = '';
+    const entries = [];
+    for (let i = 0; i < trimmed.length; i++) {
+        const char = trimmed[i];
+        if (char === '(' || char === '{' || char === '[') {
+            depth++;
+            current += char;
+        }
+        else if (char === ')' || char === '}' || char === ']') {
+            depth--;
+            current += char;
+        }
+        else if (char === ',' && depth === 0) {
+            entries.push(current.trim());
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim()) {
+        entries.push(current.trim());
+    }
+    // Parse each entry (format: "name = type" or "name = optional(type)")
+    for (const entry of entries) {
+        const match = entry.match(/^(\w+)\s*=\s*([\s\S]+)$/);
+        if (match) {
+            const [, attrName, attrType] = match;
+            attributes[attrName] = parseTypeConstraint(attrType);
+        }
+    }
+    return attributes;
+}

package/dist/services/artifactParsers.d.ts

@@ -0,0 +1,12 @@
+import { TerraformPlanDocument, TerraformStateDocument, TfVarsDocument } from '../types/artifacts';
+export declare class TfVarsParser {
+    parseFile(filePath: string): TfVarsDocument;
+}
+export declare class TfStateParser {
+    parseFile(filePath: string): TerraformStateDocument;
+    parse(raw: unknown, source?: string): TerraformStateDocument;
+}
+export declare class TfPlanParser {
+    parseFile(filePath: string): TerraformPlanDocument;
+    parse(raw: unknown, source?: string): TerraformPlanDocument;
+}

package/dist/services/artifactParsers.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TfPlanParser = exports.TfStateParser = exports.TfVarsParser = void 0;
+const bodyParser_1 = require("../utils/parser/bodyParser");
+const fs_1 = require("../utils/common/fs");
+const terraformJsonParser_1 = require("./terraformJsonParser");
+class TfVarsParser {
+    parseFile(filePath) {
+        if (filePath.endsWith('.json')) {
+            const json = (0, fs_1.readJsonFile)(filePath);
+            const assignments = {};
+            for (const [key, val] of Object.entries(json)) {
+                assignments[key] = (0, terraformJsonParser_1.convertJsonValue)(val);
+            }
+            return {
+                source: filePath,
+                raw: JSON.stringify(json),
+                assignments
+            };
+        }
+        const raw = (0, fs_1.readTextFile)(filePath);
+        const parsed = (0, bodyParser_1.parseBlockBody)(raw);
+        return {
+            source: filePath,
+            raw,
+            assignments: parsed.attributes
+        };
+    }
+}
+exports.TfVarsParser = TfVarsParser;
+class TfStateParser {
+    parseFile(filePath) {
+        const raw = (0, fs_1.readJsonFile)(filePath);
+        return this.parse(raw, filePath);
+    }
+    parse(raw, source = '') {
+        const data = raw || {};
+        const resources = Array.isArray(data.resources) ? data.resources.map(normalizeStateResource) : [];
+        const outputs = normalizeStateOutputs(data.outputs || {});
+        return {
+            version: typeof data.version === 'number' ? data.version : Number(data.version) || 0,
+            terraform_version: typeof data.terraform_version === 'string' ? data.terraform_version : undefined,
+            serial: typeof data.serial === 'number' ? data.serial : undefined,
+            lineage: typeof data.lineage === 'string' ? data.lineage : undefined,
+            outputs,
+            resources,
+            raw,
+            source
+        };
+    }
+}
+exports.TfStateParser = TfStateParser;
+class TfPlanParser {
+    parseFile(filePath) {
+        const raw = (0, fs_1.readJsonFile)(filePath);
+        return this.parse(raw, filePath);
+    }
+    parse(raw, source = '') {
+        const data = raw || {};
+        const plannedValues = data.planned_values;
+        const resourceChanges = Array.isArray(data.resource_changes) ? data.resource_changes : [];
+        return {
+            format_version: typeof data.format_version === 'string' ? data.format_version : undefined,
+            terraform_version: typeof data.terraform_version === 'string' ? data.terraform_version : undefined,
+            planned_values: plannedValues
+                ? { root_module: normalizePlanModule(plannedValues.root_module || {}) }
+                : undefined,
+            resource_changes: resourceChanges.map(normalizePlanResourceChange),
+            raw,
+            source
+        };
+    }
+}
+exports.TfPlanParser = TfPlanParser;
+function normalizeStateOutputs(outputs) {
+    const result = {};
+    for (const [name, value] of Object.entries(outputs)) {
+        const output = value;
+        result[name] = {
+            value: output.value ?? value,
+            type: output.type,
+            sensitive: Boolean(output.sensitive)
+        };
+    }
+    return result;
+}
+function normalizeStateResource(resource) {
+    const data = resource || {};
+    const instancesRaw = Array.isArray(data.instances) ? data.instances : [];
+    return {
+        module: typeof data.module === 'string' ? data.module : undefined,
+        mode: data.mode === 'data' ? 'data' : 'managed',
+        type: typeof data.type === 'string' ? data.type : 'unknown',
+        name: typeof data.name === 'string' ? data.name : 'unknown',
+        provider: typeof data.provider === 'string' ? data.provider : undefined,
+        instances: instancesRaw.map(normalizeStateInstance)
+    };
+}
+function normalizeStateInstance(instance) {
+    const data = instance || {};
+    return {
+        index_key: typeof data.index_key === 'string' || typeof data.index_key === 'number'
+            ? data.index_key
+            : typeof data.index === 'string' || typeof data.index === 'number'
+                ? data.index
+                : undefined,
+        attributes: data.attributes || data.attributes_flat,
+        status: typeof data.status === 'string' ? data.status : undefined
+    };
+}
+function normalizePlanModule(module) {
+    const resourcesRaw = Array.isArray(module.resources) ? module.resources : [];
+    const childrenRaw = Array.isArray(module.child_modules) ? module.child_modules : [];
+    return {
+        address: typeof module.address === 'string' ? module.address : undefined,
+        resources: resourcesRaw.map(normalizePlanResource),
+        child_modules: childrenRaw.map((child) => normalizePlanModule(child || {}))
+    };
+}
+function normalizePlanResource(resource) {
+    const data = resource || {};
+    const address = typeof data.address === 'string' ? data.address : undefined;
+    return {
+        address: address ?? buildAddress(data),
+        mode: data.mode === 'data' ? 'data' : 'managed',
+        type: typeof data.type === 'string' ? data.type : 'unknown',
+        name: typeof data.name === 'string' ? data.name : 'unknown',
+        provider_name: typeof data.provider_name === 'string' ? data.provider_name : undefined,
+        values: data.values || undefined
+    };
+}
+function normalizePlanResourceChange(change) {
+    const data = change || {};
+    const changeData = data.change || {};
+    return {
+        address: typeof data.address === 'string' ? data.address : buildAddress(data),
+        module_address: typeof data.module_address === 'string' ? data.module_address : undefined,
+        mode: data.mode === 'data' ? 'data' : 'managed',
+        type: typeof data.type === 'string' ? data.type : 'unknown',
+        name: typeof data.name === 'string' ? data.name : 'unknown',
+        provider_name: typeof data.provider_name === 'string' ? data.provider_name : undefined,
+        change: {
+            actions: Array.isArray(changeData.actions) ? changeData.actions : [],
+            before: changeData.before,
+            after: changeData.after,
+            after_unknown: changeData.after_unknown || undefined,
+            before_sensitive: changeData.before_sensitive || undefined,
+            after_sensitive: changeData.after_sensitive || undefined
+        }
+    };
+}
+function buildAddress(data) {
+    const mode = data.mode === 'data' ? 'data' : 'resource';
+    const type = typeof data.type === 'string' ? data.type : 'unknown';
+    const name = typeof data.name === 'string' ? data.name : 'unknown';
+    return `${mode}.${type}.${name}`;
+}

package/dist/services/terraformJsonParser.d.ts

@@ -0,0 +1,16 @@
+import { TerraformDocument, Value } from '../types/blocks';
+type JsonConfig = Record<string, unknown>;
+export declare class TerraformJsonParser {
+    parseFile(filePath: string): TerraformDocument;
+    parse(json: JsonConfig, source?: string): TerraformDocument;
+    private parseTerraform;
+    private parseProviders;
+    private parseVariables;
+    private parseOutputs;
+    private parseLocals;
+    private parseModules;
+    private parseResources;
+    private parseData;
+}
+export declare function convertJsonValue(input: unknown): Value;
+export {};