@dataparade/cli 0.0.1

package/dist/src/analyzers/terraform/terraform-show-json.js

@@ -0,0 +1,188 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeTerraformShowJsonFromDoc = mergeTerraformShowJsonFromDoc;
+exports.mergeTerraformShowJsonFindings = mergeTerraformShowJsonFindings;
+const fs_1 = __importDefault(require("fs"));
+const path = __importStar(require("path"));
+const terraform_detection_config_1 = require("./terraform-detection-config");
+const terraform_utility_resource_1 = require("./terraform-utility-resource");
+function collectFromModule(mod) {
+    if (!mod || typeof mod !== "object")
+        return [];
+    const m = mod;
+    const out = [];
+    const resources = m.resources;
+    if (Array.isArray(resources)) {
+        for (const r of resources) {
+            if (!r || typeof r !== "object")
+                continue;
+            const o = r;
+            const addr = typeof o.address === "string" ? o.address.trim() : "";
+            const t = typeof o.type === "string" ? o.type.trim() : "";
+            const n = typeof o.name === "string" ? o.name.trim() : "";
+            if (addr && t) {
+                out.push({ address: addr, type: t, name: n || addr });
+            }
+        }
+    }
+    const children = m.child_modules;
+    if (Array.isArray(children)) {
+        for (const ch of children) {
+            out.push(...collectFromModule(ch));
+        }
+    }
+    return out;
+}
+function collectFromPlanDoc(doc) {
+    const out = [];
+    const planned = doc.planned_values;
+    if (planned && typeof planned === "object") {
+        const root = planned.root_module;
+        out.push(...collectFromModule(root));
+    }
+    const values = doc.values;
+    if (values && typeof values === "object") {
+        const root = values.root_module;
+        out.push(...collectFromModule(root));
+    }
+    const changes = doc.resource_changes;
+    if (Array.isArray(changes)) {
+        for (const ch of changes) {
+            if (!ch || typeof ch !== "object")
+                continue;
+            const o = ch;
+            const addr = typeof o.address === "string" ? o.address.trim() : "";
+            const t = typeof o.type === "string" ? o.type.trim() : "";
+            const n = typeof o.name === "string" ? o.name.trim() : "";
+            if (addr && t) {
+                out.push({ address: addr, type: t, name: n || addr });
+            }
+        }
+    }
+    const seen = new Set();
+    const deduped = [];
+    for (const r of out) {
+        if (seen.has(r.address))
+            continue;
+        seen.add(r.address);
+        deduped.push(r);
+    }
+    return deduped.sort((a, b) => a.address.localeCompare(b.address));
+}
+function rawFindingFromJsonResource(r, jsonBasename, tfConfig) {
+    const hints = (0, terraform_detection_config_1.lookupTerraformResourceHints)(r.type, tfConfig);
+    return {
+        pattern: "terraform_resource",
+        name: r.address,
+        confidence: 0.78,
+        location: {
+            filePath: jsonBasename,
+            startLine: 1,
+            endLine: 1,
+        },
+        properties: {
+            terraform_address: r.address,
+            terraform_block_kind: "resource",
+            resource_type: r.type,
+            block_name: r.name,
+            componentSubType: hints.componentSubType,
+            cloud_provider: hints.cloud_provider,
+            section_id: "global",
+            section_label: "terraform-json",
+            terraform_references: [],
+            terraform_json_source: true,
+        },
+    };
+}
+/**
+ * Parse a `terraform show -json` object (plan or state) and emit `RawFinding`s
+ * for addresses not already present in `existingFindings`.
+ */
+function mergeTerraformShowJsonFromDoc(existingFindings, doc, syntheticFileLabel, onWarning) {
+    const resources = collectFromPlanDoc(doc);
+    if (resources.length === 0) {
+        onWarning?.("terraform-json: no resources found (expected planned_values/values root_module or resource_changes).");
+        return { findings: [], mergedCount: 0 };
+    }
+    const tfConfig = (0, terraform_detection_config_1.loadTerraformPatternConfig)();
+    const existingAddresses = new Set();
+    for (const f of existingFindings) {
+        if (f.pattern !== "terraform_resource")
+            continue;
+        const addr = f.properties?.terraform_address;
+        if (typeof addr === "string" && addr.trim()) {
+            existingAddresses.add(addr.trim());
+        }
+    }
+    const extra = [];
+    for (const r of resources) {
+        if (existingAddresses.has(r.address))
+            continue;
+        if ((0, terraform_utility_resource_1.isTerraformOmittedFromServiceGraphResourceType)(r.type))
+            continue;
+        extra.push(rawFindingFromJsonResource(r, syntheticFileLabel, tfConfig));
+        existingAddresses.add(r.address);
+    }
+    if (extra.length > 0) {
+        onWarning?.(`terraform-json: merged ${extra.length} resource(s) from '${syntheticFileLabel}' (state/plan may contain secrets — values are not copied into output).`);
+    }
+    return { findings: extra, mergedCount: extra.length };
+}
+/**
+ * Parse a `terraform show -json` file (plan or state) and emit `RawFinding`s
+ * for addresses not already present in `existingFindings` (static `.tf` wins).
+ */
+function mergeTerraformShowJsonFindings(existingFindings, jsonAbsolutePath, onWarning) {
+    let parsed;
+    try {
+        const raw = fs_1.default.readFileSync(jsonAbsolutePath, "utf8");
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        onWarning?.(`terraform-json: failed to read or parse '${jsonAbsolutePath}': ${msg}`);
+        return { findings: [], mergedCount: 0 };
+    }
+    if (!parsed || typeof parsed !== "object") {
+        onWarning?.("terraform-json: root JSON value must be an object.");
+        return { findings: [], mergedCount: 0 };
+    }
+    const doc = parsed;
+    return mergeTerraformShowJsonFromDoc(existingFindings, doc, path.basename(jsonAbsolutePath), onWarning);
+}

