devlensio 0.6.2 → 1.0.0

package/extractors/python/devlens_extractors_python/edges/tests.py

@@ -0,0 +1,53 @@
+"""TESTS edges — test file → the production code it imports.
+
+Mirror of the JS detectTestEdges (src/graph/edges/testEdges.ts):
+  - every TEST file node is scanned via its symbol map (import aliases)
+  - a local named import pointing at a FILE is refined to the symbol with
+    that name inside it (the calls.py refinement)
+  - third-party targets and test-importing-test targets are skipped
+  - edge: TEST file node → TESTS → production node (metadata.importPath)
+"""
+from __future__ import annotations
+
+from ..lookup import LookupMaps, module_name
+
+
+def resolve_test_edges(lookup: LookupMaps) -> list[dict]:
+    edges: list[dict] = []
+    seen: set[tuple[str, str]] = set()
+
+    for rel, file_node in lookup.file_nodes_by_path.items():
+        if file_node["type"] != "TEST":
+            continue
+        symbols = lookup.symbol_maps.get(rel, {})
+
+        for alias, target in symbols.items():
+            # refine file targets to the symbol inside (calls.py refinement)
+            if target.startswith("file::"):
+                target_rel = target[len("file::"):]
+                target_id = lookup.nodes_by_file.get(target_rel, {}).get(alias)
+                if not target_id:
+                    continue
+            elif target.startswith("[pip]/"):
+                continue          # third-party — not production code under test
+            else:
+                target_id = target
+
+            target_node = lookup.node_by_id.get(target_id)
+            if not target_node or target_node["type"] in ("TEST", "FILE"):
+                continue          # test importing test helpers / plain files
+            if target_node["filePath"] == rel:
+                continue          # self-import
+
+            key = (file_node["id"], target_id)
+            if key in seen:
+                continue
+            seen.add(key)
+
+            edges.append({
+                "from": file_node["id"], "to": target_id, "type": "TESTS",
+                "metadata": {"importPath": module_name(target_node["filePath"]),
+                             "testFileType": "TEST"},
+            })
+
+    return edges

package/extractors/python/devlens_extractors_python/extractor.py

