cg-code-graph 0.10.1__py3-none-any.whl

codegraph/plugins/tsweb/common.py

@@ -0,0 +1,290 @@
+"""Shared helpers for the TypeScript server-framework layers (NestJS, Next.js, Express/Fastify/Koa/Hono).
+
+All three sit on the TypeScript language plugin. The extractor's `fw` facts (extractor/fw.mjs) describe decorators,
+router calls, exports and data-access calls as JSON values; these helpers turn them into graph nodes and edges:
+
+  * route paths in one notation (`{param}`, `{rest*}` catch-all, `{rest*?}` optional catch-all) so `link` can match
+    client calls against any backend,
+  * route nodes (`route:<METHOD> <uri>`, entry kind http_route) with ROUTES_TO / USES_MIDDLEWARE evidence,
+  * the post-pass shared by all TS server frameworks (env/config keys, ORM tables, in-repo client -> route links),
+    run once after the last framework contributed.
+"""
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from ... import presets
+from ...core.plugin import GraphBuilder, Project
+
+# package.json dependencies that mark a TS/JS server framework (any of them enables the TS plugin, even without a
+# tsconfig.json: plain-JS projects are indexed with allowJs)
+SERVER_DEPS = {
+    "nest": ("@nestjs/core", "@nestjs/common"),
+    "next": ("next",),
+    "express": ("express", "koa", "@koa/router", "koa-router", "fastify", "hono", "@hono/node-server", "restify", "polka", "h3", "elysia"),
+}
+# test trees: anywhere for the unambiguous names; `test/`, `tests/`, `e2e/` only at the top (or under src/), since
+# deeper directories with those names are often real route segments (app/api/test/route.ts)
+# build output (codegraph/presets/typescript.yaml build_dirs) and test tooling directories
+TEST_TOOL_DIRS = ("__tests__", "__mocks__", "__fixtures__", "cypress", "playwright", ".storybook")
+TEST_SKIP_RE = (r"(^|/)(" + "|".join(re.escape(d) for d in sorted(presets.skip_dirs("typescript", "build_dirs"))
+                                      + list(TEST_TOOL_DIRS)) + r")(/|$)"
+                r"|^(src/)?(test|tests|e2e|spec)(/|$)"
+                r"|\.(test|spec|e2e-spec|stories)\.(t|j)sx?$")
+HTTP_VERBS = ("GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS")
+
+
+def pkg_deps(root: Path) -> dict:
+    p = Path(root) / "package.json"
+    if not p.exists():
+        return {}
+    try:
+        d = json.loads(p.read_text())
+    except Exception:
+        return {}
+    return {**(d.get("dependencies") or {}), **(d.get("devDependencies") or {}), **(d.get("peerDependencies") or {})}
+
+
+def has_server_framework(project: Project, which: str | None = None) -> bool:
+    deps = pkg_deps(project.root)
+    names = SERVER_DEPS[which] if which else [d for v in SERVER_DEPS.values() for d in v]
+    return any(n in deps for n in names)
+
+
+def merge_extractor_cfg(cfg: dict, src_dirs=None, skip_re: str | None = None, extra_files=None, allow_js=False, walk_src=False):
+    """Several TS framework plugins may configure the one extractor run: union of source dirs, OR of skip regexes."""
+    if src_dirs:
+        cur = cfg.get("src_dirs") or []
+        cfg["src_dirs"] = list(dict.fromkeys([*cur, *src_dirs]))
+    if skip_re:
+        cfg["skip_re"] = f"(?:{cfg['skip_re']})|(?:{skip_re})" if cfg.get("skip_re") and skip_re not in cfg["skip_re"] else skip_re
+    if extra_files:
+        cfg["extra_files"] = list(dict.fromkeys([*(cfg.get("extra_files") or []), *extra_files]))
+    if allow_js:
+        cfg["allow_js"] = True
+    if walk_src:
+        cfg["walk_src"] = True
+
+
+# ---------------------------------------------------------------- paths
+def join_path(*parts: str | None) -> str:
+    segs = []
+    for p in parts:
+        if not p:
+            continue
+        segs += [s for s in str(p).split("/") if s]
+    return "/" + "/".join(segs)
+
+
+_COLON = re.compile(r":(\w+)(\([^)]*\))?([?*+])?")
+
+
+def express_path(p: str) -> str:
+    """Express / Koa / Fastify / Hono / NestJS path -> uri template: `:id` -> `{id}`, `:id?` -> `{id?}`,
+    `:id(\\d+)` -> `{id}`, catch-alls `:p+` / `*p` -> `{p*}` (one or more segments), `*` / `:p*` / `{*p}` -> `{p*?}`
+    (zero or more)."""
+    if p is None:
+        return ""
+    out = []
+    for seg in str(p).split("/"):
+        if not seg:
+            continue
+        if seg in ("*", "(.*)", "(.*)*"):
+            out.append("{wildcard*?}")
+            continue
+        m = re.fullmatch(r"\{/?\*(\w+)\}", seg)      # Express 5 optional wildcard {*rest}: zero or more
+        if m:
+            out.append("{%s*?}" % m.group(1))
+            continue
+        m = re.fullmatch(r"\*(\w+)", seg)              # Express 5 wildcard *rest: one or more
+        if m:
+            out.append("{%s*}" % m.group(1))
+            continue
+        m = re.fullmatch(r"\{/?:(\w+)\}", seg)   # Express 5 optional `{:id}`
+        if m:
+            out.append("{%s?}" % m.group(1))
+            continue
+
+        def sub(m):
+            name, mod = m.group(1), m.group(3)
+            if mod == "*":
+                return "{%s*?}" % name    # path-to-regexp `:p*` zero or more, `:p+` one or more
+            if mod == "+":
+                return "{%s*}" % name
+            return "{%s?}" % name if mod == "?" else "{%s}" % name
+        out.append(_COLON.sub(sub, seg))
+    return "/" + "/".join(out)
+
+
+def next_segment(seg: str) -> str | None:
+    """Next.js app/pages directory segment -> uri segment ('' = not part of the URL, None = private folder)."""
+    if seg.startswith("_"):
+        return None
+    if re.fullmatch(r"\(.*\)", seg) or seg.startswith("@"):
+        return ""      # route group / parallel-route slot
+    m = re.fullmatch(r"\[\[\.\.\.(\w+)\]\]", seg)
+    if m:
+        return "{%s*?}" % m.group(1)
+    m = re.fullmatch(r"\[\.\.\.(\w+)\]", seg)
+    if m:
+        return "{%s*}" % m.group(1)
+    return re.sub(r"\[(\w+)\]", r"{\1}", seg)
+
+
+# ---------------------------------------------------------------- values described by fw.mjs
+def sval(d) -> str | None:
+    """String value of a described expression ({s}), else None."""
+    return d.get("s") if isinstance(d, dict) and isinstance(d.get("s"), str) else None
+
+
+def svals(d) -> list[str]:
+    if not isinstance(d, dict):
+        return []
+    if isinstance(d.get("s"), str):
+        return [d["s"]]
+    if d.get("ss"):
+        return list(d["ss"])
+    if d.get("arr") is not None:
+        return [x for e in d["arr"] for x in svals(e)]
+    return []
+
+
+def obj(d) -> dict:
+    return d.get("obj") or {} if isinstance(d, dict) else {}
+
+
+def last_name(name: str | None) -> str:
+    return (name or "").split(".")[-1].split("(")[0]
+
+
+def ref_nodes(d, depth=0) -> list[str]:
+    """Code nodes a described value points at (function/method/class), through wrappers and handler objects."""
+    if not isinstance(d, dict) or depth > 4:
+        return []
+    if d.get("fn"):
+        return [d["fn"]]
+    if d.get("node") and d.get("ref") is not None:
+        return [d["node"]]
+    if d.get("obj_fns"):
+        return list(d["obj_fns"])
+    if "call" in d:
+        out = []
+        if last_name(d["call"]) == "bind" and d.get("recv"):
+            return ref_nodes(d["recv"], depth + 1)
+        for a in d.get("args") or []:
+            out += ref_nodes(a, depth + 1)
+        return out
+    return []
+
+
+def snake(name: str) -> str:
+    s = re.sub(r"(?<=[a-z0-9])([A-Z])", r"_\1", name)
+    s = re.sub(r"(?<=[A-Z])([A-Z][a-z])", r"_\1", s)
+    return s.lower()
+
+
+def plural(word: str) -> str:
+    if re.search(r"(s|x|z|ch|sh)$", word):
+        return word + "es"
+    if re.search(r"[^aeiou]y$", word):
+        return word[:-1] + "ies"
+    return word + "s"
+
+
+def module_of(path: str | None) -> str | None:
+    from ..ts.plugin import module_of as m
+    return m(path)
+
+
+# ---------------------------------------------------------------- routes
+def add_route(b: GraphBuilder, method: str, uri: str, handlers: list[str], file: str, line: int, framework: str,
+              confidence: str = "exact", attrs: dict | None = None, middleware: list[tuple[str, str, str]] | None = None) -> str:
+    """route:<METHOD> <uri>, entry kind http_route; ROUTES_TO each handler; USES_MIDDLEWARE (node, name, conf)."""
+    method = method.upper()
+    key = f"{method} {uri}"
+    a = {"uri": uri, "method": method, "framework": framework, **(attrs or {})}
+    if middleware:
+        a["middleware"] = list(dict.fromkeys([m[1] for m in middleware if m[1]]))
+    rid = b.add_node("route", key, name=key, file=file, line=line, module=module_of(file), lang="ts", entry_kind="http_route", attrs=a)
+    n = b.nodes[rid]
+    if n.entry_kind is None:
+        n.entry_kind = "http_route"
+    for h in handlers:
+        if h and b.has(h):
+            b.add_edge(rid, h, "ROUTES_TO", file=file, line=line, confidence=confidence)
+            hn = b.nodes[h]
+            if hn.file and not n.attrs.get("handler"):
+                n.attrs["handler"] = hn.name
+                n.module = module_of(hn.file)
+    for node, name, conf in middleware or []:
+        if node and b.has(node):
+            b.add_edge(rid, node, "USES_MIDDLEWARE", file=file, line=line, confidence=conf, name=name)
+    return rid
+
+
+def route_specs(b: GraphBuilder) -> list[dict]:
+    """Route nodes in the shape link.match_endpoint expects."""
+    out = []
+    for n in b.nodes.values():
+        if n.kind != "route" or n.lang != "ts":
+            continue
+        uri, method = n.attrs.get("uri"), n.attrs.get("method")
+        if not uri or not method:
+            continue
+        uris = [("as-declared", uri)] + [(f"variant:{v}", v) for v in n.attrs.get("uri_variants") or []]
+        out.append({"id": n.id, "uri": uri, "method": method, "uris": uris, "file": n.file, "line": n.line})
+    return out
+
+
+def link_in_repo(b: GraphBuilder, ctx) -> dict:
+    """Client HTTP calls in the same repo (Next.js pages/components, a bundled SPA) -> this repo's routes, with the
+    same deterministic matcher `cg link` uses across repos. Same-origin relative URLs are in scope here."""
+    from ...link import match_endpoint
+    from ...core.model import CONFIDENCE_RANK
+    routes = route_specs(b)
+    st = {"endpoints": 0, "matched": 0}
+    if not routes:
+        return st
+    rmap = {r["id"]: r for r in routes}
+    for n in list(b.nodes.values()):
+        if n.kind != "http" or n.lang != "ts":
+            continue
+        a = n.attrs
+        ok = a.get("origin_kind", "api")
+        if ok == "other":
+            continue
+        st["endpoints"] += 1
+        res = match_endpoint(a.get("method", "GET"), a.get("path", ""), routes, "api" if ok == "same-origin" else ok, a.get("origin"))
+        for m in res["matched"]:
+            r = rmap[m["route"]]
+            b.add_edge(n.id, m["route"], "MATCHES_ROUTE", file=r["file"], line=r["line"], confidence=m["confidence"],
+                       client_path=a.get("path"), uri_variant=m["uri_variant"], segments=m["segments"], in_repo=True)
+        if res["matched"]:
+            st["matched"] += 1
+    return st
+
+
+def finish(project: Project, b: GraphBuilder, ctx, name: str) -> dict:
+    """Called at the end of each TS server framework's contribute(); the shared post-pass runs once, after the last."""
+    pending = getattr(ctx, "tsweb_pending", None)
+    if pending is None:
+        return {}
+    pending.discard(name)
+    if pending:
+        return {}
+    from .data import contribute_data
+    st = contribute_data(project, b, ctx)
+    st["in_repo_links"] = link_in_repo(b, ctx)
+    return {"shared": st}
+
+
+def register(ctx, name: str) -> None:
+    if not hasattr(ctx, "tsweb_pending"):
+        ctx.tsweb_pending = set()
+    ctx.tsweb_pending.add(name)
+
+
+def fw_facts(ctx) -> dict:
+    return (ctx.facts or {}).get("fw") or {} if ctx else {}