package/dist/src/analyzers/terraform/terraform-utility-resource.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Terraform "utility" providers (names, sleeps, etc.) should not become
+ * standalone infrastructure nodes in dataflow output.
+ */
+export declare function isTerraformUtilityResourceType(resourceType: string): boolean;
+/**
+ * IAM / identity resources are properties of workloads (Lambda, ECS, etc.), not
+ * separate services in the dataflow diagram.
+ */
+export declare function isTerraformIdentityInfrastructureResourceType(resourceType: string): boolean;
+/** Omit from graph: utilities plus non-service identity resources. */
+export declare function isTerraformOmittedFromServiceGraphResourceType(resourceType: string): boolean;

package/dist/src/analyzers/terraform/terraform-utility-resource.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTerraformUtilityResourceType = isTerraformUtilityResourceType;
+exports.isTerraformIdentityInfrastructureResourceType = isTerraformIdentityInfrastructureResourceType;
+exports.isTerraformOmittedFromServiceGraphResourceType = isTerraformOmittedFromServiceGraphResourceType;
+/**
+ * Terraform "utility" providers (names, sleeps, etc.) should not become
+ * standalone infrastructure nodes in dataflow output.
+ */
+function isTerraformUtilityResourceType(resourceType) {
+    const rt = resourceType.trim();
+    if (!rt)
+        return false;
+    return /^(random|time|null|tls|terraform)_/.test(rt);
+}
+/**
+ * IAM / identity resources are properties of workloads (Lambda, ECS, etc.), not
+ * separate services in the dataflow diagram.
+ */
+function isTerraformIdentityInfrastructureResourceType(resourceType) {
+    const rt = resourceType.trim().toLowerCase();
+    if (!rt)
+        return false;
+    return rt.startsWith("aws_iam_");
+}
+/** Omit from graph: utilities plus non-service identity resources. */
+function isTerraformOmittedFromServiceGraphResourceType(resourceType) {
+    return (isTerraformUtilityResourceType(resourceType) ||
+        isTerraformIdentityInfrastructureResourceType(resourceType));
+}

package/dist/src/analyzers/types.d.ts

