sf-intelligence 0.1.26 → 0.2.0

package/dist/apex-ast-worker.js

@@ -0,0 +1,402 @@
+// workers/apex-ast-worker.mjs
+import { parentPort, workerData } from "node:worker_threads";
+
+// ../parsers/dist/src/apex-ast-edges.js
+import { ApexErrorListener, ApexParserFactory } from "@apexdevtools/apex-parser";
+var SYSTEM_TYPES = /* @__PURE__ */ new Set([
+  "String",
+  "Integer",
+  "Decimal",
+  "Double",
+  "Long",
+  "Boolean",
+  "Id",
+  "Date",
+  "Datetime",
+  "Time",
+  "Blob",
+  "Object",
+  "List",
+  "Map",
+  "Set",
+  "Math",
+  "JSON",
+  "Test",
+  "Schema",
+  "UserInfo",
+  "Limits",
+  "EncodingUtil",
+  "Pattern",
+  "Matcher",
+  "Url",
+  "PageReference",
+  "Exception",
+  "AggregateResult",
+  "SObject",
+  "HttpRequest",
+  "HttpResponse",
+  "QueueableContext",
+  "SchedulableContext",
+  "Savepoint",
+  "System",
+  "Database",
+  "Type",
+  "Http",
+  "Trigger"
+]);
+var SYSTEM_CALL_ALLOW = {
+  Database: "*",
+  Type: /* @__PURE__ */ new Set(["forName"]),
+  System: /* @__PURE__ */ new Set(["enqueueJob", "schedule", "scheduleBatch"]),
+  Http: /* @__PURE__ */ new Set(["send"])
+};
+var kids = (n) => Array.from({ length: n.getChildCount?.() ?? 0 }, (_, i) => n.getChild(i));
+var ctxName = (n) => String(n.constructor.name).replace(/Context$/, "");
+var findAll = (n, want, out = []) => {
+  if (ctxName(n) === want)
+    out.push(n);
+  for (const c of kids(n))
+    findAll(c, want, out);
+  return out;
+};
+var ancestorWhere = (node, pred, stopAt = /* @__PURE__ */ new Set()) => {
+  let cur = node.parentCtx;
+  while (cur !== void 0 && cur !== null) {
+    if (pred(cur))
+      return cur;
+    if (stopAt.has(ctxName(cur)))
+      return null;
+    cur = cur.parentCtx;
+  }
+  return null;
+};
+var Collecting = class extends ApexErrorListener {
+  errors = [];
+  apexSyntaxError(line, column, message) {
+    if (this.errors.length < 3)
+      this.errors.push(`${line}:${column} ${message}`);
+  }
+};
+var extractApexAstEdges = (source, className, options = {}) => {
+  const known = options.knownClasses ?? /* @__PURE__ */ new Set();
+  const listener = new Collecting();
+  let tree;
+  try {
+    const parser = ApexParserFactory.createParser(source);
+    parser.removeErrorListeners();
+    parser.addErrorListener(listener);
+    const kind = options.kind ?? (source.trimStart().toLowerCase().startsWith("trigger") ? "trigger" : "class");
+    tree = kind === "trigger" ? parser.triggerUnit() : parser.compilationUnit();
+  } catch (cause) {
+    return {
+      calls: [],
+      reads: [],
+      writes: [],
+      parseError: `parser runtime failure: ${cause instanceof Error ? cause.message : String(cause)}`
+    };
+  }
+  if (listener.errors.length > 0) {
+    return { calls: [], reads: [], writes: [], parseError: listener.errors[0] };
+  }
+  const fieldTypes = /* @__PURE__ */ new Map();
+  const methodLocals = /* @__PURE__ */ new Map();
+  const orphanLocals = /* @__PURE__ */ new Map();
+  const ownMethods = /* @__PURE__ */ new Set();
+  const methodReturnTypes = /* @__PURE__ */ new Map();
+  const innerClasses = /* @__PURE__ */ new Map();
+  let extendsType = null;
+  findAll(tree, "ClassDeclaration").forEach((cd, idx) => {
+    const cname = findAll(cd, "Id")[0]?.getText();
+    if (idx > 0 && cname !== void 0)
+      innerClasses.set(cname, `${className}.${cname}`);
+    const kidList = kids(cd);
+    const ext = kidList.findIndex((k) => k.getText?.() === "extends");
+    if (idx === 0 && ext >= 0)
+      extendsType = kidList[ext + 1]?.getText() ?? null;
+  });
+  const scopeFor = (node) => {
+    const md = ancestorWhere(node, (c) => ctxName(c) === "MethodDeclaration");
+    if (md === null)
+      return orphanLocals;
+    let scope = methodLocals.get(md);
+    if (scope === void 0) {
+      scope = /* @__PURE__ */ new Map();
+      methodLocals.set(md, scope);
+    }
+    return scope;
+  };
+  const declareVar = (typeText, varName, scope) => {
+    if (typeText === void 0 || varName === void 0 || typeText.length === 0)
+      return;
+    scope.set(varName.toLowerCase(), typeText.trim());
+  };
+  for (const md of findAll(tree, "MethodDeclaration")) {
+    const id = kids(md).find((k) => ctxName(k) === "Id")?.getText();
+    if (id === void 0)
+      continue;
+    ownMethods.add(id.toLowerCase());
+    const ret = kids(md).find((k) => ctxName(k) === "TypeRef")?.getText();
+    if (ret !== void 0 && ret.length > 0) {
+      methodReturnTypes.set(id.toLowerCase(), ret.trim());
+    }
+  }
+  for (const fd of findAll(tree, "FieldDeclaration")) {
+    const t = kids(fd)[0]?.getText();
+    for (const vd of findAll(fd, "VariableDeclarator")) {
+      declareVar(t, findAll(vd, "Id")[0]?.getText(), fieldTypes);
+    }
+  }
+  for (const pd of findAll(tree, "PropertyDeclaration")) {
+    declareVar(kids(pd)[0]?.getText(), findAll(pd, "Id")[0]?.getText(), fieldTypes);
+  }
+  for (const lv of findAll(tree, "LocalVariableDeclaration")) {
+    const t = kids(lv).find((k) => ctxName(k) === "TypeRef")?.getText() ?? kids(lv)[0]?.getText();
+    for (const vd of findAll(lv, "VariableDeclarator")) {
+      declareVar(t, findAll(vd, "Id")[0]?.getText(), scopeFor(lv));
+    }
+  }
+  for (const fp of findAll(tree, "FormalParameter")) {
+    const typeText = kids(fp).find((k) => ctxName(k) === "TypeRef")?.getText() ?? kids(fp)[kids(fp).length - 2]?.getText();
+    const varName = kids(fp).find((k) => ctxName(k) === "Id")?.getText() ?? kids(fp)[kids(fp).length - 1]?.getText();
+    declareVar(typeText, varName, scopeFor(fp));
+  }
+  for (const fc of findAll(tree, "EnhancedForControl")) {
+    const ks = kids(fc);
+    declareVar(ks[0]?.getText(), ks[1]?.getText(), scopeFor(fc));
+  }
+  const resolveVarType = (name, at) => {
+    const lower = name.toLowerCase();
+    const md = ancestorWhere(at, (c) => ctxName(c) === "MethodDeclaration");
+    if (md !== null) {
+      const scope = methodLocals.get(md);
+      if (scope?.has(lower))
+        return scope.get(lower) ?? null;
+    } else if (orphanLocals.has(lower)) {
+      return orphanLocals.get(lower) ?? null;
+    }
+    return fieldTypes.get(lower) ?? null;
+  };
+  const calls = /* @__PURE__ */ new Set();
+  const reads = /* @__PURE__ */ new Set();
+  const writes = /* @__PURE__ */ new Set();
+  const callSites = [];
+  const recordCall = (callee, node) => {
+    calls.add(callee);
+    const md = ancestorWhere(node, (c) => ctxName(c) === "MethodDeclaration");
+    const cm = md === null ? void 0 : kids(md).find((k) => ctxName(k) === "Id")?.getText();
+    callSites.push({ callee, callerMethod: cm ?? "" });
+  };
+  const resolveType = (t) => innerClasses.get(t) ?? t;
+  const isSObjectish = (t) => t !== null && t !== void 0 && !SYSTEM_TYPES.has(t) && !innerClasses.has(t) && t !== className && !/[<>]/.test(t) && /^[A-Z]/.test(t) && !known.has(t);
+  const isUserClass = (t) => t === className || innerClasses.has(t) || t === extendsType || known.has(t);
+  const allowSystemCall = (cls, method) => {
+    const rule = SYSTEM_CALL_ALLOW[cls];
+    if (rule === void 0)
+      return false;
+    return rule === "*" || rule.has(method);
+  };
+  const FROM_OBJ = (scopeCtx) => {
+    const direct = scopeCtx.fromNameList?.();
+    const list = direct ?? findAll(scopeCtx, "FromNameList").find((fl) => (ancestorWhere(fl, (c) => ctxName(c) === "SubQuery", /* @__PURE__ */ new Set(["Query"])) ?? scopeCtx) === scopeCtx);
+    if (list === void 0 || list === null)
+      return void 0;
+    const txt = findAll(list, "FieldName")[0]?.getText();
+    return txt === void 0 || txt.length === 0 ? void 0 : txt;
+  };
+  const soqlFrom = (queryCtx) => {
+    const SCOPE = /* @__PURE__ */ new Set(["Query", "SubQuery"]);
+    for (const fn of findAll(queryCtx, "FieldName")) {
+      if (ancestorWhere(fn, (c) => ctxName(c) === "FromNameList", SCOPE) !== null)
+        continue;
+      if (ancestorWhere(fn, (c) => ctxName(c) === "TypeOf", SCOPE) !== null)
+        continue;
+      const scope = ancestorWhere(fn, (c) => SCOPE.has(ctxName(c))) ?? queryCtx;
+      if (ctxName(scope) === "SubQuery") {
+        const semiJoin = ancestorWhere(scope, (c) => ctxName(c) === "WhereClause", /* @__PURE__ */ new Set(["Query", "SubQuery"]));
+        if (semiJoin === null)
+          continue;
+      }
+      const obj = FROM_OBJ(scope);
+      if (obj === void 0)
+        continue;
+      reads.add(`${obj}.${fn.getText()}`);
+    }
+  };
+  for (const q of findAll(tree, "Query"))
+    soqlFrom(q);
+  for (const lit of findAll(tree, "LiteralPrimary")) {
+    const t = lit.getText();
+    if (/^'\s*select\s/i.test(t)) {
+      try {
+        const qp = ApexParserFactory.createParser(t.slice(1, -1));
+        qp.removeErrorListeners();
+        const c = new Collecting();
+        qp.addErrorListener(c);
+        const qt = qp.query();
+        if (c.errors.length === 0)
+          soqlFrom(qt);
+      } catch {
+      }
+    }
+  }
+  const dotSegments = (dot) => {
+    const path = [];
+    let cur = dot;
+    while (cur !== void 0 && ctxName(cur) === "DotExpression") {
+      const ks = kids(cur);
+      const tail = ks[ks.length - 1];
+      if (ctxName(tail) === "DotMethodCall") {
+        const id = findAll(tail, "AnyId")[0]?.getText() ?? findAll(tail, "Id")[0]?.getText();
+        path.unshift({ name: id ?? "", isCall: true });
+      } else {
+        path.unshift({ name: tail.getText(), isCall: false });
+      }
+      cur = ks[0];
+    }
+    if (cur === void 0)
+      return null;
+    return { root: cur.getText(), rootNode: cur, path };
+  };
+  const resolveRootType = (seg) => {
+    const rootLower = seg.root.toLowerCase();
+    if (/^new\s*/i.test(seg.root) || ctxName(seg.rootNode) === "NewExpression") {
+      return seg.root.replace(/^new\s*/i, "").replace(/\(.*\)$/, "").replace(/[<>].*$/, "");
+    }
+    if (rootLower === "this")
+      return className;
+    if (rootLower === "super")
+      return extendsType;
+    if (ctxName(seg.rootNode) === "MethodCallExpression") {
+      const mid = findAll(seg.rootNode, "Id")[0]?.getText();
+      if (mid === void 0 || !ownMethods.has(mid.toLowerCase()))
+        return null;
+      return methodReturnTypes.get(mid.toLowerCase()) ?? null;
+    }
+    return resolveVarType(seg.root, seg.rootNode);
+  };
+  const advanceCalls = (startType, path, at, record) => {
+    let type = startType;
+    let i = 0;
+    for (; i < path.length; i++) {
+      const seg = path[i];
+      if (seg === void 0 || !seg.isCall)
+        break;
+      const method = seg.name;
+      if (type === null)
+        break;
+      if (isUserClass(type)) {
+        if (record)
+          recordCall(`${resolveType(type)}.${method}`, at);
+        if (type === className || resolveType(type) === className) {
+          type = methodReturnTypes.get(method.toLowerCase()) ?? null;
+        } else {
+          type = null;
+        }
+      } else if (allowSystemCall(type, method)) {
+        if (record)
+          recordCall(`${type}.${method}`, at);
+        type = null;
+      } else {
+        type = null;
+      }
+    }
+    return { type, fieldStart: i };
+  };
+  const peelOwnFields = (startType, path, from) => {
+    let type = startType;
+    let i = from;
+    while (i < path.length) {
+      const seg = path[i];
+      if (seg === void 0 || seg.isCall)
+        break;
+      if (type !== className)
+        break;
+      const ft = fieldTypes.get(seg.name.toLowerCase());
+      if (ft === void 0)
+        break;
+      type = ft;
+      i += 1;
+    }
+    return { type, fieldStart: i };
+  };
+  const resolveChain = (rootType, path, at, record) => {
+    const afterCalls = advanceCalls(rootType, path, at, record);
+    return peelOwnFields(afterCalls.type, path, afterCalls.fieldStart);
+  };
+  const writeRoots = /* @__PURE__ */ new Set();
+  for (const asg of findAll(tree, "AssignExpression")) {
+    const lhs = kids(asg)[0];
+    if (lhs !== void 0 && ctxName(lhs) === "DotExpression") {
+      writeRoots.add(lhs);
+      const seg = dotSegments(lhs);
+      if (seg !== null) {
+        const rootType = resolveRootType(seg);
+        const { type, fieldStart } = resolveChain(rootType, seg.path, lhs, false);
+        const fieldPath = seg.path.slice(fieldStart).filter((p) => !p.isCall).map((p) => p.name);
+        if (isSObjectish(type) && fieldPath.length > 0) {
+          writes.add(`${type}.${fieldPath.join(".")}`);
+        }
+      }
+    }
+  }
+  const allDots = findAll(tree, "DotExpression");
+  const nestedDots = /* @__PURE__ */ new Set();
+  for (const d of allDots)
+    for (const c of kids(d))
+      if (ctxName(c) === "DotExpression")
+        nestedDots.add(c);
+  for (const dot of allDots) {
+    if (nestedDots.has(dot))
+      continue;
+    const seg = dotSegments(dot);
+    if (seg === null)
+      continue;
+    const rootType = resolveRootType(seg);
+    const tailIsCall = seg.path.length > 0 && seg.path[seg.path.length - 1]?.isCall === true;
+    if (rootType === null && resolveVarType(seg.root, seg.rootNode) === null && /^[A-Z]/.test(seg.root) && seg.path.length === 1 && tailIsCall) {
+      const last = seg.path[0]?.name ?? "";
+      if (allowSystemCall(seg.root, last))
+        recordCall(`${seg.root}.${last}`, dot);
+      else if (isUserClass(seg.root))
+        recordCall(`${resolveType(seg.root)}.${last}`, dot);
+      continue;
+    }
+    const { type, fieldStart } = resolveChain(rootType, seg.path, dot, true);
+    const fieldPath = seg.path.slice(fieldStart).filter((p) => !p.isCall).map((p) => p.name);
+    if (fieldPath.length > 0 && isSObjectish(type) && !writeRoots.has(dot)) {
+      reads.add(`${type}.${fieldPath.join(".")}`);
+    }
+    if (isSObjectish(rootType) && tailIsCall && seg.path.length > 1 && seg.path.slice(0, -1).every((p) => !p.isCall)) {
+      const before = seg.path.slice(0, -1).map((p) => p.name);
+      if (before.length > 0)
+        reads.add(`${rootType}.${before.join(".")}`);
+    }
+  }
+  for (const mc of findAll(tree, "MethodCallExpression")) {
+    const id = findAll(mc, "Id")[0]?.getText();
+    if (id !== void 0 && ownMethods.has(id.toLowerCase()))
+      recordCall(`${className}.${id}`, mc);
+  }
+  return {
+    calls: [...calls].sort(),
+    reads: [...reads].sort(),
+    writes: [...writes].sort(),
+    innerTypes: [...innerClasses.keys()].sort(),
+    callSites: [...callSites].sort((a, b) => a.callee < b.callee ? -1 : a.callee > b.callee ? 1 : a.callerMethod < b.callerMethod ? -1 : a.callerMethod > b.callerMethod ? 1 : 0)
+  };
+};
+
+// workers/apex-ast-worker.mjs
+if (parentPort === null) {
+  throw new Error("apex-ast-worker must run as a worker_thread");
+}
+var knownClasses = new Set(
+  Array.isArray(workerData?.knownClasses) ? workerData.knownClasses : []
+);
+parentPort.on("message", (job) => {
+  const result = extractApexAstEdges(job.source, job.apiName, {
+    knownClasses,
+    kind: job.kind
+  });
+  parentPort.postMessage({ index: job.index, result });
+});