blasttrace 1.2.0__py2.py3-none-any.whl

blasttrace/parsers/ts_react_parser.py

@@ -0,0 +1,299 @@
+"""
+BlastTrace TypeScript & React Frontend Parser
+Parses TypeScript/JavaScript functions, React components, interfaces/types, ES imports,
+API consumer calls (fetch, axios, useSWR, useQuery), and response property accesses.
+"""
+
+import os
+import re
+from typing import Dict, Any, List
+
+
+def _normalize_url_to_route_path(raw_url: str) -> str:
+    cleaned = raw_url.strip().strip("\"'`")
+    cleaned = re.sub(r"^https?://[^/]+", "", cleaned)
+    cleaned = cleaned.split("?")[0]
+    cleaned = re.sub(r"\$\{[^}]+\}", ":param", cleaned)
+    cleaned = re.sub(r"\{[^}]+\}", ":param", cleaned)
+    if not cleaned.startswith("/"):
+        cleaned = "/" + cleaned
+    if len(cleaned) > 1 and cleaned.endswith("/"):
+        cleaned = cleaned.rstrip("/")
+    return cleaned
+
+
+def _parse_ts_params(param_str: str) -> List[Dict[str, Any]]:
+    params: List[Dict[str, Any]] = []
+    raw = param_str.strip()
+    if not raw:
+        return params
+    # Handle destructured props like `{ userId, amount = 0 }: CheckoutProps`
+    if raw.startswith("{"):
+        destruct_match = re.match(r"\{([^}]*)\}(?:\s*:\s*([A-Za-z0-9_<>[\]|&]+))?", raw)
+        if destruct_match:
+            inner = destruct_match.group(1)
+            prop_type = (destruct_match.group(2) or "").strip()
+            for part in inner.split(","):
+                p = part.strip()
+                if not p:
+                    continue
+                has_def = "=" in p
+                p_name = p.split("=")[0].split(":")[0].strip()
+                def_val = p.split("=", 1)[1].strip() if has_def else None
+                params.append({
+                    "name": p_name,
+                    "annotation": prop_type,
+                    "required": not has_def,
+                    "default": def_val,
+                })
+            return params
+
+    for part in raw.split(","):
+        p = part.strip()
+        if not p:
+            continue
+        has_def = "=" in p
+        left = p.split("=", 1)[0].strip()
+        def_val = p.split("=", 1)[1].strip() if has_def else None
+        optional_q = "?" in left.split(":")[0]
+        if ":" in left:
+            p_name, p_ann = left.split(":", 1)
+            p_name = p_name.strip().rstrip("?")
+            p_ann = p_ann.strip()
+        else:
+            p_name = left.rstrip("?")
+            p_ann = ""
+        params.append({
+            "name": p_name,
+            "annotation": p_ann,
+            "required": not (has_def or optional_q),
+            "default": def_val,
+        })
+    return params
+
+
+def parse_ts_react_content(content: str, rel_file: str) -> Dict[str, Any]:
+    symbols: Dict[str, Dict[str, Any]] = {}
+    interfaces: Dict[str, Dict[str, Any]] = {}
+    imports: List[Dict[str, str]] = []
+    api_calls: List[Dict[str, Any]] = []
+    property_accesses: List[str] = []
+    nodes: List[Dict[str, Any]] = []
+    edges: List[Dict[str, str]] = []
+
+    module_id = f"fe:{rel_file}"
+    nodes.append({
+        "id": module_id,
+        "type": "frontend_module",
+        "name": rel_file,
+        "file": rel_file,
+        "layer": "frontend",
+    })
+
+    # 1. ES Imports
+    import_pattern = re.compile(
+        r"import\s+(?:type\s+)?(?:\{([^}]+)\}|([A-Za-z0-9_$]+))\s+from\s+[`\"']([^`\"']+)[`\"']",
+        re.MULTILINE,
+    )
+    for match in import_pattern.finditer(content):
+        named_group = match.group(1)
+        default_imp = match.group(2)
+        src_mod = match.group(3)
+        if named_group:
+            for item in named_group.split(","):
+                sym = item.strip().split(" as ")[0].strip()
+                if sym:
+                    imports.append({"module": src_mod, "symbol": sym})
+        elif default_imp:
+            imports.append({"module": src_mod, "symbol": default_imp.strip()})
+
+    # 2. Interfaces & Type Aliases
+    iface_pattern = re.compile(r"(?:export\s+)?interface\s+([A-Za-z0-9_]+)\s*\{([^}]*)\}", re.DOTALL)
+    for match in iface_pattern.finditer(content):
+        iname = match.group(1).strip()
+        ibody = match.group(2)
+        fields: Dict[str, Dict[str, Any]] = {}
+        for line in ibody.splitlines():
+            line_clean = line.strip().rstrip(";,")
+            if not line_clean or line_clean.startswith("//"):
+                continue
+            if ":" in line_clean:
+                fname, ftype = line_clean.split(":", 1)
+                fname_clean = fname.strip().rstrip("?")
+                fields[fname_clean] = {
+                    "name": fname_clean,
+                    "type": ftype.strip(),
+                    "required": not fname.strip().endswith("?"),
+                }
+        iface_id = f"fe:{rel_file}:{iname}"
+        interfaces[iname] = {"name": iname, "fields": fields, "file": rel_file}
+        nodes.append({
+            "id": iface_id,
+            "type": "ts_interface",
+            "name": iname,
+            "fields": list(fields.keys()),
+            "file": rel_file,
+            "layer": "frontend",
+        })
+        edges.append({"source": module_id, "target": iface_id, "relation": "defines_interface"})
+
+    # 3. Functions, Arrow Functions, and React Components
+    fn_pattern = re.compile(
+        r"(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+([A-Za-z0-9_]+)\s*\(([^)]*)\)(?:\s*:\s*([A-Za-z0-9_<>[\]|&]+))?",
+    )
+    for match in fn_pattern.finditer(content):
+        fname = match.group(1).strip()
+        raw_params = match.group(2)
+        ret_type = (match.group(3) or "").strip()
+        params = _parse_ts_params(raw_params)
+        is_component = fname[0].isupper()
+        sym_id = f"fe:{rel_file}:{fname}"
+        symbols[fname] = {
+            "name": fname,
+            "kind": "react_component" if is_component else "ts_function",
+            "params": params,
+            "return_type": ret_type,
+            "signature_string": f"function {fname}({raw_params})" + (f": {ret_type}" if ret_type else ""),
+            "file": rel_file,
+        }
+        nodes.append({
+            "id": sym_id,
+            "type": "react_component" if is_component else "ts_function",
+            "name": fname,
+            "params": params,
+            "return_type": ret_type,
+            "file": rel_file,
+            "layer": "frontend",
+        })
+        edges.append({"source": module_id, "target": sym_id, "relation": "defines_symbol"})
+
+    arrow_pattern = re.compile(
+        r"(?:export\s+)?const\s+([A-Za-z0-9_]+)\s*(?::\s*[^=]+)?=\s*(?:async\s*)?\(([^)]*)\)\s*(?::\s*([A-Za-z0-9_<>[\]|&]+))?\s*=>",
+    )
+    for match in arrow_pattern.finditer(content):
+        fname = match.group(1).strip()
+        if fname in symbols:
+            continue
+        raw_params = match.group(2)
+        ret_type = (match.group(3) or "").strip()
+        params = _parse_ts_params(raw_params)
+        is_component = fname[0].isupper()
+        sym_id = f"fe:{rel_file}:{fname}"
+        symbols[fname] = {
+            "name": fname,
+            "kind": "react_component" if is_component else "ts_function",
+            "params": params,
+            "return_type": ret_type,
+            "signature_string": f"const {fname} = ({raw_params}) =>",
+            "file": rel_file,
+        }
+        nodes.append({
+            "id": sym_id,
+            "type": "react_component" if is_component else "ts_function",
+            "name": fname,
+            "params": params,
+            "return_type": ret_type,
+            "file": rel_file,
+            "layer": "frontend",
+        })
+        edges.append({"source": module_id, "target": sym_id, "relation": "defines_symbol"})
+
+    # 4. Property accesses on response/state objects (e.g. data.balance, user.balance, profile.email)
+    prop_pattern = re.compile(r"\b(?:data|user|res|response|payload|item|account|profile)\.([a-zA-Z_][a-zA-Z0-9_]*)\b")
+    for p_match in prop_pattern.finditer(content):
+        prop_name = p_match.group(1)
+        if prop_name not in ("json", "status", "ok", "headers", "then", "catch", "map", "filter", "length"):
+            if prop_name not in property_accesses:
+                property_accesses.append(prop_name)
+
+    # 5. API calls: fetch('/api/...'), axios.get('/api/...'), useSWR('/api/...')
+    fetch_pattern = re.compile(
+        r"\bfetch\s*\(\s*[`\"']([^`\"']+)[`\"'](?:\s*,\s*\{([^}]*)\})?",
+        re.DOTALL,
+    )
+    for match in fetch_pattern.finditer(content):
+        raw_url = match.group(1)
+        opts = match.group(2) or ""
+        m_match = re.search(r"method\s*:\s*[`\"']([A-Za-z]+)[`\"']", opts, re.IGNORECASE)
+        method = m_match.group(1).upper() if m_match else "GET"
+        norm_path = _normalize_url_to_route_path(raw_url)
+        api_calls.append({
+            "client": "fetch",
+            "method": method,
+            "raw_url": raw_url,
+            "normalized_path": norm_path,
+            "accessed_fields": property_accesses,
+            "file": rel_file,
+        })
+
+    axios_pattern = re.compile(
+        r"\baxios\.(get|post|put|delete|patch)\s*(?:<[^>]+>)?\s*\(\s*[`\"']([^`\"']+)[`\"']",
+        re.IGNORECASE,
+    )
+    for match in axios_pattern.finditer(content):
+        method = match.group(1).upper()
+        raw_url = match.group(2)
+        norm_path = _normalize_url_to_route_path(raw_url)
+        api_calls.append({
+            "client": "axios",
+            "method": method,
+            "raw_url": raw_url,
+            "normalized_path": norm_path,
+            "accessed_fields": property_accesses,
+            "file": rel_file,
+        })
+
+    swr_pattern = re.compile(r"\b(?:useSWR|useQuery)\s*(?:<[^>]+>)?\s*\(\s*[`\"'](/[^`\"']+)[`\"']")
+    for match in swr_pattern.finditer(content):
+        raw_url = match.group(1)
+        norm_path = _normalize_url_to_route_path(raw_url)
+        api_calls.append({
+            "client": "hook",
+            "method": "GET",
+            "raw_url": raw_url,
+            "normalized_path": norm_path,
+            "accessed_fields": property_accesses,
+            "file": rel_file,
+        })
+
+    return {
+        "file": rel_file,
+        "symbols": symbols,
+        "interfaces": interfaces,
+        "imports": imports,
+        "api_calls": api_calls,
+        "property_accesses": property_accesses,
+        "nodes": nodes,
+        "edges": edges,
+    }
+
+
+def parse_ts_react_file(file_path: str, repo_root: str = "") -> Dict[str, Any]:
+    if not os.path.exists(file_path):
+        return {
+            "error": f"Frontend file not found: {file_path}",
+            "symbols": {},
+            "interfaces": {},
+            "imports": [],
+            "api_calls": [],
+            "property_accesses": [],
+            "nodes": [],
+            "edges": [],
+        }
+    rel_file = os.path.relpath(file_path, repo_root).replace("\\", "/") if repo_root else os.path.basename(file_path)
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+            content = f.read()
+    except Exception as exc:
+        return {
+            "error": str(exc),
+            "symbols": {},
+            "interfaces": {},
+            "imports": [],
+            "api_calls": [],
+            "property_accesses": [],
+            "nodes": [],
+            "edges": [],
+        }
+    return parse_ts_react_content(content, rel_file)
+