@@ -0,0 +1,5 @@
+import type { FileInfo } from "../core/types/file";
+import type { RawFinding } from "../core/types/detection";
+export interface Analyzer {
+    detect(file: FileInfo): RawFinding[];
+}

package/dist/src/analyzers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/analyzers/typescript/actor-detection.d.ts

@@ -0,0 +1,4 @@
+import type { FileInfo } from "../../core/types/file";
+import type { RawFinding } from "../../core/types/detection";
+import type { ParserResult } from "./parser";
+export declare function detectActorsFromFile(file: FileInfo, model: ParserResult): RawFinding[];

package/dist/src/analyzers/typescript/actor-detection.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectActorsFromFile = detectActorsFromFile;
+const engine_1 = require("../../patterns/engine");
+const config_1 = require("../../patterns/config");
+function detectActorsFromFile(file, model) {
+    const unified = (0, config_1.loadUnifiedPatternConfig)();
+    const actorPatternIds = new Set(unified.actors.rules.map((r) => r.patternId));
+    const findings = (0, engine_1.matchPatterns)({
+        language: model.language,
+        file,
+        normalizedPath: model.normalizedPath,
+    });
+    return findings.filter((f) => actorPatternIds.has(f.pattern));
+}

package/dist/src/analyzers/typescript/dependency-manifests.d.ts

@@ -0,0 +1,9 @@
+import type { RawFinding } from "../../core/types/detection";
+import { type ManifestScanBudgetOptions } from "../shared/manifest-budgets";
+export interface TypeScriptManifestPackages {
+    manifestRelativePath: string;
+    packages: string[];
+    packageName?: string;
+}
+export declare function parseTypeScriptDependencyManifests(rootPath: string, opts?: ManifestScanBudgetOptions): Promise<TypeScriptManifestPackages[]>;
+export declare function detectTypeScriptPatternsFromDependencyManifests(rootPath: string, opts?: ManifestScanBudgetOptions): Promise<RawFinding[]>;

