parse-hcl 0.1.0

package/dist/services/terraformJsonParser.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerraformJsonParser = void 0;
+exports.convertJsonValue = convertJsonValue;
+const blocks_1 = require("../types/blocks");
+const fs_1 = require("../utils/common/fs");
+const valueClassifier_1 = require("../utils/parser/valueClassifier");
+class TerraformJsonParser {
+    parseFile(filePath) {
+        const json = (0, fs_1.readJsonFile)(filePath);
+        return this.parse(json, filePath);
+    }
+    parse(json, source = 'json-config') {
+        const doc = (0, blocks_1.createEmptyDocument)();
+        this.parseTerraform(json.terraform, doc, source);
+        this.parseProviders(json.provider, doc, source);
+        this.parseVariables(json.variable, doc, source);
+        this.parseOutputs(json.output, doc, source);
+        this.parseLocals(json.locals, doc, source);
+        this.parseModules(json.module, doc, source);
+        this.parseResources(json.resource, doc, source);
+        this.parseData(json.data, doc, source);
+        return doc;
+    }
+    parseTerraform(value, doc, source) {
+        if (!Array.isArray(value))
+            return;
+        for (const item of value) {
+            if (item && typeof item === 'object') {
+                doc.terraform.push({
+                    properties: convertAttributes(item),
+                    raw: JSON.stringify(item),
+                    source
+                });
+            }
+        }
+    }
+    parseProviders(value, doc, source) {
+        if (!value || typeof value !== 'object')
+            return;
+        for (const [name, config] of Object.entries(value)) {
+            const configs = Array.isArray(config) ? config : [config];
+            for (const aliasCfg of configs) {
+                if (!isRecord(aliasCfg))
+                    continue;
+                const alias = typeof aliasCfg.alias === 'string' ? aliasCfg.alias : undefined;
+                doc.provider.push({
+                    name,
+                    alias,
+                    properties: convertAttributes(aliasCfg),
+                    raw: JSON.stringify(aliasCfg),
+                    source
+                });
+            }
+        }
+    }
+    parseVariables(value, doc, source) {
+        if (!value || typeof value !== 'object')
+            return;
+        for (const [name, config] of Object.entries(value)) {
+            const cfg = config || {};
+            doc.variable.push({
+                name,
+                description: typeof cfg.description === 'string' ? cfg.description : undefined,
+                type: typeof cfg.type === 'string' ? cfg.type : undefined,
+                default: cfg.default !== undefined ? convertJsonValue(cfg.default) : undefined,
+                validation: undefined,
+                sensitive: typeof cfg.sensitive === 'boolean' ? cfg.sensitive : undefined,
+                raw: JSON.stringify(cfg),
+                source
+            });
+        }
+    }
+    parseOutputs(value, doc, source) {
+        if (!value || typeof value !== 'object')
+            return;
+        for (const [name, config] of Object.entries(value)) {
+            const cfg = config || {};
+            doc.output.push({
+                name,
+                description: typeof cfg.description === 'string' ? cfg.description : undefined,
+                value: convertJsonValue(cfg.value),
+                sensitive: typeof cfg.sensitive === 'boolean' ? cfg.sensitive : undefined,
+                raw: JSON.stringify(cfg),
+                source
+            });
+        }
+    }
+    parseLocals(value, doc, source) {
+        if (!value || typeof value !== 'object')
+            return;
+        for (const [name, val] of Object.entries(value)) {
+            const converted = convertJsonValue(val);
+            doc.locals.push({
+                name,
+                type: converted.type,
+                value: converted,
+                raw: converted.raw,
+                source
+            });
+        }
+    }
+    parseModules(value, doc, source) {
+        if (!value || typeof value !== 'object')
+            return;
+        for (const [name, config] of Object.entries(value)) {
+            const cfg = config || {};
+            doc.module.push({
+                name,
+                properties: convertAttributes(cfg),
+                raw: JSON.stringify(cfg),
+                source
+            });
+        }
+    }
+    parseResources(value, doc, source) {
+        if (!value || typeof value !== 'object')
+            return;
+        for (const [type, resourceByName] of Object.entries(value)) {
+            if (!resourceByName || typeof resourceByName !== 'object')
+                continue;
+            for (const [name, configList] of Object.entries(resourceByName)) {
+                const items = Array.isArray(configList) ? configList : [configList];
+                for (const cfg of items) {
+                    if (!cfg || typeof cfg !== 'object')
+                        continue;
+                    const parsed = convertAttributes(cfg);
+                    doc.resource.push({
+                        type,
+                        name,
+                        properties: parsed,
+                        blocks: [],
+                        dynamic_blocks: [],
+                        meta: {},
+                        raw: JSON.stringify(cfg),
+                        source
+                    });
+                }
+            }
+        }
+    }
+    parseData(value, doc, source) {
+        if (!value || typeof value !== 'object')
+            return;
+        for (const [dataType, dataByName] of Object.entries(value)) {
+            if (!dataByName || typeof dataByName !== 'object')
+                continue;
+            for (const [name, configList] of Object.entries(dataByName)) {
+                const items = Array.isArray(configList) ? configList : [configList];
+                for (const cfg of items) {
+                    if (!cfg || typeof cfg !== 'object')
+                        continue;
+                    const parsed = convertAttributes(cfg);
+                    doc.data.push({
+                        dataType,
+                        name,
+                        properties: parsed,
+                        blocks: [],
+                        raw: JSON.stringify(cfg),
+                        source
+                    });
+                }
+            }
+        }
+    }
+}
+exports.TerraformJsonParser = TerraformJsonParser;
+function convertAttributes(obj) {
+    const out = {};
+    for (const [key, val] of Object.entries(obj)) {
+        if (key === 'alias')
+            continue;
+        out[key] = convertJsonValue(val);
+    }
+    return out;
+}
+function convertJsonValue(input) {
+    if (input === null) {
+        return { type: 'literal', value: null, raw: 'null' };
+    }
+    if (typeof input === 'string') {
+        if (looksLikeExpression(input)) {
+            return (0, valueClassifier_1.classifyValue)(input);
+        }
+        return { type: 'literal', value: input, raw: input };
+    }
+    if (typeof input === 'number' || typeof input === 'boolean') {
+        return { type: 'literal', value: input, raw: String(input) };
+    }
+    if (Array.isArray(input)) {
+        return {
+            type: 'array',
+            value: input.map((item) => convertJsonValue(item)),
+            raw: JSON.stringify(input)
+        };
+    }
+    if (typeof input === 'object') {
+        const entries = Object.entries(input);
+        const value = {};
+        for (const [key, val] of entries) {
+            value[key] = convertJsonValue(val);
+        }
+        return { type: 'object', value, raw: JSON.stringify(input) };
+    }
+    return { type: 'literal', value: String(input), raw: String(input) };
+}
+function looksLikeExpression(value) {
+    return value.includes('${') || /^[\w.]+\(/.test(value) || /^[\w.]+$/.test(value);
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}

package/dist/services/terraformParser.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Main Terraform configuration parser.
+ * Parses .tf and .tf.json files into structured TerraformDocument objects.
+ */
+import { DirectoryParseOptions, DirectoryParseResult, TerraformDocument } from '../types/blocks';
+/**
+ * Main parser for Terraform configuration files.
+ * Supports both HCL (.tf) and JSON (.tf.json) formats.
+ *
+ * @example
+ * ```typescript
+ * const parser = new TerraformParser();
+ *
+ * // Parse a single file
+ * const doc = parser.parseFile('main.tf');
+ * console.log(`Found ${doc.resource.length} resources`);
+ *
+ * // Parse a directory
+ * const result = parser.parseDirectory('./terraform');
+ * console.log(`Parsed ${result.files.length} files`);
+ *
+ * // Access parsed elements
+ * for (const resource of doc.resource) {
+ *   console.log(`${resource.type}.${resource.name}`);
+ * }
+ * ```
+ */
+export declare class TerraformParser {
+    private readonly scanner;
+    private readonly variableParser;
+    private readonly outputParser;
+    private readonly localsParser;
+    private readonly moduleParser;
+    private readonly providerParser;
+    private readonly resourceParser;
+    private readonly dataParser;
+    private readonly terraformSettingsParser;
+    private readonly genericBlockParser;
+    private readonly jsonParser;
+    /**
+     * Parses a Terraform configuration file.
+     * Automatically detects format (.tf vs .tf.json) and uses appropriate parser.
+     *
+     * @param filePath - Path to the Terraform file
+     * @returns Parsed TerraformDocument containing all blocks
+     * @throws {Error} If file cannot be read or parsed
+     *
+     * @example
+     * ```typescript
+     * const doc = parser.parseFile('main.tf');
+     * console.log(doc.variable[0].name);
+     * ```
+     */
+    parseFile(filePath: string): TerraformDocument;
+    /**
+     * Parses all Terraform files in a directory (recursively).
+     *
+     * @param dirPath - Path to the directory
+     * @param options - Parsing options
+     * @returns DirectoryParseResult with combined document and per-file results
+     * @throws {Error} If directory does not exist or is not accessible
+     *
+     * @example
+     * ```typescript
+     * // Parse with defaults (aggregate + per-file results)
+     * const result = parser.parseDirectory('./terraform');
+     *
+     * // Parse without aggregation
+     * const result = parser.parseDirectory('./terraform', { aggregate: false });
+     *
+     * // Parse without per-file results
+     * const result = parser.parseDirectory('./terraform', { includePerFile: false });
+     * ```
+     */
+    parseDirectory(dirPath: string, options?: DirectoryParseOptions): DirectoryParseResult;
+    /**
+     * Combines multiple TerraformDocuments into a single document.
+     * Useful for aggregating configurations from multiple files.
+     *
+     * @param documents - Array of documents to combine
+     * @returns A single TerraformDocument containing all blocks
+     *
+     * @example
+     * ```typescript
+     * const doc1 = parser.parseFile('main.tf');
+     * const doc2 = parser.parseFile('variables.tf');
+     * const combined = parser.combine([doc1, doc2]);
+     * ```
+     */
+    combine(documents: TerraformDocument[]): TerraformDocument;
+}

package/dist/services/terraformParser.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * Main Terraform configuration parser.
+ * Parses .tf and .tf.json files into structured TerraformDocument objects.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerraformParser = void 0;
+const blocks_1 = require("../types/blocks");
+const blockScanner_1 = require("../utils/lexer/blockScanner");
+const fs_1 = require("../utils/common/fs");
+const logger_1 = require("../utils/common/logger");
+const localsParser_1 = require("../parsers/localsParser");
+const genericParser_1 = require("../parsers/genericParser");
+const outputParser_1 = require("../parsers/outputParser");
+const variableParser_1 = require("../parsers/variableParser");
+const terraformJsonParser_1 = require("./terraformJsonParser");
+/**
+ * Main parser for Terraform configuration files.
+ * Supports both HCL (.tf) and JSON (.tf.json) formats.
+ *
+ * @example
+ * ```typescript
+ * const parser = new TerraformParser();
+ *
+ * // Parse a single file
+ * const doc = parser.parseFile('main.tf');
+ * console.log(`Found ${doc.resource.length} resources`);
+ *
+ * // Parse a directory
+ * const result = parser.parseDirectory('./terraform');
+ * console.log(`Parsed ${result.files.length} files`);
+ *
+ * // Access parsed elements
+ * for (const resource of doc.resource) {
+ *   console.log(`${resource.type}.${resource.name}`);
+ * }
+ * ```
+ */
+class TerraformParser {
+    constructor() {
+        this.scanner = new blockScanner_1.BlockScanner();
+        this.variableParser = new variableParser_1.VariableParser();
+        this.outputParser = new outputParser_1.OutputParser();
+        this.localsParser = new localsParser_1.LocalsParser();
+        this.moduleParser = new genericParser_1.ModuleParser();
+        this.providerParser = new genericParser_1.ProviderParser();
+        this.resourceParser = new genericParser_1.ResourceParser();
+        this.dataParser = new genericParser_1.DataParser();
+        this.terraformSettingsParser = new genericParser_1.TerraformSettingsParser();
+        this.genericBlockParser = new genericParser_1.GenericBlockParser();
+        this.jsonParser = new terraformJsonParser_1.TerraformJsonParser();
+    }
+    /**
+     * Parses a Terraform configuration file.
+     * Automatically detects format (.tf vs .tf.json) and uses appropriate parser.
+     *
+     * @param filePath - Path to the Terraform file
+     * @returns Parsed TerraformDocument containing all blocks
+     * @throws {Error} If file cannot be read or parsed
+     *
+     * @example
+     * ```typescript
+     * const doc = parser.parseFile('main.tf');
+     * console.log(doc.variable[0].name);
+     * ```
+     */
+    parseFile(filePath) {
+        if (filePath.endsWith('.tf.json')) {
+            logger_1.logger.info(`Parsing Terraform JSON file: ${filePath}`);
+            return this.jsonParser.parseFile(filePath);
+        }
+        logger_1.logger.info(`Parsing Terraform file: ${filePath}`);
+        const content = (0, fs_1.readTextFile)(filePath);
+        const blocks = this.scanner.scan(content, filePath);
+        const document = (0, blocks_1.createEmptyDocument)();
+        for (const block of blocks) {
+            switch (block.kind) {
+                case 'variable':
+                    document.variable.push(this.variableParser.parse(block));
+                    break;
+                case 'output':
+                    document.output.push(this.outputParser.parse(block));
+                    break;
+                case 'locals':
+                    document.locals.push(...this.localsParser.parse(block));
+                    break;
+                case 'module':
+                    document.module.push(this.moduleParser.parse(block));
+                    break;
+                case 'provider':
+                    document.provider.push(this.providerParser.parse(block));
+                    break;
+                case 'resource':
+                    document.resource.push(this.resourceParser.parse(block));
+                    break;
+                case 'data':
+                    document.data.push(this.dataParser.parse(block));
+                    break;
+                case 'terraform':
+                    document.terraform.push(this.terraformSettingsParser.parse(block));
+                    break;
+                case 'moved':
+                    document.moved.push(this.genericBlockParser.parse(block));
+                    break;
+                case 'import':
+                    document.import.push(this.genericBlockParser.parse(block));
+                    break;
+                case 'check':
+                    document.check.push(this.genericBlockParser.parse(block));
+                    break;
+                case 'terraform_data':
+                    document.terraform_data.push(this.genericBlockParser.parse(block));
+                    break;
+                default:
+                    document.unknown.push(this.genericBlockParser.parse(block));
+            }
+        }
+        return document;
+    }
+    /**
+     * Parses all Terraform files in a directory (recursively).
+     *
+     * @param dirPath - Path to the directory
+     * @param options - Parsing options
+     * @returns DirectoryParseResult with combined document and per-file results
+     * @throws {Error} If directory does not exist or is not accessible
+     *
+     * @example
+     * ```typescript
+     * // Parse with defaults (aggregate + per-file results)
+     * const result = parser.parseDirectory('./terraform');
+     *
+     * // Parse without aggregation
+     * const result = parser.parseDirectory('./terraform', { aggregate: false });
+     *
+     * // Parse without per-file results
+     * const result = parser.parseDirectory('./terraform', { includePerFile: false });
+     * ```
+     */
+    parseDirectory(dirPath, options) {
+        if (!(0, fs_1.pathExists)(dirPath) || !(0, fs_1.isDirectory)(dirPath)) {
+            throw new Error(`Invalid directory path: ${dirPath}`);
+        }
+        const aggregate = options?.aggregate !== false;
+        const includePerFile = options?.includePerFile !== false;
+        const files = (0, fs_1.listTerraformFiles)(dirPath);
+        const parsedFiles = files.map((filePath) => ({
+            path: filePath,
+            document: this.parseFile(filePath)
+        }));
+        const combined = aggregate ? this.combine(parsedFiles.map((item) => item.document)) : undefined;
+        return {
+            combined,
+            files: includePerFile ? parsedFiles : []
+        };
+    }
+    /**
+     * Combines multiple TerraformDocuments into a single document.
+     * Useful for aggregating configurations from multiple files.
+     *
+     * @param documents - Array of documents to combine
+     * @returns A single TerraformDocument containing all blocks
+     *
+     * @example
+     * ```typescript
+     * const doc1 = parser.parseFile('main.tf');
+     * const doc2 = parser.parseFile('variables.tf');
+     * const combined = parser.combine([doc1, doc2]);
+     * ```
+     */
+    combine(documents) {
+        const combined = (0, blocks_1.createEmptyDocument)();
+        for (const doc of documents) {
+            combined.terraform.push(...doc.terraform);
+            combined.provider.push(...doc.provider);
+            combined.variable.push(...doc.variable);
+            combined.output.push(...doc.output);
+            combined.module.push(...doc.module);
+            combined.resource.push(...doc.resource);
+            combined.data.push(...doc.data);
+            combined.locals.push(...doc.locals);
+            combined.moved.push(...doc.moved);
+            combined.import.push(...doc.import);
+            combined.check.push(...doc.check);
+            combined.terraform_data.push(...doc.terraform_data);
+            combined.unknown.push(...doc.unknown);
+        }
+        return combined;
+    }
+}
+exports.TerraformParser = TerraformParser;

package/dist/types/artifacts.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Type definitions for Terraform artifacts (state files, plans, tfvars) and dependency graphs.
+ */
+import { BlockKind, Reference, TerraformDocument, Value } from './blocks';
+/**
+ * Types of nodes in the dependency graph.
+ * Extends BlockKind with special node types for references.
+ */
+export type GraphNodeKind = BlockKind | 'module_output' | 'path' | 'each' | 'count' | 'self' | 'external';
+/**
+ * A node in the dependency graph representing a Terraform element.
+ */
+export interface GraphNode {
+    /** Unique identifier for the node */
+    id: string;
+    /** The kind/type of the node */
+    kind: GraphNodeKind;
+    /** Display name for the node */
+    name: string;
+    /** Resource/data type (for resource and data nodes) */
+    type?: string;
+    /** Source file path (if known) */
+    source?: string;
+}
+/**
+ * An edge in the dependency graph representing a reference.
+ */
+export interface GraphEdge {
+    /** The source node ID */
+    from: string;
+    /** The target node ID */
+    to: string;
+    /** The reference that created this edge */
+    reference: Reference;
+    /** Source file path where the reference was found */
+    source?: string;
+}
+/**
+ * Complete dependency graph with nodes, edges, and orphan references.
+ */
+export interface DependencyGraph {
+    /** All nodes in the graph */
+    nodes: GraphNode[];
+    /** All edges (dependencies) in the graph */
+    edges: GraphEdge[];
+    /** References that could not be resolved to nodes */
+    orphanReferences: Reference[];
+}
+/**
+ * Export format containing document, graph, and metadata.
+ */
+export interface TerraformExport {
+    /** Export format version */
+    version: string;
+    /** The parsed document (may be partial for filtered exports) */
+    document: Partial<TerraformDocument>;
+    /** The dependency graph */
+    graph: DependencyGraph;
+}
+/**
+ * Parsed tfvars document containing variable assignments.
+ */
+export interface TfVarsDocument {
+    /** Source file path */
+    source: string;
+    /** Raw file content */
+    raw: string;
+    /** Variable assignments (name -> value) */
+    assignments: Record<string, Value>;
+}
+/**
+ * An output value from Terraform state.
+ */
+export interface TerraformStateOutput {
+    /** The output value */
+    value: unknown;
+    /** The output type */
+    type?: string | string[];
+    /** Whether the output is sensitive */
+    sensitive?: boolean;
+}
+/**
+ * A resource instance in Terraform state.
+ */
+export interface TerraformStateInstance {
+    /** Index key (for count/for_each resources) */
+    index_key?: string | number;
+    /** Resource attributes */
+    attributes?: Record<string, unknown>;
+    /** Instance status */
+    status?: string;
+}
+/**
+ * A resource in Terraform state.
+ */
+export interface TerraformStateResource {
+    /** Module address (for resources in modules) */
+    module?: string;
+    /** Resource mode (managed or data) */
+    mode: 'managed' | 'data';
+    /** Resource type */
+    type: string;
+    /** Resource name */
+    name: string;
+    /** Provider configuration */
+    provider?: string;
+    /** Resource instances */
+    instances: TerraformStateInstance[];
+}
+/**
+ * Parsed Terraform state document.
+ */
+export interface TerraformStateDocument {
+    /** State format version */
+    version: number;
+    /** Terraform version that created the state */
+    terraform_version?: string;
+    /** State serial number */
+    serial?: number;
+    /** State lineage (unique identifier) */
+    lineage?: string;
+    /** Output values */
+    outputs: Record<string, TerraformStateOutput>;
+    /** Resources in state */
+    resources: TerraformStateResource[];
+    /** Raw state data */
+    raw: unknown;
+    /** Source file path */
+    source: string;
+}
+/**
+ * A resource change in a Terraform plan.
+ */
+export interface PlanResourceChange {
+    /** Resource address */
+    address: string;
+    /** Module address (if in a module) */
+    module_address?: string;
+    /** Resource mode */
+    mode: 'managed' | 'data';
+    /** Resource type */
+    type: string;
+    /** Resource name */
+    name: string;
+    /** Provider name */
+    provider_name?: string;
+    /** Change details */
+    change: {
+        /** Actions to perform (create, update, delete, etc.) */
+        actions: string[];
+        /** State before change */
+        before?: unknown;
+        /** State after change */
+        after?: unknown;
+        /** Unknown values after change */
+        after_unknown?: Record<string, unknown>;
+        /** Sensitive values before change */
+        before_sensitive?: Record<string, unknown>;
+        /** Sensitive values after change */
+        after_sensitive?: Record<string, unknown>;
+    };
+}
+/**
+ * A resource in planned values.
+ */
+export interface PlanResource {
+    /** Resource address */
+    address: string;
+    /** Resource mode */
+    mode: 'managed' | 'data';
+    /** Resource type */
+    type: string;
+    /** Resource name */
+    name: string;
+    /** Provider name */
+    provider_name?: string;
+    /** Resource values */
+    values?: Record<string, unknown>;
+}
+/**
+ * A module in planned values.
+ */
+export interface PlanModule {
+    /** Module address */
+    address?: string;
+    /** Resources in the module */
+    resources?: PlanResource[];
+    /** Child modules */
+    child_modules?: PlanModule[];
+}
+/**
+ * Parsed Terraform plan document.
+ */
+export interface TerraformPlanDocument {
+    /** Plan format version */
+    format_version?: string;
+    /** Terraform version */
+    terraform_version?: string;
+    /** Planned values */
+    planned_values?: {
+        /** Root module */
+        root_module?: PlanModule;
+    };
+    /** Resource changes */
+    resource_changes: PlanResourceChange[];
+    /** Raw plan data */
+    raw: unknown;
+    /** Source file path */
+    source: string;
+}