@beignet/cli 0.0.52 → 0.0.53

package/src/analysis/workspace-routes.ts

@@ -0,0 +1,385 @@
+import ts from "typescript";
+import { createSourceIndex, type SourceIndex } from "./source-index.js";
+import type { AnalysisWorkspace } from "./workspace.js";
+
+type LocalDeclarations = Map<string, ts.Declaration>;
+type ServerCall = {
+  file: string;
+  call: ts.CallExpression;
+  locals: LocalDeclarations;
+};
+
+/** Follow declarative route composition without executing application modules. */
+export async function workspaceRouteContracts(
+  workspace: AnalysisWorkspace,
+): Promise<{
+  contracts: Set<string>;
+  groups: Set<string>;
+  unresolved: boolean;
+}> {
+  const sourceIndex = createSourceIndex(workspace);
+  const contracts = new Set<string>();
+  const groups = new Set<string>();
+  const visited = new Set<ts.Node>();
+  const active = new Set<ts.Node>();
+  let unresolved = false;
+
+  async function follow(
+    file: string,
+    expression: ts.Expression,
+    locals: LocalDeclarations = new Map(),
+  ): Promise<void> {
+    if (
+      ts.isAsExpression(expression) ||
+      ts.isSatisfiesExpression(expression) ||
+      ts.isParenthesizedExpression(expression)
+    ) {
+      return follow(file, expression.expression, locals);
+    }
+    if (
+      ts.isIdentifier(expression) ||
+      ts.isPropertyAccessExpression(expression)
+    ) {
+      const local = ts.isIdentifier(expression)
+        ? locals.get(expression.text)
+        : undefined;
+      const reference = local
+        ? { file, declaration: local }
+        : ts.isIdentifier(expression)
+          ? await sourceIndex.resolveName(file, expression.text)
+          : await sourceIndex.resolveExpression(file, expression);
+      if (
+        !reference?.declaration ||
+        !ts.isVariableDeclaration(reference.declaration) ||
+        !reference.declaration.initializer
+      ) {
+        unresolved = true;
+        return;
+      }
+      const key = reference.declaration;
+      if (active.has(key)) {
+        unresolved = true;
+        return;
+      }
+      if (visited.has(key)) return;
+      visited.add(key);
+      active.add(key);
+      await follow(
+        reference.file,
+        reference.declaration.initializer,
+        local ? locals : new Map(),
+      );
+      active.delete(key);
+      return;
+    }
+    if (ts.isArrayLiteralExpression(expression)) {
+      for (const item of expression.elements) {
+        if (ts.isSpreadElement(item))
+          await follow(file, item.expression, locals);
+        else if (ts.isExpression(item)) await follow(file, item, locals);
+        else unresolved = true;
+      }
+      return;
+    }
+    if (ts.isCallExpression(expression)) {
+      const name = ts.isIdentifier(expression.expression)
+        ? expression.expression.text
+        : undefined;
+      if (
+        (name === "defineRoutes" ||
+          name === "defineRouteGroup" ||
+          name === "defineRoute") &&
+        expression.arguments[0]
+      ) {
+        if (name === "defineRouteGroup") {
+          let parent = expression.parent;
+          while (
+            ts.isAsExpression(parent) ||
+            ts.isSatisfiesExpression(parent) ||
+            ts.isParenthesizedExpression(parent)
+          )
+            parent = parent.parent;
+          if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name))
+            groups.add(`${file}#${parent.name.text}`);
+        }
+        return follow(file, expression.arguments[0], locals);
+      }
+      unresolved = true;
+      return;
+    }
+    if (ts.isObjectLiteralExpression(expression)) {
+      if (!explicitObject(expression)) {
+        unresolved = true;
+        return;
+      }
+      let recognized = false;
+      for (const member of expression.properties) {
+        if (ts.isSpreadAssignment(member)) {
+          unresolved = true;
+          continue;
+        }
+        if (
+          !ts.isPropertyAssignment(member) &&
+          !ts.isShorthandPropertyAssignment(member)
+        )
+          continue;
+        const name =
+          ts.isIdentifier(member.name) || ts.isStringLiteralLike(member.name)
+            ? member.name.text
+            : undefined;
+        const value = ts.isPropertyAssignment(member)
+          ? member.initializer
+          : member.name;
+        if (name === "routes") {
+          recognized = true;
+          await follow(file, value, locals);
+        }
+        if (name === "contract") {
+          recognized = true;
+          const reference = await sourceIndex.resolveValue(file, value, locals);
+          if (reference)
+            contracts.add(`${reference.file}#${reference.exportName}`);
+          else unresolved = true;
+        }
+      }
+      if (!recognized) unresolved = true;
+      return;
+    }
+    unresolved = true;
+  }
+
+  const serverFile = workspace.config.paths.server;
+  if (!workspace.fileSet.has(serverFile))
+    return { contracts, groups, unresolved: true };
+  const selected = await selectedServerCall(workspace, sourceIndex);
+  if (!selected) return { contracts, groups, unresolved: true };
+  const { file, call, locals } = selected;
+  const options = call.arguments[0];
+  if (
+    !options ||
+    !ts.isObjectLiteralExpression(options) ||
+    !explicitObject(options)
+  ) {
+    return { contracts, groups, unresolved: true };
+  }
+  const routes = options.properties.find(
+    (member) =>
+      member.name &&
+      (ts.isIdentifier(member.name) || ts.isStringLiteralLike(member.name)) &&
+      member.name.text === "routes",
+  );
+  if (
+    routes &&
+    (ts.isPropertyAssignment(routes) ||
+      ts.isShorthandPropertyAssignment(routes))
+  ) {
+    await follow(
+      file,
+      ts.isPropertyAssignment(routes) ? routes.initializer : routes.name,
+      locals,
+    );
+  }
+  return { contracts, groups, unresolved };
+}
+
+/** Trace only the exported server or the value returned by its lazy loader. */
+async function selectedServerCall(
+  workspace: AnalysisWorkspace,
+  sourceIndex: SourceIndex,
+): Promise<ServerCall | undefined> {
+  const file = workspace.config.paths.server;
+  const roots = (
+    await Promise.all(
+      ["server", "getServer"].map((name) =>
+        sourceIndex.resolveExport(file, name),
+      ),
+    )
+  ).filter((reference) => reference !== undefined);
+  if (roots.length !== 1) return undefined;
+  const root = roots[0];
+  if (
+    !root.declaration ||
+    !ts.isVariableDeclaration(root.declaration) ||
+    !root.declaration.initializer ||
+    !ts.isVariableDeclarationList(root.declaration.parent) ||
+    !(root.declaration.parent.flags & ts.NodeFlags.Const)
+  )
+    return undefined;
+  const visited = new Set<ts.Node>();
+  return follow(root.file, root.declaration.initializer, new Map());
+
+  async function follow(
+    file: string,
+    expression: ts.Expression,
+    locals: LocalDeclarations,
+  ): Promise<ServerCall | undefined> {
+    if (visited.has(expression)) return undefined;
+    visited.add(expression);
+    if (
+      ts.isAsExpression(expression) ||
+      ts.isSatisfiesExpression(expression) ||
+      ts.isParenthesizedExpression(expression) ||
+      ts.isAwaitExpression(expression)
+    )
+      return follow(file, expression.expression, locals);
+    if (ts.isIdentifier(expression)) {
+      const local = locals.get(expression.text);
+      const reference = local
+        ? { file, declaration: local }
+        : await sourceIndex.resolveName(file, expression.text);
+      const declaration = reference?.declaration;
+      if (
+        !reference ||
+        !declaration ||
+        !ts.isVariableDeclaration(declaration) ||
+        !declaration.initializer ||
+        !ts.isVariableDeclarationList(declaration.parent) ||
+        !(declaration.parent.flags & ts.NodeFlags.Const)
+      )
+        return undefined;
+      return follow(
+        reference.file,
+        declaration.initializer,
+        local ? locals : new Map(),
+      );
+    }
+    // The canonical loader wraps stop() while preserving the server API.
+    if (ts.isObjectLiteralExpression(expression)) {
+      const [spread, ...overrides] = expression.properties;
+      if (
+        !spread ||
+        !ts.isSpreadAssignment(spread) ||
+        overrides.some(
+          (property) =>
+            !property.name ||
+            !ts.isIdentifier(property.name) ||
+            property.name.text !== "stop",
+        )
+      )
+        return undefined;
+      return follow(file, spread.expression, locals);
+    }
+    if (!ts.isCallExpression(expression)) return undefined;
+    const factory = importedFactory(
+      await workspace.readSourceFile(file),
+      expression.expression,
+      locals,
+    );
+    if (
+      factory ===
+      (workspace.config.framework === "next"
+        ? "createNextServer"
+        : "createFetchServer")
+    )
+      return { file, call: expression, locals };
+    if (
+      factory !== "createNextServerLoader" ||
+      workspace.config.framework !== "next"
+    )
+      return undefined;
+    const callback = expression.arguments[0];
+    if (
+      !callback ||
+      (!ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback)) ||
+      callback.parameters.length
+    )
+      return undefined;
+    if (!ts.isBlock(callback.body)) return follow(file, callback.body, locals);
+    const scoped = new Map(locals);
+    let returned: ts.Expression | undefined;
+    for (const statement of callback.body.statements) {
+      if (returned) return undefined;
+      if (ts.isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations)
+          addLocal(scoped, declaration.name, declaration);
+      } else if (ts.isFunctionDeclaration(statement) && statement.name) {
+        scoped.set(statement.name.text, statement);
+      } else if (ts.isReturnStatement(statement)) {
+        if (!statement.expression) return undefined;
+        returned = statement.expression;
+      } else if (
+        !ts.isExpressionStatement(statement) &&
+        !ts.isFunctionDeclaration(statement) &&
+        !ts.isEmptyStatement(statement)
+      )
+        return undefined;
+    }
+    return returned ? follow(file, returned, scoped) : undefined;
+  }
+}
+
+function importedFactory(
+  source: ts.SourceFile,
+  expression: ts.Expression,
+  locals: LocalDeclarations,
+): string | undefined {
+  const receiver = ts.isIdentifier(expression)
+    ? expression
+    : ts.isPropertyAccessExpression(expression) &&
+        ts.isIdentifier(expression.expression)
+      ? expression.expression
+      : undefined;
+  if (!receiver || locals.has(receiver.text)) return undefined;
+  for (const statement of source.statements) {
+    if (
+      !ts.isImportDeclaration(statement) ||
+      !ts.isStringLiteral(statement.moduleSpecifier) ||
+      statement.importClause?.isTypeOnly
+    )
+      continue;
+    const bindings = statement.importClause?.namedBindings;
+    const name =
+      bindings && ts.isNamedImports(bindings) && ts.isIdentifier(expression)
+        ? bindings.elements.find(
+            (element) =>
+              element.name.text === receiver.text && !element.isTypeOnly,
+          )
+        : undefined;
+    const imported = name
+      ? (name.propertyName ?? name.name).text
+      : bindings &&
+          ts.isNamespaceImport(bindings) &&
+          bindings.name.text === receiver.text &&
+          ts.isPropertyAccessExpression(expression)
+        ? expression.name.text
+        : undefined;
+    if (
+      statement.moduleSpecifier.text === "@beignet/next" &&
+      (imported === "createNextServer" || imported === "createNextServerLoader")
+    )
+      return imported;
+    if (
+      statement.moduleSpecifier.text === "@beignet/web" &&
+      imported === "createFetchServer"
+    )
+      return imported;
+  }
+  return undefined;
+}
+
+function addLocal(
+  locals: LocalDeclarations,
+  name: ts.BindingName,
+  declaration: ts.Declaration,
+): void {
+  if (ts.isIdentifier(name)) locals.set(name.text, declaration);
+  else
+    for (const element of name.elements)
+      if (ts.isBindingElement(element)) addLocal(locals, element.name, element);
+}
+
+function explicitObject(object: ts.ObjectLiteralExpression): boolean {
+  const names = new Set<string>();
+  for (const property of object.properties) {
+    if (
+      ts.isSpreadAssignment(property) ||
+      !property.name ||
+      (!ts.isIdentifier(property.name) &&
+        !ts.isStringLiteralLike(property.name))
+    )
+      return false;
+    if (names.has(property.name.text)) return false;
+    names.add(property.name.text);
+  }
+  return true;
+}