codegraph/plugins/tsweb/data.py

@@ -0,0 +1,276 @@
+"""Env/config keys and ORM data access for TypeScript server code (shared by the NestJS, Next.js and Express layers).
+
+env / config
+  process.env.X, process.env['X'], import.meta.env.X, `const { X } = process.env`  -> READS_ENV env:X (exact)
+  ConfigService.get('ns.key') with a registerAs('ns', () => ({ key: process.env.X })) namespace
+      -> READS_CONFIG config:ns.key (resolved), config:ns.key READS_ENV env:X (exact)
+  ConfigService.get('X') (UPPER_SNAKE, no namespace) -> READS_ENV env:X (resolved)
+  NEXT_PUBLIC_ / VITE_ / NUXT_PUBLIC_ keys are marked attrs.public (inlined into client bundles)
+
+tables (node kind `table`, collections too: attrs.collection)
+  TypeORM / MikroORM @Entity('t') | @Entity() (snake_case class name), sequelize-typescript @Table({tableName}),
+  Mongoose @Schema({collection}) / mongoose.model('Cat', s) (lower-case plural)  -> MAPS_TO_TABLE, columns (CONTAINS)
+  Prisma schema.prisma models (@@map / @map)                                       -> table + column nodes
+  Drizzle pgTable/mysqlTable/sqliteTable('t', ...)                                  -> table for the variable
+  reads/writes:
+    this.<repo>.<op>() where <repo> is @InjectRepository(E) / Repository<E> / @InjectModel(E.name) / Model<E>
+    prisma.<model>.<op>(), <ds>.getRepository(E).<op>() / manager.<op>(E, ...)
+    Kysely selectFrom/insertInto/updateTable/deleteFrom('t'), knex('t'), Drizzle .from(t) / .insert(t) / ...
+  -> READS_TABLE / WRITES_TABLE (resolved: needed type/name resolution; heuristic for name-shaped receivers)
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from ...core.plugin import GraphBuilder, Project
+from .common import fw_facts, last_name, obj, plural, ref_nodes, snake, sval, svals
+from ... import presets
+
+# dependency / VCS directories every walk skips (codegraph/presets/common.yaml skip_dirs)
+COMMON_SKIP = presets.skip_dirs("common")
+
+PUBLIC_ENV = re.compile(r"^(NEXT_PUBLIC_|VITE_|NUXT_PUBLIC_|REACT_APP_|EXPO_PUBLIC_|PUBLIC_)")
+READ_OPS = {"findUnique", "findUniqueOrThrow", "findFirst", "findFirstOrThrow", "findMany", "count", "aggregate", "groupBy",
+            "find", "findOne", "findOneBy", "findBy", "findAndCount", "findAndCountBy", "findOneOrFail", "findOneByOrFail", "findByIds",
+            "exist", "exists", "existsBy", "createQueryBuilder", "findAll", "findByPk", "findById", "countDocuments",
+            "estimatedDocumentCount", "distinct", "selectFrom", "from", "innerJoin", "leftJoin", "rightJoin", "fullJoin", "query"}
+KNEX_WRITES = {"insert", "update", "del", "delete", "upsert", "merge", "truncate", "increment", "decrement"}
+WRITE_OPS = {"create", "createMany", "createManyAndReturn", "update", "updateMany", "updateManyAndReturn", "upsert", "delete",
+             "deleteMany", "save", "insert", "remove", "softDelete", "softRemove", "restore", "increment", "decrement",
+             "findOrCreate", "bulkCreate", "destroy", "findByIdAndUpdate", "findByIdAndDelete", "findOneAndUpdate",
+             "findOneAndDelete", "findOneAndReplace", "updateOne", "deleteOne", "insertMany", "replaceOne", "bulkWrite",
+             "insertInto", "updateTable", "deleteFrom", "replaceInto", "mergeInto", "into"}
+ENTITY_DECOS = {"Entity", "ViewEntity", "Table", "Schema"}
+COLUMN_DECOS = {"Column", "PrimaryColumn", "PrimaryGeneratedColumn", "CreateDateColumn", "UpdateDateColumn", "DeleteDateColumn",
+                "VersionColumn", "ObjectIdColumn", "Property", "PrimaryKey", "Prop", "ForeignKey", "Index"}
+RELATION_DECOS = {"ManyToOne", "OneToMany", "OneToOne", "ManyToMany", "BelongsTo", "HasMany", "HasOne", "BelongsToMany"}
+DRIZZLE_TABLES = {"pgTable", "mysqlTable", "sqliteTable", "singlestoreTable", "table"}
+
+
+def _ensure_table(b: GraphBuilder, name: str, **attrs) -> str:
+    return b.add_node("table", name, name=name, lang="ts", attrs=attrs)
+
+
+def _ensure_column(b: GraphBuilder, table: str, col: str, file=None, line=None) -> str:
+    tid = _ensure_table(b, table)
+    cid = b.add_node("column", f"{table}.{col}", name=f"{table}.{col}", file=file, line=line, lang="ts", attrs={"table": table})
+    b.add_edge(tid, cid, "CONTAINS", file=file, line=line, confidence="exact")
+    return cid
+
+
+def parse_prisma(root: Path) -> dict:
+    """model Name { field Type @map("col") ... @@map("table") } -> {Name: {table, fields: {field: column}, file, line}}"""
+    models = {}
+    files = []
+    for pat in ("schema.prisma", "prisma/schema.prisma", "prisma/*.prisma", "prisma/schema/*.prisma", "src/prisma/*.prisma"):
+        files += sorted(root.glob(pat))
+    if not files:
+        files = [p for p in sorted(root.rglob("*.prisma")) if COMMON_SKIP.isdisjoint(p.parts)][:20]
+    for f in dict.fromkeys(files):
+        try:
+            txt = f.read_text()
+        except Exception:
+            continue
+        rel = str(f.relative_to(root))
+        for m in re.finditer(r"^model\s+(\w+)\s*\{(.*?)^\}", txt, re.S | re.M):
+            name, body = m.group(1), m.group(2)
+            line = txt[:m.start()].count("\n") + 1
+            mp = re.search(r"@@map\(\s*(?:name:\s*)?\"([^\"]+)\"", body)
+            fields = {}
+            for fm in re.finditer(r"^\s*(\w+)\s+(\w+)(\[\])?\??([^\n]*)$", body, re.M):
+                fname, ftype, rest = fm.group(1), fm.group(2), fm.group(4)
+                if fname.startswith("@@"):
+                    continue
+                if "@relation" in rest or (ftype[0].isupper() and ftype not in ("String", "Int", "BigInt", "Float", "Decimal", "Boolean", "DateTime", "Json", "Bytes")):
+                    continue
+                cm = re.search(r"@map\(\s*(?:name:\s*)?\"([^\"]+)\"", rest)
+                fields[fname] = cm.group(1) if cm else fname
+            models[name] = {"table": mp.group(1) if mp else name, "fields": fields, "file": rel, "line": line}
+    return models
+
+
+def contribute_data(project: Project, b: GraphBuilder, ctx) -> dict:
+    F = fw_facts(ctx)
+    st = {"env_reads": 0, "config_reads": 0, "tables": 0, "table_reads": 0, "table_writes": 0}
+    if not F:
+        return st
+    classes = {c["id"]: c for c in F.get("classes") or []}
+    instances = F.get("instances") or {}
+
+    # ---- config namespaces (registerAs)
+    cfg_defs = {}
+    for d in F.get("config_defs") or []:
+        cid = b.add_node("config", d["key"], name=d["key"], file=d["file"], line=d["line"], lang="ts", attrs={"namespace": d["ns"]})
+        cfg_defs[d["key"]] = cid
+        for k in d["env"]:
+            b.add_edge(cid, _env(b, k), "READS_ENV", file=d["file"], line=d["line"], confidence="exact")
+    namespaces = {d["ns"] for d in F.get("config_defs") or []}
+    for e in F.get("env") or []:
+        if not e.get("src") or not b.has(e["src"]):
+            continue
+        key = e["key"]
+        if e["via"].startswith("ConfigService"):
+            if key in cfg_defs or key.split(".")[0] in namespaces:
+                cid = cfg_defs.get(key) or b.add_node("config", key, name=key, lang="ts", attrs={"namespace": key.split(".")[0]})
+                b.add_edge(e["src"], cid, "READS_CONFIG", file=e["file"], line=e["line"], confidence="resolved", via=e["via"])
+                st["config_reads"] += 1
+            elif re.fullmatch(r"[A-Z][A-Z0-9_]*", key):
+                b.add_edge(e["src"], _env(b, key), "READS_ENV", file=e["file"], line=e["line"], confidence="resolved", via=e["via"])
+                st["env_reads"] += 1
+            else:
+                cid = b.add_node("config", key, name=key, lang="ts")
+                b.add_edge(e["src"], cid, "READS_CONFIG", file=e["file"], line=e["line"], confidence="resolved", via=e["via"])
+                st["config_reads"] += 1
+            continue
+        b.add_edge(e["src"], _env(b, key), "READS_ENV", file=e["file"], line=e["line"], confidence="exact", via=e["via"])
+        st["env_reads"] += 1
+
+    # ---- entities -> tables
+    entity_table = {}      # class node id -> table
+    model_name_table = {}  # Mongoose model name -> collection
+    for c in classes.values():
+        decos = {last_name(d["name"]): d for d in c.get("decorators") or []}
+        hit = next((n for n in ENTITY_DECOS if n in decos), None)
+        if not hit or not c.get("name"):
+            continue
+        d = decos[hit]
+        a0 = (d.get("args") or [None])[0]
+        if hit == "Schema" and not (d.get("mod") or "").startswith("@nestjs/mongoose") and d.get("mod"):
+            continue
+        if hit == "Table" and d.get("mod") and "sequelize" not in d["mod"]:
+            continue
+        explicit = sval(a0) or sval(obj(a0).get("name")) or sval(obj(a0).get("tableName")) or sval(obj(a0).get("collection"))
+        if hit == "Schema":
+            table, kind = explicit or plural(c["name"].lower()), {"collection": True}
+        elif hit == "Table":
+            table, kind = explicit or plural(c["name"]), {}
+        else:
+            table, kind = explicit or snake(c["name"]), {}
+        tid = _ensure_table(b, table, orm=hit, **kind)
+        entity_table[c["id"]] = table
+        model_name_table[c["name"]] = table
+        if b.has(c["id"]):
+            b.add_edge(c["id"], tid, "MAPS_TO_TABLE", file=c["file"], line=c["line"], confidence="exact" if explicit else "resolved",
+                       via=f"@{hit}" if explicit else "naming-convention")
+        for p in c.get("props") or []:
+            pd = {last_name(x["name"]): x for x in p.get("decorators") or []}
+            col = next((n for n in COLUMN_DECOS if n in pd), None)
+            rel = next((n for n in RELATION_DECOS if n in pd), None)
+            if col:
+                args = pd[col].get("args") or []
+                cname = next((sval(obj(a).get("name")) for a in args if sval(obj(a).get("name"))), None) or p["name"]
+                _ensure_column(b, table, cname, c["file"], p["line"])
+            if rel:
+                for a in pd[rel].get("args") or []:
+                    for n in ref_nodes(a.get("body") or a if isinstance(a, dict) else None) + [((a or {}).get("body") or {}).get("node")]:
+                        if n and n.startswith("class:") and b.has(c["id"]):
+                            b.add_edge(c["id"], n, "HAS_RELATION", file=c["file"], line=p["line"], confidence="exact", relation=rel, property=p["name"])
+                            break
+                    else:
+                        continue
+                    break
+    st["entities"] = len(entity_table)
+
+    # mongoose.model('Cat', CatSchema)
+    for mc in F.get("member_calls") or []:
+        if mc["method"] == "model" and sval(mc.get("a0")):
+            pass
+    prisma = parse_prisma(project.root)
+    prisma_by_client = {}
+    for name, m in prisma.items():
+        tid = _ensure_table(b, m["table"], orm="prisma", model=name)
+        b.nodes[tid].file = b.nodes[tid].file or m["file"]
+        b.nodes[tid].line = b.nodes[tid].line or m["line"]
+        for f, col in m["fields"].items():
+            _ensure_column(b, m["table"], col, m["file"], m["line"])
+        prisma_by_client[name[0].lower() + name[1:]] = m["table"]
+    st["prisma_models"] = len(prisma)
+    drizzle = {}   # instance key -> table
+    drizzle_names = {}
+    for k, inst in instances.items():
+        init = (inst or {}).get("init") or {}
+        if "call" in init and last_name(init["call"]) in DRIZZLE_TABLES and sval((init.get("args") or [None])[0]) and (init.get("mod") or "").startswith("drizzle"):
+            t = sval(init["args"][0])
+            drizzle[k] = t
+            drizzle_names[inst.get("name")] = t
+            _ensure_table(b, t, orm="drizzle")
+    st["drizzle_tables"] = len(drizzle)
+
+    # repositories / models injected into classes: (class id, prop name) -> table
+    repo_prop = {}
+    for c in classes.values():
+        members = [(p, p.get("decorators") or []) for p in c.get("ctor") or []] + [(p, p.get("decorators") or []) for p in c.get("props") or []]
+        for p, decos in members:
+            table = None
+            for d in decos:
+                n = last_name(d["name"])
+                a0 = (d.get("args") or [None])[0] or {}
+                if n == "InjectRepository":
+                    table = entity_table.get(a0.get("node"))
+                elif n == "InjectModel":
+                    ref = (a0.get("ref") or sval(a0) or "").replace(".name", "")
+                    table = model_name_table.get(ref) or entity_table.get(a0.get("node"))
+            t = p.get("type") or {}
+            if not table and t.get("name") in ("Repository", "Model", "EntityRepository", "MongoRepository", "TreeRepository") and t.get("args"):
+                table = entity_table.get((t["args"][0] or {}).get("id"))
+            if table:
+                repo_prop[(c["id"], p["name"])] = table
+    supers = {c["id"]: (c.get("extends") or {}).get("id") for c in classes.values()}
+
+    def prop_table(cls, prop):
+        for _ in range(6):
+            if not cls:
+                return None
+            if (cls, prop) in repo_prop:
+                return repo_prop[(cls, prop)]
+            cls = supers.get(cls)
+        return None
+
+    for mc in F.get("member_calls") or []:
+        src, m = mc.get("src"), mc["method"]
+        if not src or not b.has(src):
+            continue
+        tables, conf, via = [], "resolved", None
+        a0 = mc.get("a0") or {}
+        if mc.get("prop") and (m in READ_OPS or m in WRITE_OPS):
+            t = prop_table(mc.get("cls"), mc["prop"])
+            if t:
+                tables, via = [t], "injected-repository"
+            elif m in ("selectFrom", "insertInto", "updateTable", "deleteFrom", "replaceInto", "mergeInto") and svals(a0):
+                tables, via = [s.split(" ")[0] for s in svals(a0)], "kysely"
+        elif mc.get("chain") and (m in READ_OPS or m in WRITE_OPS):
+            ch = mc["chain"]
+            if len(ch) >= 2 and ch[-1] in prisma_by_client and (re.search(r"prisma|db|tx|client|trx", ".".join(ch[:-1]), re.I) or "Prisma" in (mc.get("recv_type") or "")):
+                tables, via = [prisma_by_client[ch[-1]]], "prisma"
+            elif len(ch) >= 3 and ch[-2] == "query" and ch[-1] in drizzle_names:
+                tables, via = [drizzle_names[ch[-1]]], "drizzle-query"
+            elif m in ("selectFrom", "insertInto", "updateTable", "deleteFrom", "replaceInto", "mergeInto") and svals(a0):
+                tables, via = [s.split(" ")[0] for s in svals(a0)], "kysely"
+            elif a0.get("node") in entity_table:
+                tables, via = [entity_table[a0["node"]]], "entity-argument"
+        elif m == "knex" and svals(a0):
+            tables, via, conf = [s.split(" ")[0] for s in svals(a0)], "knex", "heuristic"
+        elif mc.get("chained") or mc.get("root"):
+            if a0.get("key") in drizzle:
+                tables, via = [drizzle[a0["key"]]], "drizzle"
+            elif m in ("selectFrom", "insertInto", "updateTable", "deleteFrom", "replaceInto", "mergeInto", "innerJoin", "leftJoin") and svals(a0):
+                tables, via = [s.split(" ")[0] for s in svals(a0)], "kysely"
+            elif m in ("from", "into", "table") and svals(a0) and re.search(r"knex|db|trx|qb|query|sql", mc.get("root") or "", re.I):
+                tables, via, conf = [s.split(" ")[0] for s in svals(a0)], "query-builder", "heuristic"
+        if not tables and a0.get("key") in drizzle and m in ("from", "insert", "update", "delete", "into", "innerJoin", "leftJoin"):
+            tables, via = [drizzle[a0["key"]]], "drizzle"
+        for t in tables:
+            if not t or "{" in t:
+                continue
+            tid = _ensure_table(b, t)
+            write = m in WRITE_OPS or (via == "drizzle" and m in ("insert", "update", "delete")) \
+                or (via == "knex" and bool(KNEX_WRITES & set(mc.get("chain") or ())))
+            b.add_edge(src, tid, "WRITES_TABLE" if write else "READS_TABLE", file=mc["file"], line=mc["line"], confidence=conf, via=via, op=m)
+            st["table_writes" if write else "table_reads"] += 1
+    st["tables"] = sum(1 for n in b.nodes.values() if n.kind == "table" and n.lang == "ts")
+    return st
+
+
+def _env(b: GraphBuilder, key: str) -> str:
+    return b.add_node("env", key, name=key, lang="ts", attrs={"public": True} if PUBLIC_ENV.match(key) else {})