package/dist/src/analyzers/typescript/dependency-manifests.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTypeScriptDependencyManifests = parseTypeScriptDependencyManifests;
+exports.detectTypeScriptPatternsFromDependencyManifests = detectTypeScriptPatternsFromDependencyManifests;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const engine_1 = require("../../patterns/engine");
+const manifest_budgets_1 = require("../shared/manifest-budgets");
+const manifest_fs_1 = require("../shared/manifest-fs");
+const manifest_parsers_1 = require("./manifest-parsers");
+function normalizePosix(p) {
+    return p.split(path_1.default.sep).join("/");
+}
+const FRONTEND_FRAMEWORKS_BY_PACKAGE = [
+    { packageName: "next", framework: "nextjs" },
+    { packageName: "react", framework: "react" },
+    { packageName: "vue", framework: "vue" },
+    { packageName: "@angular/core", framework: "angular" },
+    { packageName: "svelte", framework: "svelte" },
+    { packageName: "solid-js", framework: "solid" },
+    { packageName: "@builder.io/qwik", framework: "qwik" },
+    { packageName: "@ionic/react", framework: "ionic" },
+    { packageName: "electron", framework: "electron" },
+];
+function inferFrontendFrameworkFromPackages(packages) {
+    const packageSet = new Set(packages.map((p) => p.toLowerCase()));
+    const matched = FRONTEND_FRAMEWORKS_BY_PACKAGE.find((entry) => packageSet.has(entry.packageName));
+    return matched?.framework;
+}
+async function parseTypeScriptDependencyManifests(rootPath, opts) {
+    const rootDir = path_1.default.resolve(rootPath);
+    const manifests = [];
+    const state = (0, manifest_budgets_1.budgetStateFromOptions)(opts);
+    await (0, manifest_fs_1.walkForManifests)(rootDir, manifests, {
+        rootDir,
+        state,
+        excludePaths: opts?.excludePaths,
+        isManifestFile: (entry) => entry.isFile() && entry.name === "package.json",
+    });
+    const byManifest = [];
+    let bytesRead = 0;
+    const maxBytes = state.maxTotalManifestReadBytes;
+    for (const manifestAbsPath of manifests) {
+        if (bytesRead >= maxBytes)
+            break;
+        const manifestRelativePath = normalizePosix(path_1.default.relative(rootDir, manifestAbsPath));
+        const raw = await fs_1.promises.readFile(manifestAbsPath, "utf8").catch(() => "");
+        bytesRead += raw.length;
+        if (!raw)
+            continue;
+        try {
+            const parsed = JSON.parse(raw);
+            const packages = (0, manifest_parsers_1.extractPackagesFromPackageJsonObject)(parsed);
+            if (packages.length === 0)
+                continue;
+            const packageName = typeof parsed.name === "string"
+                ? (parsed.name ?? "").trim()
+                : "";
+            byManifest.push({
+                manifestRelativePath,
+                packages,
+                packageName: packageName || undefined,
+            });
+        }
+        catch {
+            // Ignore malformed package.json files.
+        }
+    }
+    return byManifest;
+}
+function createManifestFileInfo(manifestRelativePath) {
+    const fileInfo = {
+        path: manifestRelativePath,
+        name: path_1.default.basename(manifestRelativePath),
+        content: "",
+        language: "typescript", // ensures language-specific detectors behave consistently
+        size: 0,
+    };
+    return fileInfo;
+}
+async function detectTypeScriptPatternsFromDependencyManifests(rootPath, opts) {
+    const manifestPackages = await parseTypeScriptDependencyManifests(rootPath, opts);
+    if (manifestPackages.length === 0)
+        return [];
+    const findings = [];
+    for (const manifest of manifestPackages) {
+        const manifestFile = createManifestFileInfo(manifest.manifestRelativePath);
+        const imports = manifest.packages.map((p) => ({
+            module: p,
+            names: [p],
+        }));
+        const manifestFindings = (0, engine_1.matchPatterns)({
+            language: manifestFile.language,
+            file: manifestFile,
+            normalizedPath: manifestFile.path,
+            imports,
+        });
+        findings.push(...manifestFindings.map((finding) => ({
+            ...finding,
+            properties: {
+                ...finding.properties,
+                sourceContext: "dependency_manifest",
+                packageName: manifest.packageName,
+            },
+        })));
+        const frontendFramework = inferFrontendFrameworkFromPackages(manifest.packages);
+        if (frontendFramework) {
+            findings.push({
+                pattern: "express_route",
+                name: "Frontend Application",
+                confidence: 0.75,
+                location: {
+                    filePath: manifestFile.path,
+                    startLine: 1,
+                    endLine: 1,
+                },
+                properties: {
+                    framework: frontendFramework,
+                    sourceContext: "dependency_manifest",
+                    packageName: manifest.packageName,
+                    httpMethods: [],
+                    path: undefined,
+                },
+            });
+        }
+    }
+    return findings;
+}

package/dist/src/analyzers/typescript/detector.d.ts

@@ -0,0 +1,3 @@
+import type { FileInfo } from "../../core/types/file";
+import type { RawFinding } from "../../core/types/detection";
+export declare function detectPatterns(file: FileInfo): RawFinding[];

package/dist/src/analyzers/typescript/detector.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPatterns = detectPatterns;
+const parser_1 = require("./parser");
+const typescript_detection_1 = require("./typescript-detection");
+const property_inference_1 = require("../shared/property-inference");
+const actor_detection_1 = require("./actor-detection");
+function detectPatterns(file) {
+    const model = (0, parser_1.buildCodeModel)(file);
+    if (model.language !== "typescript" && model.language !== "javascript") {
+        return [];
+    }
+    const findings = [];
+    findings.push(...(0, typescript_detection_1.detectRoutePatterns)(file, model), ...(0, typescript_detection_1.detectDatabaseConnections)(file, model), ...(0, typescript_detection_1.detectExternalApiCalls)(file, model), ...(0, typescript_detection_1.detectAuthMiddleware)(file, model), ...(0, typescript_detection_1.detectConfigAndEnvUsage)(file, model), ...(0, actor_detection_1.detectActorsFromFile)(file, model));
+    // Merge pattern-matched component properties into each finding so classifier/enhancer get them
+    for (const finding of findings) {
+        const detected = (0, property_inference_1.getPropertiesFromFinding)(finding, file.content);
+        if (Object.keys(detected).length > 0) {
+            finding.properties = { ...finding.properties, ...detected };
+        }
+    }
+    return findings;
+}