@@ -0,0 +1,107 @@
+"""Orchestration — walks the repo, parses files, resolves imports,
+detects calls/routes/orm, and assembles the final ExtractorResult.
+
+Pipeline:
+  1. walk + parse every .py file → nodes
+  2. build shared lookup maps (once) + resolve imports → IMPORTS edges + symbol maps
+  3. resolve calls → CALLS edges (lazily creating [pip]/pkg::method nodes)
+  4. routes → BACKEND_ROUTEs + ROUTE nodes + HANDLES edges
+  5. ORM data layer → model metadata + READS_FROM/WRITES_TO edges
+  6. collect third-party nodes (AFTER call resolution — lazy nodes)
+"""
+from __future__ import annotations
+
+from . import edges, fingerprint, parser
+from .contract import ExtractorError, Stats
+from .lookup import build_lookup_maps
+from .third_party import ThirdPartyRegistry
+
+
+def extract(repo_path: str, options: dict) -> dict:
+    fp = fingerprint.detect(repo_path)
+
+    nodes: list[dict] = []
+    edges_out: list[dict] = []
+    errors: list[dict] = []
+    total_files = 0
+    skipped = 0
+
+    # 1. walk + parse every file (test files stay leaf nodes)
+    parsed_files: list[parser.ParsedFile] = []
+    rel_paths: list[str] = []
+    for rel in parser.walk_python_files(repo_path):
+        total_files += 1
+        rel_paths.append(rel)
+        try:
+            parsed = parser.parse_file(repo_path, rel)
+        except parser.ParseError as exc:
+            skipped += 1
+            errors.append(ExtractorError(file=rel, error=str(exc)).to_dict())
+            continue
+        parsed_files.append(parsed)
+        nodes.append(parsed.file_node)
+        nodes.extend(parsed.nodes)
+
+    # 2. shared lookup — built ONCE, consumed by every edge detector
+    lookup = build_lookup_maps(parsed_files)
+    lookup.module_map = edges.imports.build_module_map(rel_paths)
+
+    # third-party inclusion gate: only libs listed in options.includeThirdPartyLibs
+    # (engine contract name) / includedThirdPartyLibs (contract.html alias) get
+    # [pip]/ nodes + edges. Absent/empty → no third-party nodes at all.
+    libs = options.get("includeThirdPartyLibs") or options.get("includedThirdPartyLibs") or []
+    allowed = set(libs)
+    registry = ThirdPartyRegistry(fp.rawDependencies, allowed)
+
+    for parsed in parsed_files:
+        file_edges, imported = edges.resolve_file_imports(parsed, lookup, registry)
+        edges_out.extend(file_edges)
+        for n in parsed.nodes:
+            n["metadata"]["imports"] = imported
+
+    # 3. CALLS edges — same lookup, zero rebuilds
+    edges_out.extend(edges.resolve_calls(lookup, registry))
+
+    # 4. routes — BackendRouteNodes + ROUTE nodes + HANDLES edges
+    route_result = edges.detect_routes(parsed_files, lookup, fp)
+    edges_out.extend(route_result.handles_edges)
+    nodes.extend(route_result.route_nodes)
+
+    # 5. ORM data layer — model metadata + READS_FROM/WRITES_TO
+    models = edges.detect_models(lookup, parsed_files)
+    edges_out.extend(edges.resolve_orm_edges(lookup, models))
+
+    # 5c. inheritance — EXTENDS / IMPLEMENTS edges (class → base)
+    edges_out.extend(edges.resolve_inheritance(lookup, registry))
+
+    # 5d. TESTS edges — test file → production symbols it imports
+    edges_out.extend(edges.resolve_test_edges(lookup))
+
+    # 5b. metadata enrichment — pydantic isSchema, celery isTask
+    edges.enrich_metadata(lookup)
+
+    # 6. third-party nodes — AFTER call resolution (lazy method nodes)
+    nodes.extend(registry.nodes)
+
+    # 7. dedupe edges — same (from, to, type) can arise from repeated ormOps
+    #    or overlapping patterns; the graph must not carry duplicates.
+    seen_edges: set[tuple[str, str, str]] = set()
+    unique_edges: list[dict] = []
+    for e in edges_out:
+        key = (e["from"], e["to"], e["type"])
+        if key in seen_edges:
+            continue
+        seen_edges.add(key)
+        unique_edges.append(e)
+    edges_out = unique_edges
+
+    stats = Stats(totalFiles=total_files, totalNodes=len(nodes), skippedFiles=skipped)
+
+    return {
+        "fingerprint": fp.to_dict(),
+        "nodes": nodes,
+        "edges": edges_out,
+        "routes": route_result.routes,
+        "stats": stats.to_dict(),
+        "errors": errors,
+    }

package/extractors/python/devlens_extractors_python/fingerprint.py

