@tinkerlandai/indiana-iam 0.2.0 → 0.4.0

package/src/source-query-evidence.mjs

@@ -0,0 +1,64 @@
+/** Trace returned TanStack query values through local source wrappers, without running a query or module. */
+export function sourceQueryEvidence({
+  ts,
+  node,
+  module,
+  locals,
+  binding,
+  functionFrom,
+  imported,
+}) {
+  let steps = 0;
+  const seen = new Set();
+  function visit(n, m, env, depth = 0) {
+    if (!n || depth > 20 || ++steps > 1800) return false;
+    while (
+      ts.isParenthesizedExpression(n) ||
+      ts.isAsExpression(n) ||
+      ts.isNonNullExpression(n)
+    )
+      n = n.expression;
+    const key = m.file + ":" + n.pos + ":" + n.end;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    if (ts.isIdentifier(n)) {
+      if (env?.has(n.text)) return visit(env.get(n.text), m, env, depth + 1);
+      const ref = binding(m, n.text);
+      return Boolean(ref && visit(ref.node, ref.module, null, depth + 1));
+    }
+    if (ts.isCallExpression(n)) {
+      const primitive = imported(m, n.expression.getText(m.source));
+      if (
+        primitive?.specifier === "@tanstack/react-query" &&
+        ["useQuery", "useInfiniteQuery"].includes(primitive.name)
+      )
+        return true;
+      if (ts.isIdentifier(n.expression)) {
+        const ref = binding(m, n.expression.text),
+          fn = ref && functionFrom(ref.node);
+        if (fn) {
+          const next = new Map();
+          if (ts.isBlock(fn.body))
+            for (const s of fn.body.statements)
+              if (ts.isVariableStatement(s))
+                for (const d of s.declarationList.declarations)
+                  if (ts.isIdentifier(d.name))
+                    next.set(d.name.text, d.initializer);
+          const returns = ts.isBlock(fn.body)
+            ? fn.body.statements
+                .filter((s) => ts.isReturnStatement(s))
+                .map((s) => s.expression)
+            : [fn.body];
+          if (returns.some((r) => visit(r, ref.module, next, depth + 1)))
+            return true;
+        }
+      }
+    }
+    let found = false;
+    ts.forEachChild(n, (c) => {
+      if (!found) found = visit(c, m, env, depth + 1);
+    });
+    return found;
+  }
+  return visit(node, module, locals);
+}

package/src/source-redirects.mjs