package/dist/src/analyzers/typescript/index.d.ts

@@ -0,0 +1,2 @@
+import type { Analyzer } from "../types";
+export declare function createTypeScriptAnalyzer(): Analyzer;

package/dist/src/analyzers/typescript/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypeScriptAnalyzer = createTypeScriptAnalyzer;
+const detector_1 = require("./detector");
+function createTypeScriptAnalyzer() {
+    return {
+        detect(file) {
+            return (0, detector_1.detectPatterns)(file);
+        },
+    };
+}

package/dist/src/analyzers/typescript/manifest-parsers.d.ts

@@ -0,0 +1 @@
+export declare function extractPackagesFromPackageJsonObject(parsed: unknown): string[];

package/dist/src/analyzers/typescript/manifest-parsers.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPackagesFromPackageJsonObject = extractPackagesFromPackageJsonObject;
+function normalizePackageName(name) {
+    const s = name.trim();
+    if (!s)
+        return null;
+    const beforeAt = s.includes("@") && !s.startsWith("@") ? s.split("@")[0] : s;
+    const token = beforeAt.toLowerCase();
+    return token || null;
+}
+function extractPackagesFromPackageJsonObject(parsed) {
+    if (!parsed || typeof parsed !== "object")
+        return [];
+    const obj = parsed;
+    const collect = (value) => {
+        if (!value || typeof value !== "object")
+            return [];
+        const deps = value;
+        return Object.keys(deps)
+            .map((k) => normalizePackageName(k))
+            .filter((v) => typeof v === "string" && v.length > 0);
+    };
+    const packages = [
+        ...collect(obj.dependencies),
+        ...collect(obj.devDependencies),
+        ...collect(obj.optionalDependencies),
+    ];
+    return Array.from(new Set(packages));
+}

package/dist/src/analyzers/typescript/parser.d.ts

@@ -0,0 +1,44 @@
+import type { FileInfo, FileLanguage, SourceLocation } from "../../core/types/file";
+type ParserLanguage = Extract<FileLanguage, "typescript" | "javascript">;
+export interface ImportEntry {
+    moduleSpecifier: string;
+    importedNames: string[];
+    isTypeOnly: boolean;
+    resolvedPath?: string;
+    location: SourceLocation;
+}
+export type ExportKind = "named" | "default";
+export interface FunctionEntry {
+    name: string;
+    isExported: boolean;
+    exportKind?: ExportKind;
+    location: SourceLocation;
+}
+export interface ParserResult {
+    file: FileInfo;
+    normalizedPath: string;
+    language: ParserLanguage;
+    imports: ImportEntry[];
+    functions: FunctionEntry[];
+    /**
+     * Non-fatal issues encountered while parsing or indexing the file.
+     * Callers should surface these as warnings, not hard failures.
+     */
+    warnings: string[];
+}
+/**
+ * Normalize a file system path to a POSIX-style string (forward slashes).
+ * This keeps path handling consistent across platforms.
+ */
+export declare function normalizePath(p: string): string;
+/**
+ * Build a lightweight code model for a TypeScript/JavaScript file.
+ *
+ * - Ensures the language is correctly inferred for TS/JS files.
+ * - Indexes import statements and simple require() calls.
+ * - Indexes top-level function declarations, exported functions, and basic
+ *   arrow/function expressions assigned to exported variables.
+ * - Surfaces parser/diagnostic issues as warnings instead of throwing.
+ */
+export declare function buildCodeModel(file: FileInfo): ParserResult;
+export {};