blasttrace/parsers/vue_nuxt_parser.py

@@ -0,0 +1,175 @@
+"""
+BlastTrace Vue.js & Nuxt 3 AST Parser
+Extracts component definitions, script interfaces, Pinia state bindings,
+template property references, and HTTP / useFetch / $fetch API route queries.
+"""
+
+import os
+import re
+from typing import Dict, Any, List, Optional, Set
+from dataclasses import dataclass, field
+
+
+@dataclass
+class VueApiCall:
+    endpoint: str
+    method: str = "GET"
+    line_number: int = 1
+    response_fields_accessed: List[str] = field(default_factory=list)
+
+
+@dataclass
+class VueComponent:
+    name: str
+    file_path: str
+    props: List[str] = field(default_factory=list)
+    interfaces: List[str] = field(default_factory=list)
+    state_properties: List[str] = field(default_factory=list)
+    template_properties: List[str] = field(default_factory=list)
+    api_calls: List[VueApiCall] = field(default_factory=list)
+
+
+@dataclass
+class VueParseResult:
+    components: List[VueComponent] = field(default_factory=list)
+    api_calls: List[VueApiCall] = field(default_factory=list)
+    interfaces: Dict[str, List[str]] = field(default_factory=dict)
+    all_accessed_properties: Set[str] = field(default_factory=set)
+
+
+# Regex patterns for Vue 2/3 and Nuxt 3
+_RE_SCRIPT = re.compile(r"<script[^>]*>(.*?)</script>", re.DOTALL | re.IGNORECASE)
+_RE_TEMPLATE = re.compile(r"<template[^>]*>(.*?)</template>", re.DOTALL | re.IGNORECASE)
+
+# TypeScript interfaces inside Vue script
+_RE_INTERFACE = re.compile(r"(?:export\s+)?interface\s+([A-Za-z0-9_]+)\s*\{([^}]*)\}", re.DOTALL)
+_RE_TYPE_ALIAS = re.compile(r"(?:export\s+)?type\s+([A-Za-z0-9_]+)\s*=\s*\{([^}]*)\}", re.DOTALL)
+
+# Vue defineProps
+_RE_DEFINE_PROPS = re.compile(r"defineProps<\s*\{([^}]*)\}\s*>", re.DOTALL)
+_RE_DEFINE_PROPS_ARR = re.compile(r"defineProps\(\s*\[([^\]]+)\]\s*\)")
+
+# Pinia stores: const store = useProductStore()
+_RE_PINIA = re.compile(r"(?:const|let|var)\s+([A-Za-z0-9_]+)\s*=\s*(use[A-Za-z0-9_]+Store)\(\)")
+
+# API Fetching in Vue / Nuxt:
+# 1. Nuxt: useFetch('/api/v1/user') or useAsyncData('key', () => $fetch('/api/...'))
+# 2. $fetch('/api/v1/user')
+# 3. axios.get('/api/v1/user')
+# 4. fetch('/api/v1/user')
+_RE_NUXT_USE_FETCH = re.compile(r"useFetch(?:<[^>]+>)?\(\s*['\"`](/[^'\"`]+)['\"`]")
+_RE_DOLLAR_FETCH = re.compile(r"\$fetch(?:<[^>]+>)?\(\s*['\"`](/[^'\"`]+)['\"`]")
+_RE_AXIOS = re.compile(r"axios\.(get|post|put|delete|patch)\(\s*['\"`](/[^'\"`]+)['\"`]", re.IGNORECASE)
+_RE_STANDARD_FETCH = re.compile(r"fetch\(\s*['\"`](/[^'\"`]+)['\"`]")
+
+# Template property accesses: {{ item.price }}, :value="user.balance", v-if="order.tax"
+_RE_TEMPLATE_INTERPOLATION = re.compile(r"\{\{\s*([^}]+)\s*\}\}")
+_RE_TEMPLATE_ATTR_BINDING = re.compile(r"(?::|v-bind:|v-model|v-if|v-for=)[a-zA-Z0-9_\-\.]*=['\"]([^'\"]+)['\"]")
+_RE_PROP_ACCESS = re.compile(r"(?:[A-Za-z0-9_]+)\.([A-Za-z0-9_]+)")
+
+
+def parse_vue_content(content: str, file_path: str = "Component.vue") -> VueParseResult:
+    """Parses single-file Vue / Nuxt component (.vue)."""
+    result = VueParseResult()
+    basename = os.path.basename(file_path)
+    comp_name = os.path.splitext(basename)[0]
+
+    component = VueComponent(name=comp_name, file_path=file_path)
+
+    # 1. Extract Scripts
+    scripts = _RE_SCRIPT.findall(content)
+    script_text = "\n".join(scripts) if scripts else ""
+
+    # Parse Interfaces
+    for match in _RE_INTERFACE.finditer(script_text):
+        ifname = match.group(1)
+        body = match.group(2)
+        fields = [f.split(":")[0].strip().replace("?", "") for f in body.split(";") if ":" in f]
+        component.interfaces.append(ifname)
+        result.interfaces[ifname] = fields
+
+    for match in _RE_TYPE_ALIAS.finditer(script_text):
+        tname = match.group(1)
+        body = match.group(2)
+        fields = [f.split(":")[0].strip().replace("?", "") for f in body.split(";") if ":" in f]
+        component.interfaces.append(tname)
+        result.interfaces[tname] = fields
+
+    # Parse defineProps
+    for match in _RE_DEFINE_PROPS.finditer(script_text):
+        body = match.group(1)
+        props = [p.split(":")[0].strip().replace("?", "") for p in body.split(";") if ":" in p]
+        component.props.extend(props)
+
+    for match in _RE_DEFINE_PROPS_ARR.finditer(script_text):
+        raw_props = match.group(1)
+        props = [p.strip().strip("'\"") for p in raw_props.split(",") if p.strip()]
+        component.props.extend(props)
+
+    # Parse API calls
+    # Nuxt useFetch
+    for match in _RE_NUXT_USE_FETCH.finditer(script_text):
+        endpoint = match.group(1)
+        call = VueApiCall(endpoint=endpoint, method="GET")
+        component.api_calls.append(call)
+        result.api_calls.append(call)
+
+    # $fetch
+    for match in _RE_DOLLAR_FETCH.finditer(script_text):
+        endpoint = match.group(1)
+        call = VueApiCall(endpoint=endpoint, method="GET")
+        component.api_calls.append(call)
+        result.api_calls.append(call)
+
+    # Axios
+    for match in _RE_AXIOS.finditer(script_text):
+        method = match.group(1).upper()
+        endpoint = match.group(2)
+        call = VueApiCall(endpoint=endpoint, method=method)
+        component.api_calls.append(call)
+        result.api_calls.append(call)
+
+    # Standard fetch
+    for match in _RE_STANDARD_FETCH.finditer(script_text):
+        endpoint = match.group(1)
+        call = VueApiCall(endpoint=endpoint, method="GET")
+        component.api_calls.append(call)
+        result.api_calls.append(call)
+
+    # 2. Extract Templates
+    templates = _RE_TEMPLATE.findall(content)
+    template_text = "\n".join(templates) if templates else ""
+
+    # Check property bindings in template
+    accessed: Set[str] = set()
+    for match in _RE_TEMPLATE_INTERPOLATION.finditer(template_text):
+        expr = match.group(1)
+        for pmatch in _RE_PROP_ACCESS.finditer(expr):
+            accessed.add(pmatch.group(1))
+
+    for match in _RE_TEMPLATE_ATTR_BINDING.finditer(template_text):
+        expr = match.group(1)
+        for pmatch in _RE_PROP_ACCESS.finditer(expr):
+            accessed.add(pmatch.group(1))
+
+    # Also extract property accesses in script
+    for pmatch in _RE_PROP_ACCESS.finditer(script_text):
+        accessed.add(pmatch.group(1))
+
+    component.template_properties = sorted(list(accessed))
+    result.all_accessed_properties = accessed
+    result.components.append(component)
+
+    return result
+
+
+def parse_vue_file(file_path: str) -> Optional[VueParseResult]:
+    """Reads and parses a .vue file."""
+    if not os.path.exists(file_path):
+        return None
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        return parse_vue_content(content, file_path)
+    except Exception:
+        return None