@tanstack/start-plugin-core 1.142.11 → 1.142.13

package/dist/esm/create-server-fn-plugin/compiler.d.ts

@@ -22,6 +22,13 @@ type ExportEntry = {
 };
 type Kind = 'None' | `Root` | `Builder` | LookupKind;
 export type LookupKind = 'ServerFn' | 'Middleware' | 'IsomorphicFn' | 'ServerOnlyFn' | 'ClientOnlyFn';
+export declare const KindDetectionPatterns: Record<LookupKind, RegExp>;
+export declare const LookupKindsPerEnv: Record<'client' | 'server', Set<LookupKind>>;
+/**
+ * Detects which LookupKinds are present in the code using string matching.
+ * This is a fast pre-scan before AST parsing to limit the work done during compilation.
+ */
+export declare function detectKindsInCode(code: string, env: 'client' | 'server'): Set<LookupKind>;
 export type LookupConfig = {
     libName: string;
     rootExport: string;
@@ -38,8 +45,8 @@ export declare class ServerFnCompiler {
     private moduleCache;
     private initialized;
     private validLookupKinds;
-    private hasDirectCallKinds;
-    private hasRootAsCandidateKinds;
+    private resolveIdCache;
+    private exportResolutionCache;
     private knownRootImports;
     constructor(options: {
         env: 'client' | 'server';
@@ -48,8 +55,21 @@ export declare class ServerFnCompiler {
         lookupKinds: Set<LookupKind>;
         loadModule: (id: string) => Promise<void>;
         resolveId: (id: string, importer?: string) => Promise<string | null>;
+        /**
+         * In 'build' mode, resolution results are cached for performance.
+         * In 'dev' mode (default), caching is disabled to avoid invalidation complexity with HMR.
+         */
+        mode?: 'dev' | 'build';
     });
+    private get mode();
+    private resolveIdCached;
+    private getExportResolutionCache;
     private init;
+    /**
+     * Extracts bindings and exports from an already-parsed AST.
+     * This is the core logic shared by ingestModule and ingestModuleFromAst.
+     */
+    private extractModuleInfo;
     ingestModule({ code, id }: {
         code: string;
         id: string;
@@ -58,12 +78,13 @@ export declare class ServerFnCompiler {
         ast: import('@tanstack/router-utils').ParseAstResult;
     };
     invalidateModule(id: string): boolean;
-    compile({ code, id, isProviderFile, }: {
+    compile({ code, id, isProviderFile, detectedKinds, }: {
         code: string;
         id: string;
         isProviderFile: boolean;
+        /** Pre-detected kinds present in this file. If not provided, all valid kinds are checked. */
+        detectedKinds?: Set<LookupKind>;
     }): Promise<import('@tanstack/router-utils').GeneratorResult | null>;
-    private collectCandidates;
     private resolveIdentifierKind;
     /**
      * Recursively find an export in a module, following `export * from` chains.

package/dist/esm/create-server-fn-plugin/compiler.js

@@ -24,6 +24,38 @@ const LookupSetup = {
   ServerOnlyFn: { type: "directCall" },
   ClientOnlyFn: { type: "directCall" }
 };
+const KindDetectionPatterns = {
+  ServerFn: /\.handler\s*\(/,
+  Middleware: /createMiddleware/,
+  IsomorphicFn: /createIsomorphicFn/,
+  ServerOnlyFn: /createServerOnlyFn/,
+  ClientOnlyFn: /createClientOnlyFn/
+};
+const LookupKindsPerEnv = {
+  client: /* @__PURE__ */ new Set([
+    "Middleware",
+    "ServerFn",
+    "IsomorphicFn",
+    "ServerOnlyFn",
+    "ClientOnlyFn"
+  ]),
+  server: /* @__PURE__ */ new Set([
+    "ServerFn",
+    "IsomorphicFn",
+    "ServerOnlyFn",
+    "ClientOnlyFn"
+  ])
+};
+function detectKindsInCode(code, env) {
+  const detected = /* @__PURE__ */ new Set();
+  const validForEnv = LookupKindsPerEnv[env];
+  for (const [kind, pattern] of Object.entries(KindDetectionPatterns)) {
+    if (validForEnv.has(kind) && pattern.test(code)) {
+      detected.add(kind);
+    }
+  }
+  return detected;
+}
 const IdentifierToKinds = /* @__PURE__ */ new Map();
 for (const [kind, setup] of Object.entries(LookupSetup)) {
   if (setup.type === "methodChain") {
@@ -37,31 +69,86 @@ for (const [kind, setup] of Object.entries(LookupSetup)) {
     }
   }
 }
+const DirectCallFactoryNames = /* @__PURE__ */ new Set([
+  "createServerOnlyFn",
+  "createClientOnlyFn",
+  "createIsomorphicFn"
+]);
+function needsDirectCallDetection(kinds) {
+  for (const kind of kinds) {
+    const setup = LookupSetup[kind];
+    if (setup.type === "directCall" || setup.allowRootAsCandidate) {
+      return true;
+    }
+  }
+  return false;
+}
+function areAllKindsTopLevelOnly(kinds) {
+  return kinds.size === 1 && kinds.has("ServerFn");
+}
+function isNestedDirectCallCandidate(node) {
+  let calleeName;
+  if (t.isIdentifier(node.callee)) {
+    calleeName = node.callee.name;
+  } else if (t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.property)) {
+    calleeName = node.callee.property.name;
+  }
+  return calleeName !== void 0 && DirectCallFactoryNames.has(calleeName);
+}
+function isTopLevelDirectCallCandidate(path) {
+  const node = path.node;
+  const isSimpleCall = t.isIdentifier(node.callee) || t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.object) && t.isIdentifier(node.callee.property);
+  if (!isSimpleCall) {
+    return false;
+  }
+  const parent = path.parent;
+  if (!t.isVariableDeclarator(parent) || parent.init !== node) {
+    return false;
+  }
+  const grandParent = path.parentPath.parent;
+  if (!t.isVariableDeclaration(grandParent)) {
+    return false;
+  }
+  return t.isProgram(path.parentPath.parentPath?.parent);
+}
 class ServerFnCompiler {
   constructor(options) {
     this.options = options;
     this.validLookupKinds = options.lookupKinds;
-    this.hasDirectCallKinds = false;
-    this.hasRootAsCandidateKinds = false;
-    for (const kind of options.lookupKinds) {
-      const setup = LookupSetup[kind];
-      if (setup.type === "directCall") {
-        this.hasDirectCallKinds = true;
-      } else if (setup.allowRootAsCandidate) {
-        this.hasRootAsCandidateKinds = true;
-      }
-    }
   }
   moduleCache = /* @__PURE__ */ new Map();
   initialized = false;
   validLookupKinds;
-  // Precomputed flags for candidate detection (avoid recomputing on each collectCandidates call)
-  hasDirectCallKinds;
-  hasRootAsCandidateKinds;
+  resolveIdCache = /* @__PURE__ */ new Map();
+  exportResolutionCache = /* @__PURE__ */ new Map();
   // Fast lookup for direct imports from known libraries (e.g., '@tanstack/react-start')
   // Maps: libName → (exportName → Kind)
   // This allows O(1) resolution for the common case without async resolveId calls
   knownRootImports = /* @__PURE__ */ new Map();
+  get mode() {
+    return this.options.mode ?? "dev";
+  }
+  async resolveIdCached(id, importer) {
+    if (this.mode === "dev") {
+      return this.options.resolveId(id, importer);
+    }
+    const cacheKey = importer ? `${importer}::${id}` : id;
+    const cached = this.resolveIdCache.get(cacheKey);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const resolved = await this.options.resolveId(id, importer);
+    this.resolveIdCache.set(cacheKey, resolved);
+    return resolved;
+  }
+  getExportResolutionCache(moduleId) {
+    let cache = this.exportResolutionCache.get(moduleId);
+    if (!cache) {
+      cache = /* @__PURE__ */ new Map();
+      this.exportResolutionCache.set(moduleId, cache);
+    }
+    return cache;
+  }
   async init() {
     this.knownRootImports.set(
       "@tanstack/start-fn-stubs",
@@ -79,7 +166,7 @@ class ServerFnCompiler {
           this.knownRootImports.set(config.libName, libExports);
         }
         libExports.set(config.rootExport, config.kind);
-        const libId = await this.options.resolveId(config.libName);
+        const libId = await this.resolveIdCached(config.libName);
         if (!libId) {
           throw new Error(`could not resolve "${config.libName}"`);
         }
@@ -113,8 +200,11 @@ class ServerFnCompiler {
     );
     this.initialized = true;
   }
-  ingestModule({ code, id }) {
-    const ast = parseAst({ code });
+  /**
+   * Extracts bindings and exports from an already-parsed AST.
+   * This is the core logic shared by ingestModule and ingestModuleFromAst.
+   */
+  extractModuleInfo(ast, id) {
     const bindings = /* @__PURE__ */ new Map();
     const exports = /* @__PURE__ */ new Map();
     const reExportAllSources = [];
@@ -199,6 +289,11 @@ class ServerFnCompiler {
       reExportAllSources
     };
     this.moduleCache.set(id, info);
+    return info;
+  }
+  ingestModule({ code, id }) {
+    const ast = parseAst({ code });
+    const info = this.extractModuleInfo(ast, id);
     return { info, ast };
   }
   invalidateModule(id) {
@@ -207,43 +302,111 @@ class ServerFnCompiler {
   async compile({
     code,
     id,
-    isProviderFile
+    isProviderFile,
+    detectedKinds
   }) {
     if (!this.initialized) {
       await this.init();
     }
-    const { info, ast } = this.ingestModule({ code, id });
-    const candidates = this.collectCandidates(info.bindings);
-    if (candidates.length === 0) {
+    const fileKinds = detectedKinds ? new Set([...detectedKinds].filter((k) => this.validLookupKinds.has(k))) : this.validLookupKinds;
+    if (fileKinds.size === 0) {
+      return null;
+    }
+    const checkDirectCalls = needsDirectCallDetection(fileKinds);
+    const canUseFastPath = areAllKindsTopLevelOnly(fileKinds);
+    const { ast } = this.ingestModule({ code, id });
+    const candidatePaths = [];
+    const chainCallPaths = /* @__PURE__ */ new Map();
+    if (canUseFastPath) {
+      const candidateIndices = [];
+      for (let i = 0; i < ast.program.body.length; i++) {
+        const node = ast.program.body[i];
+        let declarations;
+        if (t.isVariableDeclaration(node)) {
+          declarations = node.declarations;
+        } else if (t.isExportNamedDeclaration(node) && node.declaration) {
+          if (t.isVariableDeclaration(node.declaration)) {
+            declarations = node.declaration.declarations;
+          }
+        }
+        if (declarations) {
+          for (const decl of declarations) {
+            if (decl.init && t.isCallExpression(decl.init)) {
+              if (isMethodChainCandidate(decl.init, fileKinds)) {
+                candidateIndices.push(i);
+                break;
+              }
+            }
+          }
+        }
+      }
+      if (candidateIndices.length === 0) {
+        return null;
+      }
+      babel.traverse(ast, {
+        Program(programPath) {
+          const bodyPaths = programPath.get("body");
+          for (const idx of candidateIndices) {
+            const stmtPath = bodyPaths[idx];
+            if (!stmtPath) continue;
+            stmtPath.traverse({
+              CallExpression(path) {
+                const node = path.node;
+                const parent = path.parent;
+                if (t.isMemberExpression(parent) && t.isCallExpression(path.parentPath.parent)) {
+                  chainCallPaths.set(node, path);
+                  return;
+                }
+                if (isMethodChainCandidate(node, fileKinds)) {
+                  candidatePaths.push(path);
+                }
+              }
+            });
+          }
+          programPath.stop();
+        }
+      });
+    } else {
+      babel.traverse(ast, {
+        CallExpression: (path) => {
+          const node = path.node;
+          const parent = path.parent;
+          if (t.isMemberExpression(parent) && t.isCallExpression(path.parentPath.parent)) {
+            chainCallPaths.set(node, path);
+            return;
+          }
+          if (isMethodChainCandidate(node, fileKinds)) {
+            candidatePaths.push(path);
+            return;
+          }
+          if (checkDirectCalls) {
+            if (isTopLevelDirectCallCandidate(path)) {
+              candidatePaths.push(path);
+            } else if (isNestedDirectCallCandidate(node)) {
+              candidatePaths.push(path);
+            }
+          }
+        }
+      });
+    }
+    if (candidatePaths.length === 0) {
       return null;
     }
     const resolvedCandidates = await Promise.all(
-      candidates.map(async (candidate) => ({
-        candidate,
-        kind: await this.resolveExprKind(candidate, id)
+      candidatePaths.map(async (path) => ({
+        path,
+        kind: await this.resolveExprKind(path.node, id)
       }))
     );
-    const toRewriteMap = /* @__PURE__ */ new Map();
-    for (const { candidate, kind } of resolvedCandidates) {
-      if (this.validLookupKinds.has(kind)) {
-        toRewriteMap.set(candidate, kind);
-      }
-    }
-    if (toRewriteMap.size === 0) {
+    const validCandidates = resolvedCandidates.filter(
+      ({ kind }) => this.validLookupKinds.has(kind)
+    );
+    if (validCandidates.length === 0) {
       return null;
     }
     const pathsToRewrite = [];
-    const callExprPaths = /* @__PURE__ */ new Map();
-    babel.traverse(ast, {
-      CallExpression(path) {
-        callExprPaths.set(path.node, path);
-      }
-    });
-    for (const [node, kind] of toRewriteMap) {
-      const path = callExprPaths.get(node);
-      if (!path) {
-        continue;
-      }
+    for (const { path, kind } of validCandidates) {
+      const node = path.node;
       const methodChain = {
         middleware: null,
         inputValidator: null,
@@ -252,6 +415,7 @@ class ServerFnCompiler {
         client: null
       };
       let currentNode = node;
+      let currentPath = path;
       while (true) {
         const callee = currentNode.callee;
         if (!t.isMemberExpression(callee)) {
@@ -260,7 +424,6 @@ class ServerFnCompiler {
         if (t.isIdentifier(callee.property)) {
           const name = callee.property.name;
           if (name in methodChain) {
-            const currentPath = callExprPaths.get(currentNode);
             const args = currentPath.get("arguments");
             const firstArgPath = Array.isArray(args) && args.length > 0 ? args[0] ?? null : null;
             methodChain[name] = {
@@ -273,14 +436,14 @@ class ServerFnCompiler {
           break;
         }
         currentNode = callee.object;
+        const nextPath = chainCallPaths.get(currentNode);
+        if (!nextPath) {
+          break;
+        }
+        currentPath = nextPath;
       }
       pathsToRewrite.push({ path, kind, methodChain });
     }
-    if (pathsToRewrite.length !== toRewriteMap.size) {
-      throw new Error(
-        `Internal error: could not find all paths to rewrite. please file an issue`
-      );
-    }
     const refIdents = findReferencedIdentifiers(ast);
     for (const { path, kind, methodChain } of pathsToRewrite) {
       const candidate = { path, methodChain };
@@ -313,28 +476,6 @@ class ServerFnCompiler {
       filename: id
     });
   }
-  // collects all candidate CallExpressions at top-level
-  collectCandidates(bindings) {
-    const candidates = [];
-    for (const binding of bindings.values()) {
-      if (binding.type === "var" && t.isCallExpression(binding.init)) {
-        const methodChainCandidate = isCandidateCallExpression(
-          binding.init,
-          this.validLookupKinds
-        );
-        if (methodChainCandidate) {
-          candidates.push(methodChainCandidate);
-          continue;
-        }
-        if (this.hasDirectCallKinds || this.hasRootAsCandidateKinds) {
-          if (t.isIdentifier(binding.init.callee) || t.isMemberExpression(binding.init.callee) && t.isIdentifier(binding.init.callee.property)) {
-            candidates.push(binding.init);
-          }
-        }
-      }
-    }
-    return candidates;
-  }
   async resolveIdentifierKind(ident, id, visited = /* @__PURE__ */ new Set()) {
     const info = await this.getModuleInfo(id);
     const binding = info.bindings.get(ident);
@@ -358,6 +499,16 @@ class ServerFnCompiler {
    * Returns the module info and binding if found, or undefined if not found.
    */
   async findExportInModule(moduleInfo, exportName, visitedModules = /* @__PURE__ */ new Set()) {
+    const isBuildMode = this.mode === "build";
+    if (isBuildMode && visitedModules.size === 0) {
+      const moduleCache = this.exportResolutionCache.get(moduleInfo.id);
+      if (moduleCache) {
+        const cached = moduleCache.get(exportName);
+        if (cached !== void 0) {
+          return cached ?? void 0;
+        }
+      }
+    }
     if (visitedModules.has(moduleInfo.id)) {
       return void 0;
     }
@@ -366,13 +517,17 @@ class ServerFnCompiler {
     if (directExport) {
       const binding = moduleInfo.bindings.get(directExport.name);
       if (binding) {
-        return { moduleInfo, binding };
+        const result = { moduleInfo, binding };
+        if (isBuildMode) {
+          this.getExportResolutionCache(moduleInfo.id).set(exportName, result);
+        }
+        return result;
       }
     }
     if (moduleInfo.reExportAllSources.length > 0) {
       const results = await Promise.all(
         moduleInfo.reExportAllSources.map(async (reExportSource) => {
-          const reExportTarget = await this.options.resolveId(
+          const reExportTarget = await this.resolveIdCached(
             reExportSource,
             moduleInfo.id
           );
@@ -389,10 +544,16 @@ class ServerFnCompiler {
       );
       for (const result of results) {
         if (result) {
+          if (isBuildMode) {
+            this.getExportResolutionCache(moduleInfo.id).set(exportName, result);
+          }
           return result;
         }
       }
     }
+    if (isBuildMode) {
+      this.getExportResolutionCache(moduleInfo.id).set(exportName, null);
+    }
     return void 0;
   }
   async resolveBindingKind(binding, fileId, visited = /* @__PURE__ */ new Set()) {
@@ -408,7 +569,7 @@ class ServerFnCompiler {
           return kind;
         }
       }
-      const target = await this.options.resolveId(binding.source, fileId);
+      const target = await this.resolveIdCached(binding.source, fileId);
       if (!target) {
         return "None";
       }
@@ -501,7 +662,7 @@ class ServerFnCompiler {
         const info = await this.getModuleInfo(fileId);
         const binding = info.bindings.get(callee.object.name);
         if (binding && binding.type === "import" && binding.importedName === "*") {
-          const targetModuleId = await this.options.resolveId(
+          const targetModuleId = await this.resolveIdCached(
             binding.source,
             fileId
           );
@@ -542,23 +703,25 @@ class ServerFnCompiler {
     return cached;
   }
 }
-function isCandidateCallExpression(node, lookupKinds) {
-  if (!t.isCallExpression(node)) return void 0;
+function isMethodChainCandidate(node, lookupKinds) {
   const callee = node.callee;
   if (!t.isMemberExpression(callee) || !t.isIdentifier(callee.property)) {
-    return void 0;
+    return false;
   }
   const possibleKinds = IdentifierToKinds.get(callee.property.name);
   if (possibleKinds) {
     for (const kind of possibleKinds) {
       if (lookupKinds.has(kind)) {
-        return node;
+        return true;
       }
     }
   }
-  return void 0;
+  return false;
 }
 export {
-  ServerFnCompiler
+  KindDetectionPatterns,
+  LookupKindsPerEnv,
+  ServerFnCompiler,
+  detectKindsInCode
 };
 //# sourceMappingURL=compiler.js.map