Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(javascript): retain standalone GraphQL source operations

Ysopwnable6688ed6db7f4
diff --git a/docs/javascript-artifact-reconstruction.md b/docs/javascript-artifact-reconstruction.md
index e66d52d72..ac87b5183 100644
--- a/docs/javascript-artifact-reconstruction.md
+++ b/docs/javascript-artifact-reconstruction.md
@@ -276,8 +276,13 @@ RPC client syntax also contributes network endpoint candidates, in both
named operation found at the start of a string or cooked template literal —
the name must be followed by variable definitions (`($`), a directive, or a
selection set starting with a field name — or in a precompiled
- `OperationDefinition` document object. A graphql-tag `loc.source.body` copy is
- not reported twice. Anonymous operations are not reported.
+ `OperationDefinition` document object. A standalone Source object's `body`
+ remains an operation candidate even when it has `locationOffset` metadata.
+ A graphql-tag `loc.source.body` copy is suppressed only when that source
+ belongs to a recovered document with the same operation and its containing
+ document, location and source have proven private metadata ownership. Writes,
+ escapes and classic-script global bindings retain the source observation.
+ Anonymous operations are not reported.
Literal link options and precompiled document fields follow object property
order: the final definition owns the key. A later spread, dynamic computed key,
diff --git a/src/domain/javascript/javascriptAstValues.ts b/src/domain/javascript/javascriptAstValues.ts
index 8be3a5e83..cd2b5d754 100644
--- a/src/domain/javascript/javascriptAstValues.ts
+++ b/src/domain/javascript/javascriptAstValues.ts
@@ -98,6 +98,30 @@ export const semanticStaticPropertyKey = (
return !computed && t.isIdentifier(property) ? property.name : null;
};
+/** Later properties own a key; an intervening dynamic write leaves it unknown. */
+export const semanticFinalObjectProperty = (
+ node: t.ObjectExpression,
+ key: string,
+): t.Node | undefined => {
+ for (let index = node.properties.length - 1; index >= 0; index -= 1) {
+ const property = node.properties[index];
+ if (property === undefined || t.isSpreadElement(property)) return undefined;
+ const name = semanticStaticPropertyKey(property.key, property.computed);
+ if (name === null) return undefined;
+ if (name === key)
+ return t.isObjectProperty(property) ? property.value : undefined;
+ }
+ return undefined;
+};
+
+export const semanticFinalObjectStringProperty = (
+ node: t.ObjectExpression,
+ key: string,
+): string | undefined => {
+ const value = semanticFinalObjectProperty(node, key);
+ return t.isStringLiteral(value) ? value.value : undefined;
+};
+
/** Read exact consumed object-pattern keys, leaving dynamic keys unknown. */
export const semanticObjectPatternKeys = (
pattern: t.ObjectPattern,
diff --git a/src/domain/javascript/javascriptGraphqlOperations.ts b/src/domain/javascript/javascriptGraphqlOperations.ts
new file mode 100644
index 000000000..820379b78
--- /dev/null
+++ b/src/domain/javascript/javascriptGraphqlOperations.ts
@@ -0,0 +1,479 @@
+import * as t from "@babel/types";
+import {
+ unwrapJavaScriptExpression,
+ semanticStaticPropertyKey,
+ semanticFinalObjectProperty,
+ semanticFinalObjectStringProperty,
+} from "./javascriptAstValues.js";
+import { range } from "./javascriptStaticAnalysisHelpers.js";
+import type { JavaScriptSemanticReference } from "./javascriptSemanticIr.js";
+import {
+ resolveSemanticBindingState,
+ semanticStableInitializer,
+ type JavaScriptSemanticAnalysisState,
+ type JavaScriptBindingIndex,
+} from "./javascriptSemanticState.js";
+import type {
+ JavaScriptRpcEndpoint,
+ JavaScriptRpcScan,
+} from "./javascriptRpcEndpoints.js";
+
+/**
+ * Find source-body string values owned by a GraphQL Source-shaped literal.
+ * A later duplicate or spread can make the effective `body` unknown, but the
+ * earlier strings still belong to this object and must not become standalone
+ * operation findings during the string scan.
+ */
+const graphqlSourceBodyLiterals = (
+ node: t.ObjectExpression,
+): readonly t.StringLiteral[] | undefined => {
+ const hasLocationOffset = node.properties.some(
+ (property) =>
+ t.isObjectProperty(property) &&
+ semanticStaticPropertyKey(property.key, property.computed) ===
+ "locationOffset",
+ );
+ if (!hasLocationOffset) return undefined;
+
+ const bodyStrings = (object: t.ObjectExpression) =>
+ object.properties.flatMap((property) =>
+ t.isObjectProperty(property) &&
+ semanticStaticPropertyKey(property.key, property.computed) === "body" &&
+ t.isStringLiteral(property.value)
+ ? [property.value]
+ : [],
+ );
+ const bodies = bodyStrings(node);
+
+ // Inline object spreads can own additional body values which the surrounding
+ // Source object may select. Include only body-key string literals from those
+ // spread values; ordinary strings elsewhere in the object remain scannable.
+ const visited = new WeakSet<t.ObjectExpression>();
+ visited.add(node);
+ const pending = node.properties.flatMap((property) => {
+ if (!t.isSpreadElement(property)) return [];
+ const spread = unwrapJavaScriptExpression(property.argument).node;
+ return t.isObjectExpression(spread) ? [spread] : [];
+ });
+ while (pending.length > 0) {
+ const current = pending.pop();
+ if (current === undefined || visited.has(current)) continue;
+ visited.add(current);
+ bodies.push(...bodyStrings(current));
+ for (const property of current.properties) {
+ if (t.isSpreadElement(property)) {
+ const spread = unwrapJavaScriptExpression(property.argument).node;
+ if (t.isObjectExpression(spread)) pending.push(spread);
+ }
+ }
+ }
+ return bodies.length === 0 ? undefined : bodies;
+};
+
+const GRAPHQL_OPERATION_TYPES: ReadonlySet<string> = new Set([
+ "query",
+ "mutation",
+ "subscription",
+]);
+
+// GraphQL October 2021 §2.1.7: ignored BOM, tab/space, line endings, commas;
+// comments are consumed separately below.
+const isGraphqlIgnoredCharacter = (character: string): boolean =>
+ character === "," ||
+ character === "\uFEFF" ||
+ character === "\t" ||
+ character === " " ||
+ character === "\n" ||
+ character === "\r";
+
+/** Return the first offset after GraphQL ignored tokens. */
+const skipGraphqlIgnored = (text: string, start: number): number => {
+ const limit = text.length;
+ let index = start;
+ while (index < limit) {
+ const character = text.charAt(index);
+ if (isGraphqlIgnoredCharacter(character)) index += 1;
+ else if (character === "#") {
+ while (index < limit && !/[\n\r]/u.test(text.charAt(index))) index += 1;
+ } else break;
+ }
+ return index;
+};
+
+const graphqlNameAt = (
+ text: string,
+ index: number,
+): { readonly value: string; readonly end: number } | undefined => {
+ const name = /^[_A-Za-z][_0-9A-Za-z]*/u.exec(text.slice(index))?.[0];
+ return name === undefined
+ ? undefined
+ : { value: name, end: index + name.length };
+};
+
+/** Recover a named operation from GraphQL document text. */
+const graphqlOperationFromText = (
+ text: string,
+): JavaScriptRpcEndpoint | undefined => {
+ const type = graphqlNameAt(text, skipGraphqlIgnored(text, 0));
+ if (type === undefined || !GRAPHQL_OPERATION_TYPES.has(type.value))
+ return undefined;
+ const name = graphqlNameAt(text, skipGraphqlIgnored(text, type.end));
+ if (name === undefined) return undefined;
+ const index = skipGraphqlIgnored(text, name.end);
+ const next = text.charAt(index);
+ // Keep the existing bounded recognition scope: a named operation followed
+ // by variable definitions, a directive, or a selection set with a field.
+ const hasHeader =
+ next === "("
+ ? text.charAt(skipGraphqlIgnored(text, index + 1)) === "$"
+ : (next === "@" || next === "{") &&
+ graphqlNameAt(text, skipGraphqlIgnored(text, index + 1)) !== undefined;
+ return hasHeader
+ ? { value: name.value, mechanism: `graphql:${type.value}` }
+ : undefined;
+};
+
+/** Recover a named operation from a precompiled GraphQL document object. */
+const graphqlOperationFromDocumentNode = (
+ node: t.ObjectExpression,
+): JavaScriptRpcEndpoint | undefined => {
+ if (semanticFinalObjectStringProperty(node, "kind") !== "OperationDefinition")
+ return undefined;
+ const type = semanticFinalObjectStringProperty(node, "operation");
+ if (type === undefined || !GRAPHQL_OPERATION_TYPES.has(type))
+ return undefined;
+ const name = semanticFinalObjectProperty(node, "name");
+ if (
+ !t.isObjectExpression(name) ||
+ semanticFinalObjectStringProperty(name, "kind") !== "Name"
+ )
+ return undefined;
+ const value = semanticFinalObjectStringProperty(name, "value");
+ return value === undefined
+ ? undefined
+ : { value, mechanism: `graphql:${type}` };
+};
+
+interface GraphqlSourceDependency {
+ readonly bindingId: string;
+ readonly name: string;
+ readonly location?: JavaScriptSemanticReference["location"];
+}
+
+interface GraphqlSourceCopy {
+ readonly source: t.ObjectExpression;
+ readonly dependencies: readonly GraphqlSourceDependency[];
+ readonly operations: readonly JavaScriptRpcEndpoint[];
+}
+
+/** One private constant owns its initializer; exported or projected values do not. */
+const graphqlPrivateBinding = (
+ node: t.Identifier,
+ state: JavaScriptSemanticAnalysisState,
+ sourceType: t.Program["sourceType"],
+) => {
+ const binding = resolveSemanticBindingState(state, node, node.name);
+ if (binding === undefined || binding.mutable) return undefined;
+ const scope = state.scopesById.get(binding.scopeId);
+ if (
+ scope === undefined ||
+ (scope.kind === "program" && sourceType !== "module")
+ )
+ return undefined;
+ const initializer = semanticStableInitializer(binding, state);
+ if (initializer?.projection.length !== 0) return undefined;
+ const declaration = state.parentsByNode.get(initializer.node);
+ const statement = t.isVariableDeclarator(declaration)
+ ? state.parentsByNode.get(declaration)
+ : undefined;
+ return t.isVariableDeclaration(statement) &&
+ !t.isExportNamedDeclaration(state.parentsByNode.get(statement))
+ ? { binding, initializer }
+ : undefined;
+};
+
+/** Resolve potential metadata ownership; references must still prove exclusivity. */
+const graphqlSourceObjectValue = (
+ node: t.Node | undefined,
+ index: JavaScriptBindingIndex,
+ dependencies: GraphqlSourceDependency[],
+): t.ObjectExpression | undefined => {
+ if (node === undefined) return undefined;
+ const state = index.bindings;
+ const visited = new Set<t.Node>();
+ while (node !== undefined && !visited.has(node)) {
+ visited.add(node);
+ node = unwrapJavaScriptExpression(node).node;
+ if (t.isObjectExpression(node)) return node;
+ if (!t.isIdentifier(node)) return undefined;
+ const owner = graphqlPrivateBinding(node, state, index.sourceType);
+ if (owner === undefined) return undefined;
+ const { binding, initializer } = owner;
+ if (
+ initializer.node.end == null ||
+ node.start == null ||
+ node.loc == null ||
+ initializer.node.end > node.start
+ )
+ return undefined;
+ dependencies.push({
+ bindingId: binding.bindingId,
+ name: binding.name,
+ location: range(node),
+ });
+ node = initializer.node;
+ }
+ return undefined;
+};
+
+const graphqlDocumentSource = (
+ node: t.ObjectExpression,
+ index: JavaScriptBindingIndex,
+): Omit<GraphqlSourceCopy, "operations"> | undefined => {
+ const dependencies: GraphqlSourceDependency[] = [];
+ const loc = graphqlSourceObjectValue(
+ semanticFinalObjectProperty(node, "loc"),
+ index,
+ dependencies,
+ );
+ const source =
+ loc === undefined
+ ? undefined
+ : graphqlSourceObjectValue(
+ semanticFinalObjectProperty(loc, "source"),
+ index,
+ dependencies,
+ );
+ return source !== undefined &&
+ graphqlContainerOwnership(node, index, dependencies)
+ ? { source, dependencies }
+ : undefined;
+};
+
+/** Follow containment to the binding that can expose or mutate this document. */
+const graphqlContainerOwnership = (
+ document: t.ObjectExpression,
+ index: JavaScriptBindingIndex,
+ dependencies: GraphqlSourceDependency[],
+): boolean => {
+ const state = index.bindings;
+ let node: t.Node = document;
+ for (;;) {
+ const parent = state.parentsByNode.get(node);
+ if (parent === undefined) return false;
+ if (t.isObjectProperty(parent) && parent.value === node) {
+ const object = state.parentsByNode.get(parent);
+ if (!t.isObjectExpression(object)) return false;
+ node = object;
+ } else if (
+ t.isArrayExpression(parent) ||
+ unwrapJavaScriptExpression(parent).node === node
+ )
+ node = parent;
+ else if (t.isExpressionStatement(parent)) return true;
+ else if (t.isVariableDeclarator(parent) && parent.init === node) {
+ if (!t.isIdentifier(parent.id)) return false;
+ const owner = graphqlPrivateBinding(parent.id, state, index.sourceType);
+ if (owner?.initializer.node !== node) return false;
+ const { binding } = owner;
+ dependencies.push({ bindingId: binding.bindingId, name: binding.name });
+ return true;
+ } else return false;
+ }
+};
+
+const graphqlDocumentOperations = (
+ node: t.ObjectExpression,
+ operation: JavaScriptRpcEndpoint | undefined,
+): readonly JavaScriptRpcEndpoint[] => {
+ if (operation !== undefined) return [operation];
+ if (semanticFinalObjectStringProperty(node, "kind") !== "Document") return [];
+ const definitions = semanticFinalObjectProperty(node, "definitions");
+ return t.isArrayExpression(definitions)
+ ? definitions.elements.flatMap((definition) => {
+ const recovered = t.isObjectExpression(definition)
+ ? graphqlOperationFromDocumentNode(definition)
+ : undefined;
+ return recovered === undefined ? [] : [recovered];
+ })
+ : [];
+};
+
+const graphqlOperationKey = (operation: JavaScriptRpcEndpoint): string =>
+ `${operation.mechanism}:${operation.value}`;
+
+/** Any non-metadata use makes that connected alias component uncertain. */
+interface GraphqlSourceReferenceIndex {
+ readonly allowed: Map<string, Set<string>>;
+ readonly neighbors: Map<string, Set<string>>;
+ readonly byName: Map<string, Set<string>>;
+}
+
+function* graphqlSourceReferenceIndexSteps(
+ copies: readonly GraphqlSourceCopy[],
+): Generator<void, GraphqlSourceReferenceIndex> {
+ const allowed = new Map<string, Set<string>>();
+ const neighbors = new Map<string, Set<string>>();
+ const byName = new Map<string, Set<string>>();
+ let examined = 0;
+ for (const { dependencies } of copies) {
+ const first = dependencies[0]?.bindingId;
+ for (const { bindingId, name, location } of dependencies) {
+ if (++examined % 1024 === 0) yield;
+ const sites = allowed.get(bindingId) ?? new Set<string>();
+ if (location !== undefined) sites.add(JSON.stringify(location));
+ allowed.set(bindingId, sites);
+ const names = byName.get(name) ?? new Set<string>();
+ names.add(bindingId);
+ byName.set(name, names);
+ if (first === undefined || first === bindingId) continue;
+ const left = neighbors.get(first) ?? new Set<string>();
+ const right = neighbors.get(bindingId) ?? new Set<string>();
+ left.add(bindingId);
+ right.add(first);
+ neighbors.set(first, left);
+ neighbors.set(bindingId, right);
+ }
+ }
+ return { allowed, neighbors, byName };
+}
+
+function* uncertainGraphqlSourceBindingsSteps(
+ index: GraphqlSourceReferenceIndex,
+ references: readonly JavaScriptSemanticReference[],
+): Generator<void, ReadonlySet<string>> {
+ const { allowed, neighbors, byName } = index;
+ const uncertain = new Set<string>();
+ let examined = 0;
+ for (const reference of references) {
+ if (++examined % 1024 === 0) yield;
+ // Direct eval may reach private lexical objects. Indirect eval cannot;
+ // classic-script globals are already rejected at private-binding admission.
+ if (reference.name === "eval") return new Set(allowed.keys());
+ if (reference.bindingId !== null) {
+ const sites = allowed.get(reference.bindingId);
+ if (
+ sites !== undefined &&
+ (reference.role !== "read" ||
+ !sites.has(JSON.stringify(reference.location)))
+ )
+ uncertain.add(reference.bindingId);
+ } else if (
+ reference.resolution === "unknown" ||
+ reference.resolution === "ambiguous"
+ )
+ for (const bindingId of byName.get(reference.name) ?? [])
+ uncertain.add(bindingId);
+ }
+ const pending = [...uncertain];
+ for (
+ let bindingId = pending.pop();
+ bindingId !== undefined;
+ bindingId = pending.pop()
+ )
+ for (const neighbor of neighbors.get(bindingId) ?? []) {
+ if (++examined % 1024 === 0) yield;
+ if (!uncertain.has(neighbor)) {
+ uncertain.add(neighbor);
+ pending.push(neighbor);
+ }
+ }
+ return uncertain;
+}
+
+function* provenGraphqlSourceCopiesSteps(
+ copies: readonly GraphqlSourceCopy[],
+ references: readonly JavaScriptSemanticReference[],
+): Generator<GraphqlSourceCopy | void, void> {
+ const index = yield* graphqlSourceReferenceIndexSteps(copies);
+ const uncertain = yield* uncertainGraphqlSourceBindingsSteps(
+ index,
+ references,
+ );
+ for (const copy of copies)
+ yield copy.dependencies.every(({ bindingId }) => !uncertain.has(bindingId))
+ ? copy
+ : undefined;
+}
+
+const graphqlOperationFromTemplate = (
+ node: t.TemplateLiteral,
+): JavaScriptRpcEndpoint | undefined => {
+ // Interpolations may contain fragment definitions. Continue only
+ // across quasis that contain ignored tokens; prose or dynamic text
+ // before an operation prevents claiming a later operation belongs to
+ // this document prefix.
+ for (const quasi of node.quasis) {
+ const cooked = quasi.value.cooked;
+ if (cooked === undefined || cooked === null) return undefined;
+ if (skipGraphqlIgnored(cooked, 0) === cooked.length) continue;
+ return graphqlOperationFromText(cooked);
+ }
+ return undefined;
+};
+
+export const createJavaScriptGraphqlScan = (
+ index: JavaScriptBindingIndex,
+): JavaScriptRpcScan => {
+ const bodies = new WeakSet<t.Node>();
+ const copied = new WeakMap<t.ObjectExpression, Set<string>>();
+ const copies: GraphqlSourceCopy[] = [];
+ const sources: {
+ readonly source: t.ObjectExpression;
+ readonly node: t.StringLiteral;
+ readonly operation: JavaScriptRpcEndpoint;
+ }[] = [];
+ const retainCopy = ({ source, operations }: GraphqlSourceCopy) => {
+ const keys = copied.get(source) ?? new Set<string>();
+ for (const operation of operations)
+ keys.add(graphqlOperationKey(operation));
+ copied.set(source, keys);
+ };
+ return {
+ inspect: (node: t.Node): JavaScriptRpcEndpoint | undefined => {
+ if (t.isStringLiteral(node))
+ return bodies.has(node)
+ ? undefined
+ : graphqlOperationFromText(node.value);
+ if (t.isTemplateLiteral(node)) return graphqlOperationFromTemplate(node);
+ if (!t.isObjectExpression(node)) return undefined;
+ const operation = graphqlOperationFromDocumentNode(node);
+ if (semanticFinalObjectProperty(node, "loc") !== undefined) {
+ const operations = graphqlDocumentOperations(node, operation);
+ const source =
+ operations.length === 0
+ ? undefined
+ : graphqlDocumentSource(node, index);
+ if (source !== undefined) {
+ copies.push({ ...source, operations });
+ }
+ }
+ const owned = graphqlSourceBodyLiterals(node);
+ if (owned !== undefined) {
+ for (const body of owned) bodies.add(body);
+ const body = semanticFinalObjectProperty(node, "body");
+ const recovered = t.isStringLiteral(body)
+ ? graphqlOperationFromText(body.value)
+ : undefined;
+ if (t.isStringLiteral(body) && recovered !== undefined)
+ sources.push({ source: node, node: body, operation: recovered });
+ }
+ return operation;
+ },
+ *finish() {
+ if (sources.length > 0 && copies.length > 0) {
+ const references = yield* index.referencesSteps();
+ for (const copy of provenGraphqlSourceCopiesSteps(copies, references)) {
+ if (copy !== undefined) retainCopy(copy);
+ yield;
+ }
+ }
+ for (const { source, node, operation } of sources)
+ yield copied.get(source)?.has(graphqlOperationKey(operation))
+ ? undefined
+ : { node, ...operation };
+ sources.length = 0;
+ copies.length = 0;
+ },
+ };
+};
diff --git a/src/domain/javascript/javascriptRpcEndpoints.test.ts b/src/domain/javascript/javascriptRpcEndpoints.test.ts
index e0f049a38..104c0e1be 100644
--- a/src/domain/javascript/javascriptRpcEndpoints.test.ts
+++ b/src/domain/javascript/javascriptRpcEndpoints.test.ts
@@ -401,6 +401,255 @@ describe("GraphQL operation recognition", () => {
});
describe("GraphQL document ownership", () => {
+ it("retains the only operation in a standalone Source object", () => {
+ expect(
+ rpcEndpoints(`const source = {
+ body: "query GetUser { user { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };`),
+ ).toEqual([
+ { kind: "network", value: "GetUser", mechanism: "graphql:query" },
+ ]);
+ });
+
+ it("does not deduplicate an unrelated Source against the same operation name", () => {
+ expect(
+ rpcEndpoints(`
+ const source = {
+ body: "query GetUser { user { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ const operation = {
+ kind: "OperationDefinition", operation: "query",
+ name: { kind: "Name", value: "GetUser" },
+ };
+ `),
+ ).toEqual([
+ { kind: "network", value: "GetUser", mechanism: "graphql:query" },
+ { kind: "network", value: "GetUser", mechanism: "graphql:query" },
+ ]);
+ });
+
+ it.each(["referenced", "inline"])(
+ "deduplicates a proven %s source reference",
+ (representation) => {
+ const source = `{
+ body: "query GetUser { user { id } }",
+ locationOffset: { line: 1, column: 1 },
+ }`;
+ const document = `export {}; const doc = { kind: "Document", definitions: [{
+ kind: "OperationDefinition", operation: "query",
+ name: { kind: "Name", value: "GetUser" },
+ }], loc: { source: ${representation === "referenced" ? "source" : source} } };`;
+ expect(
+ rpcEndpoints(
+ representation === "referenced"
+ ? `const source = ${source};` + document
+ : document,
+ ),
+ ).toEqual([
+ { kind: "network", value: "GetUser", mechanism: "graphql:query" },
+ ]);
+ },
+ );
+
+ it("retains source text that differs from its document operation", () => {
+ const actual = rpcEndpoints(`
+ const source = {
+ body: "query SourceUser { user { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ const operation = {
+ kind: "OperationDefinition", operation: "mutation",
+ name: { kind: "Name", value: "UpdateUser" }, loc: { source },
+ };
+ `);
+ expect(actual).toHaveLength(2);
+ expect(actual).toEqual(
+ expect.arrayContaining([
+ { kind: "network", value: "SourceUser", mechanism: "graphql:query" },
+ { kind: "network", value: "UpdateUser", mechanism: "graphql:mutation" },
+ ]),
+ );
+ });
+
+ it("selects only the final known standalone Source body", () => {
+ expect(
+ rpcEndpoints(`const source = {
+ body: "query Old { user { id } }",
+ body: "query Current { user { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };`),
+ ).toEqual([
+ { kind: "network", value: "Current", mechanism: "graphql:query" },
+ ]);
+ });
+
+ it("does not prove source ownership from an uninitialized reference", () => {
+ const actual = rpcEndpoints(`
+ const operation = {
+ kind: "OperationDefinition", operation: "query",
+ name: { kind: "Name", value: "GetUser" }, loc: { source },
+ };
+ const source = {
+ body: "query GetUser { user { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ `);
+ expect(actual).toHaveLength(2);
+ expect(actual.every(({ value }) => value === "GetUser")).toBe(true);
+ });
+});
+
+describe("GraphQL document container ownership", () => {
+ it.each([
+ ["", "", 2],
+ ["export {};", "", 1],
+ ["function inspect() {", "}", 1],
+ ] as const)(
+ "distinguishes global script bindings from private lexical objects: %s",
+ (prefix, suffix, count) => {
+ expect(
+ rpcEndpoints(`
+ ${prefix}
+ const source={body:"query GetUser { user { id } }",locationOffset:{line:1,column:1}};
+ const doc={kind:"OperationDefinition",operation:"query",name:{kind:"Name",value:"GetUser"},loc:{source}};
+ ${suffix}
+ `),
+ ).toHaveLength(count);
+ },
+ );
+
+ it("does not prove a copy when a caller supplies direct eval", () => {
+ expect(
+ rpcEndpoints(`
+ function inspect(eval) {
+ const source={body:"query GetUser { user { id } }",locationOffset:{line:1,column:1}};
+ const doc={kind:"OperationDefinition",operation:"query",name:{kind:"Name",value:"GetUser"},loc:{source}};
+ eval("doc.loc.source={}");
+ }
+ `),
+ ).toHaveLength(2);
+ });
+
+ it.each([
+ ["export {}; ", "", 1],
+ ["export {}; ", "holder.docs[0].loc.source = {};", 2],
+ ["export ", "", 2],
+ ] as const)(
+ "checks containing object and array ownership: %s %s",
+ (prefix, effect, count) => {
+ expect(
+ rpcEndpoints(`
+ ${prefix}const holder = {docs:[{kind:"OperationDefinition",operation:"query",name:{kind:"Name",value:"GetUser"},loc:{source:{body:"query GetUser { user { id } }",locationOffset:{line:1,column:1}}}}]};
+ ${effect}
+ `),
+ ).toHaveLength(count);
+ },
+ );
+
+ it.each([
+ ["", 'const indirect=globalThis; indirect.eval("loc.source={}");', 2],
+ ["export {};", 'globalThis.eval("loc.source={}");', 1],
+ ["export {};", 'eval("loc.source={}");', 2],
+ ] as const)(
+ "respects lexical exposure for indirect evaluation: %s %s",
+ (prefix, effect, count) => {
+ expect(
+ rpcEndpoints(`
+ ${prefix}
+ const source={body:"query GetUser { user { id } }",locationOffset:{line:1,column:1}};
+ const loc={source};
+ const doc={kind:"OperationDefinition",operation:"query",name:{kind:"Name",value:"GetUser"},loc};
+ ${effect}
+ `),
+ ).toHaveLength(count);
+ },
+ );
+
+ it.each([
+ "doc.loc.source = {};",
+ "mutate(doc);",
+ "export { doc };",
+ 'globalThis.eval("source.body = replacement");',
+ ])("retains sources exposed through their document: %s", (effect) => {
+ const actual = rpcEndpoints(`
+ const source = {body:"query GetUser { user { id } }",locationOffset:{line:1,column:1}};
+ const doc = {kind:"OperationDefinition",operation:"query",name:{kind:"Name",value:"GetUser"},loc:{source}};
+ ${effect}
+ `);
+ expect(actual).toHaveLength(2);
+ });
+
+ it.each(["doc.loc.source = {};", "mutate(doc);", "export { doc };"])(
+ "retains inline sources when the document escapes: %s",
+ (effect) => {
+ const actual = rpcEndpoints(`
+ const doc = {kind:"OperationDefinition",operation:"query",name:{kind:"Name",value:"GetUser"},loc:{source:{body:"query GetUser { user { id } }",locationOffset:{line:1,column:1}}}};
+ ${effect}
+ `);
+ expect(actual).toHaveLength(2);
+ },
+ );
+});
+
+describe("GraphQL source alias effects", () => {
+ it.each([
+ 'source.body = "query Changed { user { id } }";',
+ "mutate(source);",
+ 'eval("source.body = replacement");',
+ ])(
+ "retains Source observations after an unproven member effect: %s",
+ (effect) => {
+ const actual = rpcEndpoints(`
+ const source = {
+ body: "query GetUser { user { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ ${effect}
+ const operation = {
+ kind: "OperationDefinition", operation: "query",
+ name: { kind: "Name", value: "GetUser" }, loc: { source },
+ };
+ `);
+ expect(actual.filter(({ value }) => value === "GetUser")).toHaveLength(2);
+ },
+ );
+
+ it("does not prove source ownership through a changed location alias", () => {
+ const actual = rpcEndpoints(`
+ const source = {
+ body: "query GetUser { user { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ const loc = { source };
+ loc.source = {};
+ const operation = {
+ kind: "OperationDefinition", operation: "query",
+ name: { kind: "Name", value: "GetUser" }, loc,
+ };
+ `);
+ expect(actual).toHaveLength(2);
+ });
+
+ it.each(["inline", "specifier"])(
+ "retains separately exported sources: %s",
+ (form) => {
+ const actual = rpcEndpoints(`
+ ${form === "inline" ? "export" : ""} const source = {
+ body: "query GetUser { user { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ ${form === "specifier" ? "export { source };" : ""}
+ const doc = { kind: "OperationDefinition", operation: "query",
+ name: { kind: "Name", value: "GetUser" }, loc: { source } };
+ `);
+ expect(actual).toHaveLength(2);
+ },
+ );
+});
+
+describe("GraphQL document recognition", () => {
it("recognizes precompiled GraphQL document objects", () => {
expect(
rpcEndpoints(`
@@ -430,9 +679,10 @@ describe("GraphQL document ownership", () => {
).toEqual([]);
});
- it("reports a precompiled graphql-tag document once, not again from loc.source.body", () => {
+ it("reports a private precompiled document once, not again from loc.source.body", () => {
expect(
rpcEndpoints(`
+ export {};
const doc = { kind: "Document", definitions: [{
kind: "OperationDefinition",
operation: "query",
@@ -459,6 +709,7 @@ describe("GraphQL document ownership", () => {
(sourceFields) => {
expect(
rpcEndpoints(`
+ export {};
const source = { ${sourceFields} };
const operation = {
kind: "OperationDefinition",
diff --git a/src/domain/javascript/javascriptRpcEndpoints.ts b/src/domain/javascript/javascriptRpcEndpoints.ts
index 08e6f3aa6..a7af6d246 100644
--- a/src/domain/javascript/javascriptRpcEndpoints.ts
+++ b/src/domain/javascript/javascriptRpcEndpoints.ts
@@ -3,8 +3,11 @@ import * as t from "@babel/types";
import {
unwrapJavaScriptExpression,
semanticStaticPropertyKey,
+ semanticFinalObjectStringProperty,
} from "./javascriptAstValues.js";
import { calleeName } from "./javascriptStaticAnalysisHelpers.js";
+import type { JavaScriptBindingIndex } from "./javascriptSemanticState.js";
+import { createJavaScriptGraphqlScan } from "./javascriptGraphqlOperations.js";
/** One RPC operation or transport URL recovered from client-side syntax. */
export interface JavaScriptRpcEndpoint {
@@ -12,9 +15,12 @@ export interface JavaScriptRpcEndpoint {
readonly mechanism: string;
}
-/** Per-source RPC recognition state; feed it every AST node in pre-order. */
+/** Feed every AST node in pre-order, then drain finish() for Source findings. */
export interface JavaScriptRpcScan {
inspect(node: t.Node): JavaScriptRpcEndpoint | undefined;
+ finish(): Iterable<
+ (JavaScriptRpcEndpoint & { readonly node: t.Node }) | void
+ >;
}
// tRPC proxies preserve router and procedure names as property names, so they
@@ -122,165 +128,6 @@ const objectKeys = (node: t.Node | undefined): readonly string[] =>
})
: [];
-/** Later properties own a key; an intervening dynamic write leaves it unknown. */
-const objectProperty = (
- node: t.ObjectExpression,
- key: string,
-): t.Node | undefined => {
- for (let index = node.properties.length - 1; index >= 0; index -= 1) {
- const property = node.properties[index];
- if (property === undefined || t.isSpreadElement(property)) return undefined;
- const name = semanticStaticPropertyKey(property.key, property.computed);
- if (name === null) return undefined;
- if (name === key)
- return t.isObjectProperty(property) ? property.value : undefined;
- }
- return undefined;
-};
-
-const objectStringProperty = (
- node: t.ObjectExpression,
- key: string,
-): string | undefined => {
- const value = objectProperty(node, key);
- return t.isStringLiteral(value) ? value.value : undefined;
-};
-
-/**
- * Find source-body string values owned by a GraphQL Source-shaped literal.
- * A later duplicate or spread can make the effective `body` unknown, but the
- * earlier strings still belong to this object and must not become standalone
- * operation findings during the string scan.
- */
-const graphqlSourceBodyLiterals = (
- node: t.ObjectExpression,
-): readonly t.StringLiteral[] | undefined => {
- const bodyStrings = (object: t.ObjectExpression) =>
- object.properties.flatMap((property) =>
- t.isObjectProperty(property) &&
- semanticStaticPropertyKey(property.key, property.computed) === "body" &&
- t.isStringLiteral(property.value)
- ? [property.value]
- : [],
- );
- const bodies = bodyStrings(node);
- const hasLocationOffset = node.properties.some(
- (property) =>
- t.isObjectProperty(property) &&
- semanticStaticPropertyKey(property.key, property.computed) ===
- "locationOffset",
- );
- if (!hasLocationOffset) return undefined;
-
- // Inline object spreads can own additional body values which the surrounding
- // Source object may select. Include only body-key string literals from those
- // spread values; ordinary strings elsewhere in the object remain scannable.
- const visited = new WeakSet<t.ObjectExpression>();
- visited.add(node);
- const pending = node.properties.flatMap((property) => {
- if (!t.isSpreadElement(property)) return [];
- const spread = unwrapJavaScriptExpression(property.argument).node;
- return t.isObjectExpression(spread) ? [spread] : [];
- });
- while (pending.length > 0) {
- const current = pending.pop();
- if (current === undefined || visited.has(current)) continue;
- visited.add(current);
- bodies.push(...bodyStrings(current));
- for (const property of current.properties) {
- if (t.isSpreadElement(property)) {
- const spread = unwrapJavaScriptExpression(property.argument).node;
- if (t.isObjectExpression(spread)) pending.push(spread);
- }
- }
- }
- return bodies.length === 0 ? undefined : bodies;
-};
-
-const GRAPHQL_OPERATION_TYPES: ReadonlySet<string> = new Set([
- "query",
- "mutation",
- "subscription",
-]);
-
-// GraphQL October 2021 §2.1.7: ignored BOM, tab/space, line endings, commas;
-// comments are consumed separately below.
-const isGraphqlIgnoredCharacter = (character: string): boolean =>
- character === "," ||
- character === "\uFEFF" ||
- character === "\t" ||
- character === " " ||
- character === "\n" ||
- character === "\r";
-
-/** Return the first offset after GraphQL ignored tokens. */
-const skipGraphqlIgnored = (text: string, start: number): number => {
- const limit = text.length;
- let index = start;
- while (index < limit) {
- const character = text.charAt(index);
- if (isGraphqlIgnoredCharacter(character)) index += 1;
- else if (character === "#") {
- while (index < limit && !/[\n\r]/u.test(text.charAt(index))) index += 1;
- } else break;
- }
- return index;
-};
-
-const graphqlNameAt = (
- text: string,
- index: number,
-): { readonly value: string; readonly end: number } | undefined => {
- const name = /^[_A-Za-z][_0-9A-Za-z]*/u.exec(text.slice(index))?.[0];
- return name === undefined
- ? undefined
- : { value: name, end: index + name.length };
-};
-
-/** Recover a named operation from GraphQL document text. */
-export const graphqlOperationFromText = (
- text: string,
-): JavaScriptRpcEndpoint | undefined => {
- const type = graphqlNameAt(text, skipGraphqlIgnored(text, 0));
- if (type === undefined || !GRAPHQL_OPERATION_TYPES.has(type.value))
- return undefined;
- const name = graphqlNameAt(text, skipGraphqlIgnored(text, type.end));
- if (name === undefined) return undefined;
- const index = skipGraphqlIgnored(text, name.end);
- const next = text.charAt(index);
- // Keep the existing bounded recognition scope: a named operation followed
- // by variable definitions, a directive, or a selection set with a field.
- const hasHeader =
- next === "("
- ? text.charAt(skipGraphqlIgnored(text, index + 1)) === "$"
- : (next === "@" || next === "{") &&
- graphqlNameAt(text, skipGraphqlIgnored(text, index + 1)) !== undefined;
- return hasHeader
- ? { value: name.value, mechanism: `graphql:${type.value}` }
- : undefined;
-};
-
-/** Recover a named operation from a precompiled GraphQL document object. */
-export const graphqlOperationFromDocumentNode = (
- node: t.ObjectExpression,
-): JavaScriptRpcEndpoint | undefined => {
- if (objectStringProperty(node, "kind") !== "OperationDefinition")
- return undefined;
- const type = objectStringProperty(node, "operation");
- if (type === undefined || !GRAPHQL_OPERATION_TYPES.has(type))
- return undefined;
- const name = objectProperty(node, "name");
- if (
- !t.isObjectExpression(name) ||
- objectStringProperty(name, "kind") !== "Name"
- )
- return undefined;
- const value = objectStringProperty(name, "value");
- return value === undefined
- ? undefined
- : { value, mechanism: `graphql:${type}` };
-};
-
/** Bundlers use `(0, imported.factory)` to call an import without a receiver. */
const rpcFactoryName = (callee: t.Node): string => {
let current = unwrapJavaScriptExpression(callee).node;
@@ -312,7 +159,7 @@ const trpcLinkUrl = (
if (!TRPC_URL_LINKS.has(factory)) return undefined;
const options = node.arguments[0];
if (!t.isObjectExpression(options)) return undefined;
- const url = objectStringProperty(options, "url");
+ const url = semanticFinalObjectStringProperty(options, "url");
return url === undefined
? undefined
: { value: url, mechanism: `trpc:link:${factory}` };
@@ -328,14 +175,12 @@ const trpcLinkUrl = (
export const createJavaScriptRpcScan = (
source: string,
clientRoots: ReadonlySet<t.Node>,
+ index: JavaScriptBindingIndex,
): JavaScriptRpcScan => {
let marker: boolean | undefined;
const hasMarker = (): boolean =>
(marker ??= TRPC_SOURCE_MARKERS.some((value) => source.includes(value)));
- // graphql-tag documents retain source text in loc.source.body. Keep each
- // direct body literal owned by a Source-shaped object out of the independent
- // string scan, including duplicates that a later property or spread hides.
- const graphqlDocumentSourceBodies = new WeakSet<t.Node>();
+ const graphql = createJavaScriptGraphqlScan(index);
const procedure = (
node: t.CallExpression | t.OptionalCallExpression,
@@ -369,32 +214,8 @@ export const createJavaScriptRpcScan = (
inspect: (node) => {
if (t.isCallExpression(node) || t.isOptionalCallExpression(node))
return trpcLinkUrl(node) ?? procedure(node);
- if (t.isObjectExpression(node)) {
- const bodies = graphqlSourceBodyLiterals(node);
- if (bodies !== undefined) {
- for (const body of bodies) graphqlDocumentSourceBodies.add(body);
- return undefined;
- }
- return graphqlOperationFromDocumentNode(node);
- }
- if (t.isStringLiteral(node))
- return graphqlDocumentSourceBodies.has(node)
- ? undefined
- : graphqlOperationFromText(node.value);
- if (t.isTemplateLiteral(node)) {
- // Interpolations may contain fragment definitions. Continue only
- // across quasis that contain ignored tokens; prose or dynamic text
- // before an operation prevents claiming a later operation belongs to
- // this document prefix.
- for (const quasi of node.quasis) {
- const cooked = quasi.value.cooked;
- if (cooked === undefined || cooked === null) return undefined;
- if (skipGraphqlIgnored(cooked, 0) === cooked.length) continue;
- return graphqlOperationFromText(cooked);
- }
- return undefined;
- }
- return undefined;
+ return graphql.inspect(node);
},
+ finish: graphql.finish,
};
};
diff --git a/src/domain/javascript/javascriptSemanticAnalysis.ts b/src/domain/javascript/javascriptSemanticAnalysis.ts
index df6f4d21b..5d63b7699 100644
--- a/src/domain/javascript/javascriptSemanticAnalysis.ts
+++ b/src/domain/javascript/javascriptSemanticAnalysis.ts
@@ -27,6 +27,7 @@ import type {
JavaScriptSemanticAnalysisState,
JavaScriptSemanticBindingState,
JavaScriptSemanticScopeState,
+ JavaScriptBindingIndex,
} from "./javascriptSemanticState.js";
import {
currentSemanticScope,
@@ -243,46 +244,37 @@ export interface JavaScriptReceiverFacts {
readonly rpcClientRoots: ReadonlySet<t.Node>;
}
-/**
- * Resolve only the lexical receiver identities needed to distinguish browser
- * `window.open` from XHR and global storage `.open` calls, configuration
- * `.get` reads from HTTP client calls, and tRPC client roots (excluding
- * overwritten bindings). This deliberately builds definitions without running
- * semantic value or provenance analysis.
- */
-export const classifyParsedJavaScriptReceivers = (
- file: ParsedJavaScriptSource,
-): JavaScriptReceiverFacts =>
- completeSemanticSteps(classifyParsedJavaScriptReceiversSteps(file));
-
-/** Classify receivers while yielding during lexical and AST scans. */
-export function* classifyParsedJavaScriptReceiversSteps(
- file: ParsedJavaScriptSource,
-): Generator<void, JavaScriptReceiverFacts> {
- const state = createState(file.program);
- yield* collectDefinitionsSteps(file.program, state);
- return yield* classifyDefinitionReceiversSteps(file.program, state);
+export interface JavaScriptReceiverIndex extends JavaScriptBindingIndex {
+ readonly receivers: JavaScriptReceiverFacts;
}
/**
* Index bindings and classify receivers from one definitions pass. Receiver
- * facts read the definitions-only phase, so they are classified before the
- * same state is extended with ambient writes.
+ * facts read the definitions-only phase. Consumers request ambient writes and
+ * lexical references only when needed; each optional index is built once.
*/
export function* indexJavaScriptBindingsWithReceiversSteps(
program: t.Program,
-): Generator<
- void,
- {
- readonly bindings: JavaScriptSemanticAnalysisState;
- readonly receivers: JavaScriptReceiverFacts;
- }
-> {
+): Generator<void, JavaScriptReceiverIndex> {
const state = createState(program);
yield* collectDefinitionsSteps(program, state);
const receivers = yield* classifyDefinitionReceiversSteps(program, state);
- yield* indexJavaScriptAmbientWritesSteps(program, state);
- return { bindings: state, receivers };
+ let ambientIndexed = false;
+ let references: readonly JavaScriptSemanticReference[] | undefined;
+ return {
+ sourceType: program.sourceType,
+ bindings: state,
+ receivers,
+ *indexAmbientWritesSteps() {
+ if (ambientIndexed) return;
+ yield* indexJavaScriptAmbientWritesSteps(program, state);
+ ambientIndexed = true;
+ },
+ *referencesSteps() {
+ references ??= yield* collectSemanticReferencesSteps(program, state);
+ return references;
+ },
+ };
}
function* classifyDefinitionReceiversSteps(
diff --git a/src/domain/javascript/javascriptSemanticAnalysisSteps.test.ts b/src/domain/javascript/javascriptSemanticAnalysisSteps.test.ts
index 1afd5e48b..175ca2352 100644
--- a/src/domain/javascript/javascriptSemanticAnalysisSteps.test.ts
+++ b/src/domain/javascript/javascriptSemanticAnalysisSteps.test.ts
@@ -5,15 +5,47 @@ import {
analyzeParsedJavaScriptSemanticsSteps,
classifyParsedJavaScriptElectronBindings,
classifyParsedJavaScriptElectronBindingsSteps,
- classifyParsedJavaScriptReceivers,
- classifyParsedJavaScriptReceiversSteps,
+ indexJavaScriptBindingsWithReceiversSteps,
} from "./javascriptSemanticAnalysis.js";
import { parseJavaScriptSource } from "./javascriptSourceParser.js";
+import { createJavaScriptGraphqlScan } from "./javascriptGraphqlOperations.js";
import {
+ completeSemanticSteps,
traverseJavaScriptAst,
traverseJavaScriptAstSteps,
} from "./javascriptSemanticTraversal.js";
+it.each([false, true])(
+ "checkpoints suppressed GraphQL sources, including alias proof (aliases: %s)",
+ (aliased) => {
+ const count = 1100;
+ const source = Array.from({ length: count }, (_, index) => {
+ const value = `{body:"query Q${index} { id }",locationOffset:{line:1,column:1}}`;
+ const declaration = aliased ? `const source${index}=${value};` : "";
+ return `${declaration}const doc${index}={kind:"OperationDefinition",operation:"query",name:{kind:"Name",value:"Q${index}"},loc:{source:${aliased ? `source${index}` : value}}};`;
+ }).join("\n");
+ const parsed = parseJavaScriptSource(source, "sources.mjs");
+ if (parsed === null) throw new Error("Expected parsed source");
+ const index = completeSemanticSteps(
+ indexJavaScriptBindingsWithReceiversSteps(parsed.program),
+ );
+ const scan = createJavaScriptGraphqlScan(index);
+ let operations = 0;
+ traverseJavaScriptAst(parsed.program, {
+ enter: (node) => {
+ if (scan.inspect(node) !== undefined) operations += 1;
+ },
+ });
+ expect(operations).toBe(count);
+ let checkpoints = 0;
+ for (const finding of scan.finish()) {
+ expect(finding).toBeUndefined();
+ checkpoints += 1;
+ }
+ expect(checkpoints).toBeGreaterThanOrEqual(count);
+ },
+);
+
const source = `
import { readFile } from "node:fs";
const shared = { token: "TOKEN" };
@@ -110,15 +142,14 @@ new NativeWindow();
`;
const parsed = parseJavaScriptSource(text, "receivers.js");
if (parsed === null) throw new Error("Expected parsed source");
- const openSteps = classifyParsedJavaScriptReceiversSteps(parsed);
+ const openSteps = indexJavaScriptBindingsWithReceiversSteps(parsed.program);
let openStep = openSteps.next();
expect(openStep.done).toBe(false);
while (openStep.done !== true) openStep = openSteps.next();
- expect([...openStep.value.openReceivers]).toEqual([
+ expect([...openStep.value.receivers.openReceivers]).toEqual([
[text.indexOf('ambient.open("/local")'), "local"],
[text.indexOf('ambient.open("/global")'), "window"],
]);
- expect(openStep.value).toEqual(classifyParsedJavaScriptReceivers(parsed));
const electronSteps = classifyParsedJavaScriptElectronBindingsSteps(parsed);
let electronStep = electronSteps.next();
diff --git a/src/domain/javascript/javascriptSemanticState.ts b/src/domain/javascript/javascriptSemanticState.ts
index 96fa37d67..6f26f68b4 100644
--- a/src/domain/javascript/javascriptSemanticState.ts
+++ b/src/domain/javascript/javascriptSemanticState.ts
@@ -11,6 +11,7 @@ import type {
JavaScriptSemanticModuleLink,
JavaScriptSemanticCallable,
JavaScriptSemanticScope,
+ JavaScriptSemanticReference,
} from "./javascriptSemanticIr.js";
import type { JavaScriptModuleResolutionMode } from "./javascriptModuleResolutionMode.js";
@@ -109,6 +110,14 @@ export interface JavaScriptSemanticAnalysisState {
readonly ambientWriteEffects: JavaScriptSemanticMemberEffect[];
}
+/** One parsed source owns its optional indexes and their per-source lifetime. */
+export interface JavaScriptBindingIndex {
+ readonly sourceType: t.Program["sourceType"];
+ readonly bindings: JavaScriptSemanticAnalysisState;
+ indexAmbientWritesSteps(): Generator<void, void>;
+ referencesSteps(): Generator<void, readonly JavaScriptSemanticReference[]>;
+}
+
/**
* Return one unconditional source initializer for a declared lexical binding.
* Repeated variable declarations without another initializer do not write it.
diff --git a/src/domain/javascript/javascriptStaticAnalysis.ts b/src/domain/javascript/javascriptStaticAnalysis.ts
index 0b87da864..49158abe6 100644
--- a/src/domain/javascript/javascriptStaticAnalysis.ts
+++ b/src/domain/javascript/javascriptStaticAnalysis.ts
@@ -25,6 +25,7 @@ import {
inspectRouteProperty,
inspectRoleProperty,
inspectRpcNode,
+ finishRpcScanSteps,
indexVitePreloadDependencyTable,
} from "./javascriptStaticAnalysisCalls.js";
import {
@@ -81,8 +82,9 @@ export function* analyzeParsedJavaScriptStaticSourceSteps(
): Generator<void, JavaScriptStaticAnalysis> {
const accumulator = createJavaScriptAnalysisAccumulator(source.length);
// One definitions pass serves receiver classification and binding lookup.
- const { bindings, receivers } =
- yield* indexJavaScriptBindingsWithReceiversSteps(file.program);
+ const index = yield* indexJavaScriptBindingsWithReceiversSteps(file.program);
+ const { bindings, receivers } = index;
+ yield* index.indexAmbientWritesSteps();
const electronIdentity = yield* indexJavaScriptElectronIdentitySteps(
file.program,
bindings,
@@ -95,7 +97,7 @@ export function* analyzeParsedJavaScriptStaticSourceSteps(
vitePreloadDependencyTable: indexVitePreloadDependencyTable(file.program),
openReceiverFacts: receivers.openReceivers,
electronBindings: electronIdentity.bindings,
- rpcScan: createJavaScriptRpcScan(source, receivers.rpcClientRoots),
+ rpcScan: createJavaScriptRpcScan(source, receivers.rpcClientRoots, index),
},
bindings,
);
@@ -122,6 +124,7 @@ function* traverseStaticSourceSteps(
return undefined;
},
});
+ yield* finishRpcScanSteps(findings);
}
const finalizeStaticAnalysis = (
diff --git a/src/domain/javascript/javascriptStaticAnalysisCalls.ts b/src/domain/javascript/javascriptStaticAnalysisCalls.ts
index 16a123b8b..008da7dd4 100644
--- a/src/domain/javascript/javascriptStaticAnalysisCalls.ts
+++ b/src/domain/javascript/javascriptStaticAnalysisCalls.ts
@@ -454,6 +454,16 @@ export const inspectRpcNode = (node: t.Node, context: FindingContext): void => {
addEndpoint(context, { node, kind: "network", ...rpc });
};
+/** Resolve deferred Source bodies after their document owners have been seen. */
+export function* finishRpcScanSteps(
+ context: FindingContext,
+): Generator<void, void> {
+ for (const rpc of context.rpcScan.finish()) {
+ if (rpc !== undefined) addEndpoint(context, { kind: "network", ...rpc });
+ yield;
+ }
+}
+
export const inspectRouteProperty = (
node: t.ObjectProperty,
context: FindingContext,
diff --git a/src/domain/webBundleAnalyzer.test.ts b/src/domain/webBundleAnalyzer.test.ts
index ed0a151eb..cc137be20 100644
--- a/src/domain/webBundleAnalyzer.test.ts
+++ b/src/domain/webBundleAnalyzer.test.ts
@@ -8,6 +8,20 @@ import { createWebTextArtifact } from "./webContentArtifact.js";
const origin = "https://app.example.test";
+it("retains standalone GraphQL Source operations in captured scripts", () => {
+ const result = analyzeCapturedWebBundle(
+ inspection(`
+ const source = {
+ body: "query GetUser { user { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ `),
+ );
+ expect(result.observations.endpoints).toEqual([
+ expect.objectContaining({ value: "GetUser", mechanism: "graphql:query" }),
+ ]);
+});
+
it.each([
{
kind: "recovered",
diff --git a/src/domain/webBundleAnalyzerInspection.ts b/src/domain/webBundleAnalyzerInspection.ts
index 93a4f9c70..9fd759997 100644
--- a/src/domain/webBundleAnalyzerInspection.ts
+++ b/src/domain/webBundleAnalyzerInspection.ts
@@ -5,7 +5,8 @@ import { compositeKey } from "./unicodeCodePointOrder.js";
import type { WebPageInspection } from "./browserObservationSchemas.js";
import type { WebBundleAnalysis } from "./webBundleAnalysis.js";
import { traverseJavaScriptAst } from "./javascript/javascriptSemanticTraversal.js";
-import { classifyParsedJavaScriptReceivers } from "./javascript/javascriptSemanticAnalysis.js";
+import { indexJavaScriptBindingsWithReceiversSteps } from "./javascript/javascriptSemanticAnalysis.js";
+import { completeSemanticSteps } from "./javascript/javascriptSemanticTraversal.js";
import type { JavaScriptOpenReceiverFact } from "./javascript/javascriptSemanticAnalysis.js";
import { semanticStaticPropertyName } from "./javascript/javascriptAstValues.js";
import {
@@ -61,11 +62,15 @@ export const analyzeScript = (
if ((file.errors?.length ?? 0) > 0)
accumulator.recoveredScripts.push(script.script_key);
detectVendorFingerprints(script, accumulator);
- const receivers = classifyParsedJavaScriptReceivers(file);
+ const index = completeSemanticSteps(
+ indexJavaScriptBindingsWithReceiversSteps(file.program),
+ );
+ const { receivers } = index;
const openReceiverFacts = receivers.openReceivers;
const rpc = createJavaScriptRpcScan(
script.source.artifact.text,
receivers.rpcClientRoots,
+ index,
);
traverseJavaScriptAst(file, {
enter: (node) => {
@@ -83,6 +88,16 @@ export const analyzeScript = (
});
},
});
+ for (const endpoint of rpc.finish())
+ if (endpoint !== undefined)
+ addFinding({
+ collection: accumulator.endpoints,
+ script,
+ rawValue: endpoint.value,
+ mechanism: endpoint.mechanism,
+ node: endpoint.node,
+ accumulator,
+ });
};
const inspectNode = (
diff --git a/tests/acceptance/applications/javascriptRpcPropertyOwnershipCli.test.ts b/tests/acceptance/applications/javascriptRpcPropertyOwnershipCli.test.ts
index a369e7519..205a05a28 100644
--- a/tests/acceptance/applications/javascriptRpcPropertyOwnershipCli.test.ts
+++ b/tests/acceptance/applications/javascriptRpcPropertyOwnershipCli.test.ts
@@ -8,6 +8,104 @@ import {
} from "../../support/cli/javascriptApplication.js";
import { writeFixtureFiles } from "../../support/javascriptApplicationFixture.js";
+cliTest.for(["CLI", "stdio MCP"] as const)(
+ "retains standalone GraphQL sources and only suppresses owned copies through %s",
+ async (surface, { cli }) => {
+ const root = await createTestTempDirectory("rea-graphql-source-");
+ await writeFixtureFiles(root, {
+ "classic.js": `
+ const document = {
+ kind: "OperationDefinition", operation: "query",
+ name: { kind: "Name", value: "ClassicSource" },
+ loc: { source: {
+ body: "query ClassicSource { viewer { id } }",
+ locationOffset: { line: 1, column: 1 },
+ } },
+ };
+ `,
+ "entry.mjs": `
+ const source = {
+ body: "query Standalone { viewer { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ const compiledSource = {
+ body: "query Compiled { viewer { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ const document = { kind: "Document", definitions: [{
+ kind: "OperationDefinition", operation: "query",
+ name: { kind: "Name", value: "Compiled" },
+ }], loc: { source: compiledSource } };
+ const independentSource = {
+ body: "query Independent { viewer { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ const unrelated = {
+ kind: "OperationDefinition", operation: "query",
+ name: { kind: "Name", value: "Independent" },
+ };
+ const changedSource = {
+ body: "query ChangedSource { viewer { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ const location = { source: changedSource };
+ location.source = {};
+ const changedDocument = {
+ kind: "OperationDefinition", operation: "query",
+ name: { kind: "Name", value: "ChangedSource" }, loc: location,
+ };
+ const exposedSource = {
+ body: "query ExposedSource { viewer { id } }",
+ locationOffset: { line: 1, column: 1 },
+ };
+ const exposedDocument = {
+ kind: "OperationDefinition", operation: "query",
+ name: { kind: "Name", value: "ExposedSource" },
+ loc: { source: exposedSource },
+ };
+ exposedDocument.loc.source = {};
+ `,
+ });
+ const result = await analyzeJavaScriptDirectory(surface, cli, root);
+ const operations = result.graph.nodes
+ .filter((node) => node.kind === "endpoint")
+ .flatMap((node) => node.observations)
+ .filter(({ properties }) => properties.mechanism === "graphql:query");
+ expect(operations.map(({ properties }) => properties.value).sort()).toEqual(
+ [
+ "ChangedSource",
+ "ChangedSource",
+ "ClassicSource",
+ "ClassicSource",
+ "Compiled",
+ "ExposedSource",
+ "ExposedSource",
+ "Independent",
+ "Independent",
+ "Standalone",
+ ],
+ );
+ for (const observation of operations)
+ expect(observation.evidence).toMatchObject({
+ authority: "ast-static-analysis",
+ state: "observed",
+ artifact: { available: true },
+ location: {
+ available: true,
+ value: {
+ kind: "source-range",
+ source:
+ observation.properties.value === "ClassicSource"
+ ? "classic.js"
+ : "entry.mjs",
+ },
+ },
+ });
+ expect(result.statistics.parse_failures).toBe(0);
+ expect(result.graph.coverage.status).toBe("complete");
+ },
+);
+
cliTest.for(["CLI", "stdio MCP"] as const)(
"retains only final known RPC object properties through %s",
async (surface, { cli }) => {