@@ -0,0 +1,388 @@
+import { uiRelation } from "./ui-structure.mjs";
+
+/** Bounded source dataflow: current location -> query parameter -> Navigate query consumer.
+ * This records conditional UI relations only. It never runs guards, helpers or authentication. */
+export function sourceRedirects({
+  ts,
+  modules,
+  binding,
+  functionFrom,
+  externalImport,
+  sourceLocation,
+  constant,
+  pages,
+  components,
+  documents,
+}) {
+  const router = (ref) =>
+    ["react-router", "react-router-dom"].includes(ref?.specifier);
+  const unknown = Symbol("unresolved redirect");
+  const unwrap = (n) => {
+    while (
+      n &&
+      (ts.isParenthesizedExpression(n) ||
+        ts.isAsExpression(n) ||
+        ts.isNonNullExpression(n) ||
+        ts.isTypeAssertionExpression(n))
+    )
+      n = n.expression;
+    return n;
+  };
+  const score = (v) =>
+    v?.kind === "url"
+      ? 5
+      : v?.kind === "query"
+        ? 4
+        : v?.kind === "origin"
+          ? 3
+          : typeof v === "string"
+            ? 1
+            : 0;
+  const choose = (values) =>
+    values
+      .filter((v) => v !== unknown && v !== undefined && v !== null)
+      .sort((a, b) => score(b) - score(a))[0] ?? unknown;
+  const definitions = new Map();
+  let budget = 0;
+  function value(raw, module, env, refs, depth = 0) {
+    const node = unwrap(raw);
+    if (!node || depth > 16 || ++budget > 20000) return unknown;
+    const next = (n) => value(n, module, env, refs, depth + 1);
+    if (ts.isIdentifier(node)) {
+      if (env.has(node.text)) return env.get(node.text);
+      const c = constant(node, module);
+      return c === undefined ? unknown : c;
+    }
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+      return node.text;
+    if (ts.isPropertyAccessExpression(node)) {
+      const parent = next(node.expression),
+        key = node.name.text;
+      if (
+        parent?.kind === "location" &&
+        ["pathname", "search", "hash"].includes(key)
+      )
+        return { kind: "origin", pathname: key === "pathname" };
+      if (parent && typeof parent === "object" && Object.hasOwn(parent, key))
+        return parent[key];
+      const c = constant(node, module);
+      return c === undefined ? unknown : c;
+    }
+    if (ts.isObjectLiteralExpression(node))
+      return Object.fromEntries(
+        node.properties.flatMap((p) =>
+          ts.isShorthandPropertyAssignment(p)
+            ? [[p.name.text, next(p.name)]]
+            : ts.isPropertyAssignment(p)
+              ? [[p.name.text, next(p.initializer)]]
+              : [],
+        ),
+      );
+    if (ts.isConditionalExpression(node))
+      return choose([next(node.whenTrue), next(node.whenFalse)]);
+    if (
+      ts.isBinaryExpression(node) &&
+      [ts.SyntaxKind.BarBarToken, ts.SyntaxKind.QuestionQuestionToken].includes(
+        node.operatorToken.kind,
+      )
+    )
+      return choose([next(node.left), next(node.right)]);
+    if (
+      ts.isNewExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === "URLSearchParams" &&
+      !node.arguments?.length
+    )
+      return { kind: "params", entries: new Map() };
+    if (ts.isTemplateExpression(node)) {
+      const parts = [node.head.text];
+      for (const span of node.templateSpans)
+        parts.push(next(span.expression), span.literal.text);
+      const dynamic = parts.filter((p) => typeof p !== "string");
+      if (
+        dynamic.length &&
+        dynamic.every((p) => p?.kind === "origin") &&
+        dynamic.some((p) => p.pathname) &&
+        parts.filter((p) => typeof p === "string").every((p) => p === "")
+      )
+        return { kind: "origin", pathname: true };
+      if (dynamic.length === 1 && dynamic[0]?.kind === "querystring") {
+        const index = parts.indexOf(dynamic[0]),
+          prefix = parts.slice(0, index).join(""),
+          suffix = parts.slice(index + 1).join("");
+        if (prefix.endsWith("?") && suffix === "")
+          return {
+            kind: "url",
+            path: prefix.slice(0, -1),
+            entries: dynamic[0].entries,
+          };
+      }
+      return dynamic.length ? unknown : parts.join("");
+    }
+    if (ts.isCallExpression(node)) {
+      if (ts.isIdentifier(node.expression)) {
+        const primitive = externalImport(module, node.expression.text);
+        if (router(primitive) && primitive.name === "useLocation")
+          return { kind: "location" };
+        if (router(primitive) && primitive.name === "useSearchParams")
+          return { kind: "search-hook" };
+        const ref = binding(module, node.expression.text),
+          fn = ref && functionFrom(ref.node);
+        if (
+          fn &&
+          !fn.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) &&
+          fn.parameters.every((p) => ts.isIdentifier(p.name))
+        ) {
+          refs.set(
+            ref.module.file + "#" + ref.name,
+            sourceLocation(ref.module, fn, ref.name),
+          );
+          const local = new Map(
+            fn.parameters.map((p, i) => [p.name.text, next(node.arguments[i])]),
+          );
+          const returns = [];
+          scanBody(fn.body, ref.module, local, refs, returns, null, depth + 1);
+          return choose(returns);
+        }
+      }
+      if (ts.isPropertyAccessExpression(node.expression)) {
+        const parent = next(node.expression.expression),
+          method = node.expression.name.text;
+        if (
+          parent?.kind === "search" &&
+          method === "get" &&
+          node.arguments.length === 1
+        ) {
+          const key = next(node.arguments[0]);
+          return typeof key === "string"
+            ? { kind: "query", parameter: key }
+            : unknown;
+        }
+        if (
+          parent?.kind === "params" &&
+          method === "set" &&
+          node.arguments.length === 2
+        ) {
+          const key = next(node.arguments[0]),
+            v = next(node.arguments[1]);
+          if (typeof key === "string" && v !== unknown)
+            parent.entries.set(key, v);
+          return undefined;
+        }
+        if (parent?.kind === "params" && method === "toString")
+          return { kind: "querystring", entries: parent.entries };
+      }
+    }
+    const c = constant(node, module);
+    return c === undefined ? unknown : c;
+  }
+  function scanBody(
+    node,
+    module,
+    env,
+    refs,
+    returns,
+    onNavigate,
+    depth = 0,
+    condition = null,
+  ) {
+    if (!node || depth > 24) return;
+    if (ts.isBlock(node) || ts.isSourceFile(node))
+      for (const statement of node.statements)
+        scanBody(
+          statement,
+          module,
+          env,
+          refs,
+          returns,
+          onNavigate,
+          depth + 1,
+          condition,
+        );
+    else if (ts.isVariableStatement(node))
+      for (const decl of node.declarationList.declarations) {
+        const v = value(decl.initializer, module, env, refs, depth);
+        if (ts.isIdentifier(decl.name)) env.set(decl.name.text, v);
+        else if (ts.isObjectBindingPattern(decl.name)) {
+          for (const field of decl.name.elements)
+            if (ts.isIdentifier(field.name)) {
+              const key = field.propertyName?.text || field.name.text;
+              env.set(
+                field.name.text,
+                v?.kind === "location" &&
+                  ["pathname", "search", "hash"].includes(key)
+                  ? { kind: "origin", pathname: key === "pathname" }
+                  : v && typeof v === "object"
+                    ? (v[key] ?? unknown)
+                    : unknown,
+              );
+            }
+        } else if (
+          ts.isArrayBindingPattern(decl.name) &&
+          v?.kind === "search-hook"
+        ) {
+          const name = decl.name.elements[0]?.name;
+          if (name && ts.isIdentifier(name))
+            env.set(name.text, { kind: "search" });
+        }
+      }
+    else if (ts.isIfStatement(node)) {
+      const label = node.expression.getText(module.source).slice(0, 160),
+        combine = (text) =>
+          condition ? condition + " && (" + text + ")" : text;
+      scanBody(
+        node.thenStatement,
+        module,
+        new Map(env),
+        refs,
+        returns,
+        onNavigate,
+        depth + 1,
+        combine(label),
+      );
+      if (node.elseStatement)
+        scanBody(
+          node.elseStatement,
+          module,
+          new Map(env),
+          refs,
+          returns,
+          onNavigate,
+          depth + 1,
+          combine("!(" + label + ")"),
+        );
+    } else if (ts.isExpressionStatement(node))
+      value(node.expression, module, env, refs, depth);
+    else if (ts.isReturnStatement(node)) {
+      if (onNavigate)
+        scanJsx(
+          node.expression,
+          module,
+          env,
+          refs,
+          onNavigate,
+          depth,
+          condition,
+        );
+      else returns.push(value(node.expression, module, env, refs, depth));
+    } else if (!ts.isFunctionLike(node) && onNavigate)
+      scanJsx(node, module, env, refs, onNavigate, depth, condition);
+  }
+  function scanJsx(node, module, env, refs, emit, depth, condition) {
+    if (!node || depth > 32) return;
+    if (ts.isConditionalExpression(node)) {
+      const label = node.condition.getText(module.source).slice(0, 160);
+      scanJsx(node.whenTrue, module, env, refs, emit, depth + 1, label);
+      scanJsx(
+        node.whenFalse,
+        module,
+        env,
+        refs,
+        emit,
+        depth + 1,
+        "!(" + label + ")",
+      );
+      return;
+    }
+    if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+      const opening = ts.isJsxElement(node) ? node.openingElement : node,
+        primitive = externalImport(
+          module,
+          opening.tagName.getText(module.source),
+        );
+      if (router(primitive) && primitive.name === "Navigate") {
+        const to = opening.attributes.properties.find(
+          (p) => ts.isJsxAttribute(p) && p.name.text === "to",
+        );
+        const proof = new Map(refs),
+          target = value(
+            ts.isJsxExpression(to?.initializer)
+              ? to.initializer.expression
+              : to?.initializer,
+            module,
+            env,
+            proof,
+          );
+        emit({
+          target,
+          condition,
+          source: sourceLocation(module, node, "$source-navigation"),
+          refs: [...proof.values()],
+        });
+        return;
+      }
+    }
+    if (ts.isFunctionLike(node)) return;
+    ts.forEachChild(node, (child) =>
+      scanJsx(child, module, env, refs, emit, depth + 1, condition),
+    );
+  }
+  for (const component of components) {
+    const module = modules.get(component.file),
+      ref = module && binding(module, component.name),
+      fn = ref && functionFrom(ref.node);
+    if (!fn?.body) continue;
+    budget = 0;
+    const rows = [];
+    scanBody(fn.body, module, new Map(), new Map(), [], (row) =>
+      rows.push(row),
+    );
+    definitions.set(component.componentKey, rows);
+  }
+  const byRoute = new Map(
+    pages.map((p) => [
+      p.pageKey,
+      p.componentKeys.flatMap((key) => definitions.get(key) ?? []),
+    ]),
+  );
+  const result = [];
+  for (const page of pages)
+    for (const row of byRoute.get(page.pageKey)) {
+      const target = row.target;
+      if (target?.kind !== "url" || !target.path.startsWith("/")) continue;
+      const destination = pages.find((p) => p.route === target.path);
+      if (!destination) continue;
+      for (const [parameter, origin] of target.entries) {
+        if (origin?.kind !== "origin" || !origin.pathname) continue;
+        const consumers = byRoute
+          .get(destination.pageKey)
+          .filter(
+            (r) =>
+              r.target?.kind === "query" && r.target.parameter === parameter,
+          );
+        if (!consumers.length) continue;
+        const hasPassword = documents
+          .filter((d) => d.pageKey === destination.pageKey)
+          .some((d) =>
+            d.nodes.some(
+              (n) => n.tag === "input" && n.attributes.type === "password",
+            ),
+          );
+        const sourceRefs = [row.source, ...row.refs].slice(0, 16);
+        result.push(
+          uiRelation({
+            routeKey: page.pageKey,
+            targetRouteKey: destination.pageKey,
+            kind: hasPassword ? "login" : "redirect",
+            returnParameter: parameter,
+            condition: row.condition,
+            activation: "route-condition",
+            sourceRefs,
+          }),
+        );
+        for (const consumer of consumers)
+          result.push(
+            uiRelation({
+              routeKey: destination.pageKey,
+              targetRouteKey: page.pageKey,
+              kind: "return",
+              returnParameter: parameter,
+              condition: consumer.condition,
+              activation: "route-condition",
+              sourceRefs: [consumer.source, ...consumer.refs].slice(0, 16),
+            }),
+          );
+      }
+    }
+  return [...new Map(result.map((r) => [r.relationKey, r])).values()];
+}