nx-terraform 0.3.0 → 0.5.0

package/README.md

@@ -1,11 +1,523 @@
 # nx-terraform
 
-This library was generated with [Nx](https://nx.dev).
+An [Nx](https://nx.dev) plugin for managing Terraform projects within an Nx monorepo. This plugin provides generators, automatic project discovery, and inferred tasks for Terraform infrastructure-as-code projects.
 
-## Building
+## Overview
 
-Run `nx build nx-terraform` to build the library.
+The `nx-terraform` plugin enables you to manage Terraform projects alongside your other code in an Nx monorepo. It provides:
 
-## Running unit tests
+- **Automatic Project Discovery**: Automatically discovers Terraform projects based on `main.tf` files
+- **Inferred Tasks**: Automatically creates Terraform targets (init, plan, apply, destroy, validate, fmt, output)
+- **Generators**: Scaffold Terraform backend projects and modules
+- **Target Dependencies**: Smart dependency management between Terraform projects
+- **Caching**: Intelligent caching for safe operations (fmt, validate)
 
-Run `nx test nx-terraform` to execute the unit tests via [Jest](https://jestjs.io).
+## Installation
+
+### For New Workspaces
+
+Create a new workspace with Terraform support:
+
+```bash
+npx create-nx-terraform-app my-workspace
+```
+
+This creates a new Nx workspace with the `nx-terraform` plugin already configured.
+
+### For Existing Workspaces
+
+Install the plugin in your existing Nx workspace:
+
+```bash
+nx add nx-terraform
+```
+
+This will:
+- Add `nx-terraform` as a dependency
+- Register the plugin in `nx.json`
+- Enable automatic Terraform project discovery
+
+## Quick Start
+
+1. **Initialize the plugin** (if not using `create-nx-terraform-app`):
+   ```bash
+   nx g @nx-terraform/plugin:init
+   ```
+
+2. **Create a Terraform backend project**:
+   ```bash
+   nx g @nx-terraform/plugin:terraform-backend my-backend --backendType=aws-s3
+   ```
+
+3. **Apply the backend** (to create the state storage infrastructure):
+   ```bash
+   nx run my-backend:terraform-apply
+   ```
+
+4. **Create a Terraform module**:
+   ```bash
+   nx g @nx-terraform/plugin:terraform-module my-infra \
+     --backendProject=my-backend \
+     --backendType=aws-s3
+   ```
+
+5. **Use Terraform targets**:
+   ```bash
+   nx run my-infra:terraform-init
+   nx run my-infra:terraform-plan
+   nx run my-infra:terraform-apply
+   ```
+
+## Features
+
+### Automatic Project Discovery
+
+The plugin automatically discovers Terraform projects by looking for `main.tf` files in your workspace. Projects are detected based on:
+
+- **Presence of `main.tf`**: Required for discovery
+- **Project configuration**: Must have `project.json` in the same directory
+- **Project type**: Determined by `projectType` and `metadata` in `project.json`
+
+### Inferred Tasks
+
+The plugin automatically creates these targets for each Terraform project:
+
+- **terraform-init**: Initialize Terraform workspace
+- **terraform-plan**: Create execution plan
+- **terraform-apply**: Apply changes to infrastructure
+- **terraform-destroy**: Destroy infrastructure
+- **terraform-validate**: Validate Terraform configuration
+- **terraform-fmt**: Format Terraform code
+- **terraform-output**: Show Terraform outputs
+
+### Project Types
+
+The plugin supports three types of Terraform projects:
+
+1. **Backend Projects** (`application` without `backendProject` metadata):
+   - Manage remote state infrastructure (e.g., S3 bucket, DynamoDB table)
+   - Generate `backend.config` files
+   - Full target set with caching enabled
+
+2. **Stateful Projects** (`application` with `backendProject` metadata):
+   - Infrastructure projects that use remote state
+   - Reference backend project via `metadata.backendProject`
+   - Full target set (no caching for init/plan due to state)
+
+3. **Module Projects** (`library`):
+   - Reusable Terraform modules
+   - No state management
+   - Stub targets (modules don't have state)
+
+### Smart Dependencies
+
+The plugin automatically manages dependencies between Terraform projects using the `createDependencies` API. This creates a project dependency graph that ensures proper execution order.
+
+#### Automatic Dependency Detection
+
+The plugin automatically detects and creates dependencies in two ways:
+
+1. **Backend Project Dependencies**: Projects with `metadata.backendProject` in their `project.json` automatically depend on their backend project. This ensures backend projects are applied before stateful projects initialize.
+
+2. **Module Reference Dependencies**: The plugin analyzes `.tf` files to detect module references using local paths (e.g., `source = "../../packages/networking"`). When a module block references another Terraform project, a dependency is automatically created.
+
+**How Module Detection Works:**
+- Scans `.tf` files for `module` blocks
+- Extracts `source` attributes that use local paths (`./` or `../`)
+- Matches the last path segment to project names in the workspace
+- Creates static dependencies from the referencing project to the referenced project
+
+**Example:**
+```hcl
+# In packages/web-app/main.tf
+module "networking" {
+  source = "../../packages/networking"
+  # ... module configuration
+}
+```
+
+This automatically creates a dependency: `web-app` → `networking`
+
+#### Target Dependencies
+
+In addition to project dependencies, targets have their own dependencies:
+
+- **Backend first**: `terraform-init` depends on `^terraform-apply` (backend must be applied first)
+- **Init before operations**: `terraform-plan`, `terraform-apply`, and `terraform-validate` require `terraform-init`
+- **Plan before apply**: `terraform-apply` depends on `terraform-plan`
+
+### Caching
+
+Intelligent caching for safe operations:
+
+- **Cached**: `terraform-fmt`, `terraform-validate` (when safe)
+- **Non-cached**: `terraform-init`, `terraform-plan`, `terraform-apply` (state-dependent)
+
+## Generators
+
+The plugin provides four generators:
+
+### `init` Generator
+
+Registers the `nx-terraform` plugin in your workspace.
+
+```bash
+nx g @nx-terraform/plugin:init
+```
+
+**Documentation**: [`packages/nx-terraform/src/generators/init/README.md`](./src/generators/init/README.md)
+
+### `terraform-backend` Generator
+
+Creates a Terraform backend project for managing remote state.
+
+```bash
+nx g @nx-terraform/plugin:terraform-backend my-backend --backendType=aws-s3
+```
+
+**Options**:
+- `name`: Backend project name (required)
+- `backendType`: 'aws-s3' or 'local' (required)
+- `bucketNamePrefix`: Prefix for S3 bucket name (optional, AWS S3 only)
+
+**Documentation**: [`packages/nx-terraform/src/generators/terraform-backend/README.md`](./src/generators/terraform-backend/README.md)
+
+### `terraform-module` Generator
+
+Creates Terraform modules (simple library or stateful application).
+
+```bash
+# Simple module (library)
+nx g @nx-terraform/plugin:terraform-module my-module --backendType=local
+
+# Stateful module (application)
+nx g @nx-terraform/plugin:terraform-module my-infra \
+  --backendProject=my-backend \
+  --backendType=aws-s3
+```
+
+**Options**:
+- `name`: Module name (required)
+- `backendType`: 'aws-s3' or 'local' (required)
+- `backendProject`: Backend project name (optional, creates stateful module if provided)
+
+**Documentation**: [`packages/nx-terraform/src/generators/terraform-module/README.md`](./src/generators/terraform-module/README.md)
+
+### `preset` Generator
+
+Initializes workspace with Terraform setup (used by `create-nx-terraform-app`).
+
+```bash
+nx g @nx-terraform/plugin:preset --projectName=terraform-setup --backendType=aws-s3
+```
+
+**Documentation**: [`packages/nx-terraform/src/generators/preset/README.md`](./src/generators/preset/README.md)
+
+## Targets
+
+Each Terraform project automatically gets these targets:
+
+### terraform-init
+
+Initializes Terraform workspace.
+
+```bash
+nx run my-project:terraform-init
+```
+
+**Dependencies**: `^terraform-apply` (backend must be applied first)
+
+### terraform-plan
+
+Creates an execution plan.
+
+```bash
+nx run my-project:terraform-plan
+```
+
+**Dependencies**: `terraform-init`
+
+**Configurations**: Supports `dev` and `prod` configurations via `-var-file` arguments
+
+### terraform-apply
+
+Applies changes to infrastructure.
+
+```bash
+nx run my-project:terraform-apply
+```
+
+**Dependencies**: `terraform-plan`
+
+**Configurations**: Supports `dev` and `prod` configurations
+
+### terraform-destroy
+
+Destroys infrastructure.
+
+```bash
+nx run my-project:terraform-destroy
+```
+
+**Dependencies**: `terraform-init`
+
+### terraform-validate
+
+Validates Terraform configuration.
+
+```bash
+nx run my-project:terraform-validate
+```
+
+**Dependencies**: `terraform-init`
+
+**Caching**: Enabled (safe operation)
+
+### terraform-fmt
+
+Formats Terraform code.
+
+```bash
+nx run my-project:terraform-fmt
+```
+
+**Caching**: Enabled (safe operation)
+
+### terraform-output
+
+Shows Terraform outputs.
+
+```bash
+nx run my-project:terraform-output
+```
+
+**Dependencies**: `terraform-init`
+
+## Project Structure
+
+Terraform projects should follow this structure:
+
+```
+packages/
+  └── my-terraform-project/
+      ├── project.json          # Nx project configuration
+      ├── main.tf              # Required for discovery
+      ├── backend.tf           # Backend configuration (stateful projects)
+      ├── provider.tf          # Provider requirements
+      ├── variables.tf         # Input variables
+      ├── outputs.tf           # Output values
+      ├── tfvars/
+      │   ├── dev.tfvars       # Dev environment variables
+      │   └── prod.tfvars      # Prod environment variables
+      └── backend.config       # Generated backend config (backend projects)
+```
+
+### Project Configuration
+
+For **stateful projects**, configure `metadata.backendProject`:
+
+```json
+{
+  "root": "packages/my-infra",
+  "projectType": "application",
+  "metadata": {
+    "backendProject": "my-backend"
+  }
+}
+```
+
+## Configuration
+
+### Backend Types
+
+The plugin supports two backend types:
+
+#### AWS S3 Backend
+
+Production-ready remote state storage using AWS S3:
+
+```bash
+nx g @nx-terraform/plugin:terraform-backend my-backend --backendType=aws-s3
+```
+
+**Features**:
+- Versioning enabled
+- Object lock for state protection
+- Dynamic bucket naming
+- Region detection
+
+#### Local Backend
+
+Local state files for development:
+
+```bash
+nx g @nx-terraform/plugin:terraform-backend my-backend --backendType=local
+```
+
+**Use Cases**:
+- Development and testing
+- Single-user scenarios
+- Ephemeral environments
+
+### Environment Variables
+
+Terraform projects support environment-specific variables via `tfvars` files:
+
+- `tfvars/dev.tfvars` - Development environment
+- `tfvars/prod.tfvars` - Production environment
+
+Targets automatically use the appropriate `-var-file` argument based on configuration:
+
+```bash
+# Uses tfvars/dev.tfvars
+nx run my-project:terraform-plan --configuration=dev
+
+# Uses tfvars/prod.tfvars
+nx run my-project:terraform-plan --configuration=prod
+```
+
+## Examples
+
+### Complete Workflow
+
+```bash
+# 1. Create new workspace (creates terraform-setup backend and terraform-infra module)
+npx create-nx-terraform-app my-workspace
+
+# 2. Apply backend (from workspace creation)
+cd my-workspace
+nx run terraform-setup:terraform-apply
+
+# 3. Plan and apply infrastructure module (already created by preset)
+nx run terraform-infra:terraform-init
+nx run terraform-infra:terraform-plan --configuration=dev
+nx run terraform-infra:terraform-apply --configuration=dev
+
+# 4. (Optional) Create additional infrastructure modules
+nx g @nx-terraform/plugin:terraform-module web-infra \
+  --backendProject=terraform-setup \
+  --backendType=aws-s3
+```
+
+### Multiple Environments
+
+```bash
+# Create dev environment
+nx g @nx-terraform/plugin:terraform-module dev-infra \
+  --backendProject=terraform-setup \
+  --backendType=aws-s3
+
+# Create prod environment
+nx g @nx-terraform/plugin:terraform-module prod-infra \
+  --backendProject=terraform-setup \
+  --backendType=aws-s3
+
+# Deploy to dev
+nx run dev-infra:terraform-plan --configuration=dev
+nx run dev-infra:terraform-apply --configuration=dev
+
+# Deploy to prod
+nx run prod-infra:terraform-plan --configuration=prod
+nx run prod-infra:terraform-apply --configuration=prod
+```
+
+### Reusable Modules with Automatic Dependencies
+
+```bash
+# Create reusable networking module
+nx g @nx-terraform/plugin:terraform-module networking --backendType=local
+
+# Create web app that uses the networking module
+nx g @nx-terraform/plugin:terraform-module web-app \
+  --backendProject=terraform-setup \
+  --backendType=aws-s3
+```
+
+Then reference the module in your Terraform code:
+```hcl
+# In packages/web-app/main.tf
+module "networking" {
+  source = "../../packages/networking"
+  vpc_cidr = "10.0.0.0/16"
+}
+```
+
+**Automatic Dependency Detection**: The plugin automatically detects this module reference and creates a project dependency (`web-app` → `networking`). When you run `nx graph`, you'll see the dependency visualized. This ensures `networking` is built/validated before `web-app`.
+
+## Project Discovery
+
+The plugin automatically discovers Terraform projects using:
+
+- **Pattern**: `**/main.tf` (looks for `main.tf` files recursively)
+- **Requirement**: Projects must have `project.json` in the same directory
+- **Type Detection**: Based on `projectType` and `metadata.backendProject`
+
+Projects are discovered on workspace load, so new projects are automatically available without restarting Nx.
+
+## Caching Strategy
+
+Caching behavior varies by project type:
+
+### Backend Projects (caching enabled)
+
+- **terraform-init**: Cached (backend projects don't depend on external state)
+- **terraform-plan**: Cached
+- **terraform-apply**: Cached
+- **terraform-fmt**: Cached (code formatting is deterministic)
+- **terraform-validate**: Cached (validation results can be cached when inputs haven't changed)
+- **terraform-destroy**: Not cached
+- **terraform-output**: Not cached
+
+### Stateful Projects (caching disabled for state-dependent operations)
+
+- **terraform-init**: Not cached (state-dependent, requires backend access)
+- **terraform-plan**: Not cached (state-dependent, shows infrastructure changes)
+- **terraform-apply**: Not cached (state-dependent, modifies infrastructure)
+- **terraform-fmt**: Cached (code formatting is deterministic)
+- **terraform-validate**: Cached (validation results can be cached when inputs haven't changed)
+- **terraform-destroy**: Not cached
+- **terraform-output**: Not cached
+
+### Module Projects (library)
+
+- **terraform-fmt**: Cached
+- **terraform-validate**: Cached
+- **terraform-apply**: Not cached (though modules typically don't use apply)
+- All other targets are stubs (cached but no-op)
+
+Cache inputs include:
+- All `.tf` and `.tfvars` files
+- Relevant environment variables
+- Terraform version
+- Provider and backend configuration files
+
+## Compatibility
+
+- **Nx**: v22.0.2 or compatible
+- **Terraform**: Any version (uses Terraform CLI)
+- **Node.js**: v18+ recommended
+
+## Documentation
+
+Comprehensive documentation is available for each component:
+
+- **Generators**:
+  - [`init`](./src/generators/init/README.md) - Plugin initialization
+  - [`terraform-backend`](./src/generators/terraform-backend/README.md) - Backend project creation
+  - [`terraform-module`](./src/generators/terraform-module/README.md) - Module creation
+  - [`preset`](./src/generators/preset/README.md) - Workspace preset
+
+- **Workspace Creation**:
+  - [`create-nx-terraform-app`](../create-nx-terraform-app/README.md) - CLI tool for workspace creation
+
+## Contributing
+
+Contributions are welcome! Please see the repository for contribution guidelines.
+
+## License
+
+MIT
+
+## Repository
+
+https://github.com/alexpialetski/nx-terraform

package/generators.json

@@ -15,6 +15,11 @@
       "factory": "./src/generators/init/init",
       "schema": "./src/generators/init/schema.json",
       "description": "init generator"
+    },
+    "terraform-module": {
+      "factory": "./src/generators/terraform-module/terraform-module",
+      "schema": "./src/generators/terraform-module/schema.json",
+      "description": "terraform-module generator"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx-terraform",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "type": "commonjs",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",

package/src/dependencies/createDependencies.d.ts

@@ -0,0 +1,8 @@
+import { CreateDependencies } from '@nx/devkit';
+import { NxTerraformPluginOptions } from '../types';
+/**
+ * Creates dependencies between Terraform projects by:
+ * 1. Creating static dependencies from projects to their backend projects (from project.json metadata)
+ * 2. Analyzing module references in .tf files (static dependencies)
+ */
+export declare const createDependencies: CreateDependencies<NxTerraformPluginOptions>;

package/src/dependencies/createDependencies.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDependencies = void 0;
+const tslib_1 = require("tslib");
+const path = require("node:path");
+const fileParser_1 = require("./fileParser");
+const utils_1 = require("./utils");
+/**
+ * Creates dependencies between Terraform projects by:
+ * 1. Creating static dependencies from projects to their backend projects (from project.json metadata)
+ * 2. Analyzing module references in .tf files (static dependencies)
+ */
+const createDependencies = (_, ctx) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const results = [];
+    for (const [projectName, projectConfig] of Object.entries(ctx.projects)) {
+        // ----------------------------------------------------------------
+        // Static dependencies from projects to their backend projects
+        // ----------------------------------------------------------------
+        const backendProject = (_a = projectConfig.metadata) === null || _a === void 0 ? void 0 : _a.backendProject;
+        if (backendProject) {
+            // Verify backend project exists
+            if (ctx.projects[backendProject]) {
+                (0, utils_1.validateAndAddDependency)((0, utils_1.createStaticDependency)(projectName, backendProject, path.join(projectConfig.root, 'project.json')), ctx, results);
+            }
+        }
+        // ----------------------------------------------------------------
+        // Static dependencies from projects to their module projects
+        // ----------------------------------------------------------------
+        // Find .tf files to process in this project (only changed files)
+        const tfFilesToProcess = (0, fileParser_1.getTerraformFilesToProcess)((_b = ctx.filesToProcess.projectFileMap[projectName]) !== null && _b !== void 0 ? _b : []);
+        for (const file of tfFilesToProcess) {
+            const filePath = path.join(ctx.workspaceRoot, file.file);
+            // Read and parse the Terraform file
+            const { content: fileContent, success: readSuccess } = (0, fileParser_1.readTerraformFile)(filePath, file.file);
+            if (!readSuccess) {
+                continue;
+            }
+            const { parsed, success: parseSuccess } = yield (0, fileParser_1.parseTerraformFile)(file.file, fileContent);
+            if (!parseSuccess) {
+                continue;
+            }
+            // Extract module blocks and process each one
+            for (const { source: sourcePath } of (0, fileParser_1.extractModuleBlocks)(parsed)) {
+                // Only process local paths (./ or ../)
+                if (!(0, fileParser_1.isLocalPath)(sourcePath)) {
+                    continue;
+                }
+                // Extract the last segment of the path as the potential project name
+                const potentialProjectName = sourcePath.split('/').pop();
+                // Check if the last segment matches a project name
+                const targetProject = ctx.projects[potentialProjectName]
+                    ? potentialProjectName
+                    : undefined;
+                // Skip if no target project found or if it's a self-reference
+                if (!targetProject || targetProject === projectName) {
+                    continue;
+                }
+                (0, utils_1.validateAndAddDependency)((0, utils_1.createStaticDependency)(projectName, targetProject, file.file), ctx, results);
+            }
+        }
+    }
+    return results;
+});
+exports.createDependencies = createDependencies;
+//# sourceMappingURL=createDependencies.js.map

package/src/dependencies/createDependencies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDependencies.js","sourceRoot":"","sources":["../../../../../packages/nx-terraform/src/dependencies/createDependencies.ts"],"names":[],"mappings":";;;;AAKA,kCAAkC;AAElC,6CAMsB;AACtB,mCAA2E;AAE3E;;;;GAIG;AACI,MAAM,kBAAkB,GAE3B,CAAO,CAAC,EAAE,GAA8B,EAAE,EAAE;;IAC9C,MAAM,OAAO,GAAgC,EAAE,CAAC;IAEhD,KAAK,MAAM,CAAC,WAAW,EAAE,aAAa,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;QACxE,mEAAmE;QACnE,8DAA8D;QAC9D,mEAAmE;QACnE,MAAM,cAAc,GAAG,MAAA,aAAa,CAAC,QAAQ,0CAAE,cAAc,CAAC;QAE9D,IAAI,cAAc,EAAE,CAAC;YACnB,gCAAgC;YAChC,IAAI,GAAG,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;gBACjC,IAAA,gCAAwB,EACtB,IAAA,8BAAsB,EACpB,WAAW,EACX,cAAc,EACd,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,cAAc,CAAC,CAC9C,EACD,GAAG,EACH,OAAO,CACR,CAAC;YACJ,CAAC;QACH,CAAC;QAED,mEAAmE;QACnE,6DAA6D;QAC7D,mEAAmE;QAEnE,iEAAiE;QACjE,MAAM,gBAAgB,GAAG,IAAA,uCAA0B,EACjD,MAAA,GAAG,CAAC,cAAc,CAAC,cAAc,CAAC,WAAW,CAAC,mCAAI,EAAE,CACrD,CAAC;QAEF,KAAK,MAAM,IAAI,IAAI,gBAAgB,EAAE,CAAC;YACpC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YAEzD,oCAAoC;YACpC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,IAAA,8BAAiB,EACtE,QAAQ,EACR,IAAI,CAAC,IAAI,CACV,CAAC;YACF,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,SAAS;YACX,CAAC;YAED,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,IAAA,+BAAkB,EAChE,IAAI,CAAC,IAAI,EACT,WAAW,CACZ,CAAC;YACF,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,SAAS;YACX,CAAC;YAED,6CAA6C;YAC7C,KAAK,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,IAAA,gCAAmB,EAAC,MAAM,CAAC,EAAE,CAAC;gBACjE,uCAAuC;gBACvC,IAAI,CAAC,IAAA,wBAAW,EAAC,UAAU,CAAC,EAAE,CAAC;oBAC7B,SAAS;gBACX,CAAC;gBAED,qEAAqE;gBACrE,MAAM,oBAAoB,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;gBAEzD,mDAAmD;gBACnD,MAAM,aAAa,GAAG,GAAG,CAAC,QAAQ,CAAC,oBAAoB,CAAC;oBACtD,CAAC,CAAC,oBAAoB;oBACtB,CAAC,CAAC,SAAS,CAAC;gBAEd,8DAA8D;gBAC9D,IAAI,CAAC,aAAa,IAAI,aAAa,KAAK,WAAW,EAAE,CAAC;oBACpD,SAAS;gBACX,CAAC;gBAED,IAAA,gCAAwB,EACtB,IAAA,8BAAsB,EAAC,WAAW,EAAE,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC,EAC7D,GAAG,EACH,OAAO,CACR,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC,CAAA,CAAC;AArFW,QAAA,kBAAkB,sBAqF7B"}

package/src/dependencies/fileParser.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Reads a Terraform file and returns its content
+ */
+export declare function readTerraformFile(filePath: string, relativePath: string): {
+    content: string;
+    success: boolean;
+};
+/**
+ * Parses HCL content into a JSON structure
+ */
+export declare function parseTerraformFile(fileName: string, content: string): Promise<{
+    parsed: any;
+    success: boolean;
+}>;
+/**
+ * Extracts module blocks from parsed HCL structure
+ */
+export declare function extractModuleBlocks(parsed: any): Array<{
+    moduleName: string;
+    source: string;
+}>;
+/**
+ * Gets all .tf files to process for a project
+ */
+export declare function getTerraformFilesToProcess(filesToProcess: Array<{
+    file: string;
+}>): Array<{
+    file: string;
+}>;
+/**
+ * Checks if a path is a local path (starts with ./ or ../)
+ */
+export declare function isLocalPath(sourcePath: string): boolean;