@@ -0,0 +1,201 @@
+"""Fingerprint detection — reads dependency manifests and answers:
+what framework, what databases, what raw dependencies?
+
+Manifest priority when several exist: setup.py → pyproject.toml → requirements.txt
+(later sources override earlier ones). requirements.txt is usually the
+deployed truth, so it wins.
+"""
+
+from __future__ import annotations
+import ast
+import re
+import tomllib
+from pathlib import Path
+from .contract import Fingerprint
+
+#Framework detection order - first match wins
+FRAMEWORK_ORDER = ["django", "fastapi", "flask"]
+
+# Dependency package name → DatabaseLibrary value.
+# ONLY union-safe values from src/types.ts (postgres, mongodb, mysql, sqlite).
+# sqlalchemy/redis intentionally absent — they are ORM/cache layers, not a
+# specific DB, and are not in the TS union. They still appear in rawDependencies.
+DATABASE_PACKAGES = {
+    # postgres
+    "psycopg2": "postgres", "psycopg2-binary": "postgres",
+    "psycopg": "postgres", "asyncpg": "postgres", "pg8000": "postgres",
+    # mongodb
+    "pymongo": "mongodb", "motor": "mongodb",
+    # mysql
+    "pymysql": "mysql", "mysqlclient": "mysql",
+    # sqlite
+    "aiosqlite": "sqlite",
+}
+
+_VERSION_RE = re.compile(r"(\d+\.\d+(?:\.\d+)?(?:[a-z0-9.]*)?)")
+
+
+def _extract_version(spec: str) -> str:
+    """Best-effort version from any specifier: '==0.104.1', '>=1.0,<2.0',
+    '^1.0', '~=4.2' → first version-like token, else 'unknown'."""
+    match = _VERSION_RE.search(spec)
+    return match.group(1) if match else "unknown"
+
+def _parse_pep508(dep: str) -> tuple[str, str]:
+    """Parse one PEP 508 dependency string → (name, version).
+
+    Handles: 'fastapi==0.104.1', 'requests[security]>=2.31',
+    'pkg @ https://...', 'django~=4.2'.
+    """
+    name = re.split(r"[<=>~!@\[;]", dep, maxsplit=1)[0].strip().lower()
+    return name, _extract_version(dep)
+
+def _parse_requirements(path: Path, seen: set | None = None) -> dict[str, str]:
+    """requirements.txt: one dep per line. Follows -r/--requirement and
+    -c/--constraint include files RECURSIVELY (paths relative to the
+    including file), e.g. `-r requirements/base.txt` — real projects
+    split requirements this way. Editable (-e) and other directives skip."""
+    deps: dict[str, str] = {}
+    seen = seen or set()
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return deps
+
+    for raw in text.splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#"):
+            continue
+
+        # include directive: -r/-c with space or = form
+        inc = re.match(r"^(?:--requirement|--constraint|-r|-c)(?:=|\s+)(\S+)", line)
+        if inc:
+            inc_rel = re.split(r"\s+#", inc.group(1))[0].strip()
+            inc_path = (path.parent / inc_rel).resolve()
+            if inc_path.is_file() and inc_path not in seen:
+                seen.add(inc_path)
+                deps.update(_parse_requirements(inc_path, seen))
+            continue
+
+        if line.startswith("-"):
+            continue   # -e editable, --index-url, --extra-index-url, etc.
+
+        line = re.split(r"\s+#", line)[0]   # inline comment (must follow whitespace)
+        line = line.split(";")[0].strip()   # env marker: django==4.2 ; python_version >= "3.8"
+        if not line:
+            continue
+        name, version = _parse_pep508(line)
+        deps[name] = version
+    return deps
+
+def _parse_poetry_deps(data: dict) -> dict[str, str]:
+    """Poetry-style deps under [tool.poetry.dependencies].
+    Values can be a version string, a dict {version, extras}, or a list of strings."""
+    deps: dict[str, str] = {}
+    poetry = data.get("tool", {}).get("poetry", {}).get("dependencies", {})
+    for name, spec in poetry.items():
+        if name == "python":            # poetry requires a python constraint — not a dep
+            continue
+        if isinstance(spec, str):
+            deps[name] = _extract_version(spec)
+        elif isinstance(spec, dict) and isinstance(spec.get("version"), str):
+            deps[name] = _extract_version(spec["version"])
+        elif isinstance(spec, list):
+            deps[name] = _extract_version(spec[0]) if spec else "unknown"
+    return deps
+
+def _parse_pyproject(path: Path) -> dict[str, str]:
+    """pyproject.toml: PEP 621 [project] dependencies + optional-dependencies,
+    plus Poetry's [tool.poetry.dependencies]."""
+    try:
+        with open(path, "rb") as f:     # tomllib requires binary mode
+            data = tomllib.load(f)
+    except (tomllib.TOMLDecodeError, OSError):
+        return {}
+
+    deps: dict[str, str] = {}
+    project = data.get("project", {}) or {}
+
+    for dep in project.get("dependencies", []) or []:
+        name, version = _parse_pep508(dep)
+        deps[name] = version
+
+    for group in (project.get("optional-dependencies", {}) or {}).values():
+        for dep in group or []:
+            name, version = _parse_pep508(dep)
+            deps[name] = version
+
+    deps.update(_parse_poetry_deps(data))
+    return deps
+
+def _parse_setup_py(path: Path) -> dict[str, str]:
+    """setup.py: parse (never execute!) and read install_requires/extras_require
+    string literals out of the AST. Executing repo code during analysis would
+    be a security hole."""
+    try:
+        tree = ast.parse(path.read_text(encoding="utf-8", errors="replace"))
+    except (SyntaxError, OSError):
+        return {}
+
+    deps: dict[str, str] = {}
+
+    for node in ast.walk(tree):
+        if not (isinstance(node, ast.Call) and isinstance(node.func, ast.Name)
+                and node.func.id == "setup"):
+            continue
+        for kw in node.keywords:
+            if kw.arg == "install_requires" and isinstance(kw.value, ast.List):
+                for elt in kw.value.elts:
+                    if isinstance(elt, ast.Constant) and isinstance(elt.value, str):
+                        name, version = _parse_pep508(elt.value)
+                        deps[name] = version
+            elif kw.arg == "extras_require" and isinstance(kw.value, ast.Dict):
+                for value in kw.value.values:
+                    if isinstance(value, ast.List):
+                        for elt in value.elts:
+                            if isinstance(elt, ast.Constant) and isinstance(elt.value, str):
+                                name, version = _parse_pep508(elt.value)
+                                deps[name] = version
+    return deps
+
+def _collect_dependencies(repo_path: str) -> dict[str, str]:
+    """Merge manifests. Later sources override earlier ones."""
+    root = Path(repo_path)
+    deps: dict[str, str] = {}
+
+    setup = root / "setup.py"
+    if setup.is_file():
+        deps.update(_parse_setup_py(setup))
+
+    pyproject = root / "pyproject.toml"
+    if pyproject.is_file():
+        deps.update(_parse_pyproject(pyproject))
+
+    requirements = root / "requirements.txt"
+    if requirements.is_file():
+        deps.update(_parse_requirements(requirements))
+
+    return deps
+
+def detect(repo_path: str) -> Fingerprint:
+    """Build the fingerprint from dependency manifests. Missing manifests →
+    unknown framework, empty deps. Never raises."""
+    deps = _collect_dependencies(repo_path)
+
+    fingerprint = Fingerprint()
+    fingerprint.rawDependencies = dict(sorted(deps.items()))
+
+    framework = next((fw for fw in FRAMEWORK_ORDER if fw in deps), None)
+    # DRF implies Django even if 'django' isn't declared directly
+    if framework is None and "djangorestframework" in deps:
+        framework = "django"
+
+    if framework:
+        fingerprint.framework = framework
+        fingerprint.projectType = "backend"
+
+    for pkg, db in DATABASE_PACKAGES.items():
+        if pkg in deps and db not in fingerprint.databases:
+            fingerprint.databases.append(db)
+
+    return fingerprint

package/extractors/python/devlens_extractors_python/lookup.py

@@ -0,0 +1,72 @@
+"""Shared lookup maps — the analysis index.
+
+Mirrors the JS buildLookupMaps() (src/graph/buildLookup.ts): built ONCE per
+extraction and passed to every edge detector (calls, routes, orm, tests) so
+nobody rebuilds indexes. All lookups are O(1) map hits.
+
+Field owners:
+  nodes_by_name / nodes_by_file / node_by_id / file_nodes_by_path  — build_lookup_maps()
+  module_map                                                       — extractor (imports.build_module_map)
+  symbol_maps                                                      — edges.imports.resolve_file_imports
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class LookupMaps:
+    # name → [(node_id, rel_path)] — global, closest-by-path on collision
+    nodes_by_name: dict[str, list[tuple[str, str]]] = field(default_factory=dict)
+    # rel_path → {node name → node_id} — same-file / refinement lookups
+    nodes_by_file: dict[str, dict[str, str]] = field(default_factory=dict)
+    # node_id → node dict — direct access to any parsed node
+    node_by_id: dict[str, dict] = field(default_factory=dict)
+    # rel_path → FILE/TEST node dict
+    file_nodes_by_path: dict[str, dict] = field(default_factory=dict)
+    # rel_path → {local alias → target id} — import precision (edges.imports writes)
+    symbol_maps: dict[str, dict[str, str]] = field(default_factory=dict)
+    # dotted module name → rel path (imports.build_module_map builds)
+    module_map: dict[str, str] = field(default_factory=dict)
+
+
+def module_name(rel: str) -> str:
+    """'models/user.py' → 'models.user' · 'models/__init__.py' → 'models'."""
+    parts = rel.split("/")
+    if parts[-1] == "__init__.py":
+        return ".".join(parts[:-1])
+    return ".".join(parts[:-1] + [parts[-1][:-3]])
+
+
+def build_lookup_maps(parsed_files: list) -> LookupMaps:
+    """One pass over all parsed files → shared indexes."""
+    lookup = LookupMaps()
+
+    for pf in parsed_files:
+        lookup.file_nodes_by_path[pf.rel_path] = pf.file_node
+        lookup.node_by_id[pf.file_node["id"]] = pf.file_node
+
+        names: dict[str, str] = {}
+        for n in pf.nodes:
+            names.setdefault(n["name"], n["id"])
+            lookup.node_by_id[n["id"]] = n
+            lookup.nodes_by_name.setdefault(n["name"], []).append((n["id"], pf.rel_path))
+        lookup.nodes_by_file[pf.rel_path] = names
+
+    return lookup
+
+
+def closest_by_path(candidates: list[tuple[str, str]], rel: str) -> str:
+    """Pick the candidate whose file shares the most leading path segments
+    with the caller (same heuristic as the JS closestByPath)."""
+    caller_parts = rel.split("/")
+    best_id, best_score = candidates[0][0], -1
+    for node_id, cand_rel in candidates:
+        score = 0
+        for a, b in zip(caller_parts, cand_rel.split("/")):
+            if a != b:
+                break
+            score += 1
+        if score > best_score:
+            best_id, best_score = node_id, score
+    return best_id

package/extractors/python/devlens_extractors_python/parser/__init__.py

@@ -0,0 +1,72 @@
+"""Parser package — walks the repo and turns .py files into DevLens nodes.
+
+Public API (everything else is internal):
+    parse_file(repo_path, rel_path) -> ParsedFile
+    walk_python_files(repo_path) -> iterator of relative paths
+"""
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..contract import code_hash, file_node
+from .classes import extract_class
+from .functions import extract_function
+from .walker import is_test_file, walk_python_files
+
+class ParseError(Exception):
+    """Raised when a file can't be read or parsed. Non-fatal — the caller
+    records it in errors[] and continues with the next file."""
+
+@dataclass
+class ParsedFile:
+    rel_path: str
+    file_node: dict
+    nodes: list[dict]          # FUNCTION / CLASS / METHOD nodes (children)
+    source: str
+    tree: ast.Module
+
+def parse_file(repo_path: str, rel_path: str) -> ParsedFile:
+    abs_path = Path(repo_path) / rel_path
+    try:
+        source = abs_path.read_text(encoding="utf-8", errors="replace")
+    except OSError as exc:
+        raise ParseError(f"unreadable file: {exc}") from exc
+
+    try:
+        tree = ast.parse(source, filename=rel_path)
+    except SyntaxError as exc:
+        line = exc.lineno or "?"
+        raise ParseError(f"SyntaxError at line {line}: {exc.msg}") from exc
+
+    is_test = is_test_file(rel_path)
+    children: list[dict] = []
+    test_cases: list[str] = []
+
+    for stmt in tree.body:
+        if isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            children.append(extract_function(stmt, rel_path, source))
+            if is_test:
+                test_cases.append(stmt.name)
+        elif isinstance(stmt, ast.ClassDef):
+            children.extend(extract_class(stmt, rel_path, source))
+            if is_test:
+                test_cases.append(stmt.name)
+
+    end_line = len(source.splitlines()) or 1
+    file_node_ = file_node(rel_path, end_line, node_type="TEST" if is_test else "FILE")
+
+    if is_test:
+        # Test files are leaf nodes in the graph — children become testCases
+        # metadata (mirrors the JS parser, which keeps test helpers out).
+        file_node_["metadata"]["testCases"] = test_cases
+    else:
+        file_node_["metadata"]["nodeCount"] = len(children)
+        file_node_["metadata"]["childNodeIds"] = [c["id"] for c in children]
+        joined = "\n".join(c.get("rawCode", "") for c in children)
+        if joined.strip():
+            file_node_["codeHash"] = code_hash(joined)
+
+    return ParsedFile(rel_path=rel_path, file_node=file_node_, nodes=children if not is_test else [],
+                      source=source, tree=tree)

package/extractors/python/devlens_extractors_python/parser/classes.py

@@ -0,0 +1,109 @@
+"""Class extraction — CLASS node + METHOD children + model/schema metadata.
+
+Collects at parse time (resolved later by edges/orm_edges.py):
+  fields[]       — Django field / SQLAlchemy Column assignments
+  linkedModel    — DRF serializer `class Meta: model = User`
+  ormOps         — ORM calls in class-level statements (e.g. `queryset = User.objects.all()`)
+"""
+from __future__ import annotations
+
+import ast
+
+from ..contract import code_node
+from .functions import NESTED_SCOPES, _match_orm_call, _walk_scope, extract_function
+
+FIELD_TYPE_NAMES = {
+    # Django ORM fields
+    "CharField", "TextField", "IntegerField", "BigIntegerField",
+    "PositiveIntegerField", "PositiveBigIntegerField", "SmallIntegerField",
+    "FloatField", "DecimalField", "BooleanField", "DateField", "DateTimeField",
+    "TimeField", "DurationField", "EmailField", "URLField", "UUIDField",
+    "JSONField", "SlugField", "BinaryField", "FileField", "ImageField",
+    "FilePathField", "AutoField", "BigAutoField", "ForeignKey",
+    "OneToOneField", "ManyToManyField", "GenericForeignKey", "ArrayField",
+    # SQLAlchemy
+    "Column", "relationship", "mapped_column",
+}
+
+
+def _extract_fields(node: ast.ClassDef) -> list[str]:
+    """Field names from class-body assignments: `name = CharField(...)`."""
+    fields: list[str] = []
+    for stmt in node.body:
+        if not isinstance(stmt, ast.Assign) or not isinstance(stmt.value, ast.Call):
+            continue
+        f = stmt.value.func
+        fname = f.id if isinstance(f, ast.Name) else (
+            f.attr if isinstance(f, ast.Attribute) else None)
+        if fname not in FIELD_TYPE_NAMES:
+            continue
+        for t in stmt.targets:
+            if isinstance(t, ast.Name):
+                fields.append(t.id)
+    return fields
+
+
+def _extract_linked_model(node: ast.ClassDef) -> str | None:
+    """DRF serializer: inner `class Meta: model = User` → 'User'."""
+    for stmt in node.body:
+        if isinstance(stmt, ast.ClassDef) and stmt.name == "Meta":
+            for inner in stmt.body:
+                if isinstance(inner, ast.Assign) and isinstance(inner.value, ast.Name):
+                    for t in inner.targets:
+                        if isinstance(t, ast.Name) and t.id == "model":
+                            return inner.value.id
+    return None
+
+
+def _extract_class_orm_ops(node: ast.ClassDef) -> list[dict]:
+    """ORM calls in class-level statements (queryset = Model.objects.all())."""
+    stmts = [s for s in node.body
+             if not isinstance(s, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef))]
+    ops: list[dict] = []
+
+    def visit(n: ast.AST) -> None:
+        if isinstance(n, ast.Call):
+            op = _match_orm_call(n)
+            if op:
+                ops.append(op)
+
+    _walk_scope(stmts, visit)
+    return ops
+
+
+def extract_class(node: ast.ClassDef, rel_path: str, source: str,
+                  prefix: str = "") -> list[dict]:
+    """Returns [CLASS node, *METHOD nodes]. Nested classes get dotted names
+    (Outer.Inner) and their methods (Outer.Inner.method) — same convention
+    as methods."""
+    class_name = f"{prefix}.{node.name}" if prefix else node.name
+    raw = ast.get_source_segment(source, node) or ""
+
+    children: list[dict] = []
+    for stmt in node.body:
+        if isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            children.append(extract_function(stmt, rel_path, source, parent_class=class_name))
+        elif isinstance(stmt, ast.ClassDef):
+            children.extend(extract_class(stmt, rel_path, source, prefix=class_name))
+
+    metadata = {
+        "bases": [ast.unparse(b) for b in node.bases],
+        "decorators": [ast.unparse(d) for d in node.decorator_list],
+        "methods": [c["name"] for c in children if c["type"] == "METHOD"],
+    }
+
+    fields = _extract_fields(node)
+    if fields:
+        metadata["fields"] = fields
+
+    linked = _extract_linked_model(node)
+    if linked:
+        metadata["linkedModel"] = linked
+
+    class_ops = _extract_class_orm_ops(node)
+    if class_ops:
+        metadata["ormOps"] = class_ops
+
+    class_node = code_node(rel_path, class_name, "CLASS", node.lineno,
+                           node.end_lineno or node.lineno, raw, metadata)
+    return [class_node, *children]