veryfront 0.1.157 → 0.1.161

package/src/src/platform/adapters/fs/veryfront/stat-operations.ts

@@ -329,6 +329,7 @@ export class StatOperations extends VeryfrontOperationsBase {
   private buildResolveSearchPatterns(
     normalizedPath: string,
     options?: ResolveFileOptions,
+    knownExtensionFallback: "exact" | "wildcard" = "exact",
   ): string[] {
     const patterns = new Set<string>();
     const pathWithoutExt = stripKnownExtension(normalizedPath, EXTENSION_PRIORITY);
@@ -338,7 +339,9 @@ export class StatOperations extends VeryfrontOperationsBase {
     };
 
     if (EXTENSION_PRIORITY.some((ext) => normalizedPath.endsWith(ext))) {
-      addPattern(normalizedPath);
+      addPattern(
+        knownExtensionFallback === "wildcard" ? `${pathWithoutExt}.*` : normalizedPath,
+      );
       return [...patterns];
     }
 
@@ -366,6 +369,7 @@ export class StatOperations extends VeryfrontOperationsBase {
   private async tryResolveViaApiSearch(
     normalizedPath: string,
     options?: ResolveFileOptions,
+    knownExtensionFallback: "exact" | "wildcard" = "exact",
   ): Promise<string | null | undefined> {
     if (isFrameworkSourcePath(normalizedPath)) {
       logger.debug("Skipping API search for framework path", { normalizedPath });
@@ -377,7 +381,11 @@ export class StatOperations extends VeryfrontOperationsBase {
       return undefined;
     }
 
-    const patterns = this.buildResolveSearchPatterns(normalizedPath, options);
+    const patterns = this.buildResolveSearchPatterns(
+      normalizedPath,
+      options,
+      knownExtensionFallback,
+    );
     let sawSuccessfulSearch = false;
 
     for (const pattern of patterns) {
@@ -573,55 +581,17 @@ export class StatOperations extends VeryfrontOperationsBase {
       return null;
     }
 
-    // NOTE: Removed optimization that skipped API search for paths with extensions.
-    // This was causing layout files and other project files to not be found when
-    // they were missing from the file index (due to cache issues, incomplete fetch, etc.).
-    // The API pattern search is the fallback to ensure files can still be found.
-
-    if (!this.apiSearchCircuitBreaker.canSearch()) {
-      logger.warn("API search circuit breaker open, skipping", { normalizedPath });
-      return null;
+    // NOTE: Keep the post-index API fallback aligned with the pre-index helper for extensionless
+    // paths, while preserving the older wildcard sibling-extension lookup for known-extension
+    // paths. Incomplete file-list snapshots otherwise hide valid files until the cache refreshes.
+    const apiResolved = await this.tryResolveViaApiSearch(normalizedPath, options, "wildcard");
+    if (typeof apiResolved === "string") {
+      this.cache.set(cacheKey, apiResolved);
+      return apiResolved;
     }
-
-    const searchPattern = `${pathWithoutExt}.*`;
-    logger.debug("Searching for file via API", {
-      pattern: searchPattern,
-      normalizedPath,
-    });
-
-    try {
-      const matches = await this.client.searchFiles(searchPattern);
-      this.apiSearchCircuitBreaker.recordSuccess();
-
-      logger.debug("API search result", {
-        pattern: searchPattern,
-        matchCount: matches.length,
-        matches: matches.map((m) => m.path).slice(0, 5),
-      });
-
-      const sortedMatches = sortPathsByExtensionPriority(matches, EXTENSION_PRIORITY);
-      const first = sortedMatches[0];
-      if (first) {
-        logger.debug("resolveFile found via API search", { path: first.path });
-        this.cache.set(cacheKey, first.path);
-        return first.path;
-      }
-    } catch (error) {
-      const result = this.apiSearchCircuitBreaker.recordFailure();
-      if (result.tripped) {
-        logger.warn("API search circuit breaker tripped", {
-          failures: result.failures,
-        });
-      }
-      logger.error("API pattern search failed", { pattern: searchPattern, error });
+    if (apiResolved === null) {
+      this.cache.set(cacheKey, NOT_FOUND_SENTINEL);
     }
-
-    logger.debug("resolveFile not found after API search", {
-      normalizedPath,
-      pathWithoutExt,
-    });
-
-    this.cache.set(cacheKey, NOT_FOUND_SENTINEL);
     return null;
   }
 }

package/src/src/routing/api/module-loader/loader.ts

@@ -661,129 +661,156 @@ async function loadModuleFromCode(
   }
 }
 
-async function rewriteExternalImports(
-  code: string,
+export function getNodeExternalPackagesToResolve(userDeps: Map<string, string>): string[] {
+  const externalPackagesToResolve = ["zod"];
+
+  for (const name of userDeps.keys()) {
+    if (!externalPackagesToResolve.includes(name)) {
+      externalPackagesToResolve.push(name);
+    }
+  }
+
+  return externalPackagesToResolve;
+}
+
+export async function resolveNodePackageToFileUrl(
   projectDir: string,
+  packageName: string,
   fs: FileSystem,
-  userDeps: Map<string, string> = new Map(),
-): Promise<string> {
-  let transformed = code;
-
-  if (isNode) {
-    try {
-      const { pathToFileURL } = await import("node:url");
+  pathToFileURL: typeof import("node:url").pathToFileURL,
+): Promise<string | null> {
+  const packagePath = pathHelper.join(projectDir, "node_modules", packageName);
+  const packageJsonPath = pathHelper.join(packagePath, "package.json");
 
-      logger.debug(`Rewriting external imports for Node.js, projectDir: ${projectDir}`);
+  try {
+    const pkgJson = JSON.parse(await fs.readTextFile(packageJsonPath));
+    let entryPoint: string | undefined;
 
-      const resolvePackageToFileUrl = async (packageName: string): Promise<string | null> => {
-        const packagePath = pathHelper.join(projectDir, "node_modules", packageName);
-        const packageJsonPath = pathHelper.join(packagePath, "package.json");
+    if (pkgJson.exports) {
+      entryPoint = resolveExportEntry(pkgJson.exports["."]);
+    }
 
-        try {
-          const pkgJson = JSON.parse(await fs.readTextFile(packageJsonPath));
-          let entryPoint: string | undefined;
+    entryPoint ||= pkgJson.module || pkgJson.main || "index.js";
+    if (!entryPoint) return null;
 
-          if (pkgJson.exports) {
-            entryPoint = resolveExportEntry(pkgJson.exports["."]);
-          }
+    return pathToFileURL(pathHelper.join(packagePath, entryPoint)).href;
+  } catch (_) {
+    /* expected: package.json may not exist or be invalid */
+    return null;
+  }
+}
 
-          entryPoint ||= pkgJson.module || pkgJson.main || "index.js";
-          if (!entryPoint) return null;
+export async function loadVeryfrontExportsMap(
+  projectDir: string,
+  fs: FileSystem,
+): Promise<Record<string, { import?: string }>> {
+  const vfPackagePath = pathHelper.join(projectDir, "node_modules", "veryfront");
+  const vfPackageJsonPath = pathHelper.join(vfPackagePath, "package.json");
 
-          return pathToFileURL(pathHelper.join(packagePath, entryPoint)).href;
-        } catch (_) {
-          /* expected: package.json may not exist or be invalid */
-          return null;
-        }
-      };
+  try {
+    const pkgJson = JSON.parse(await fs.readTextFile(vfPackageJsonPath));
+    return pkgJson.exports || {};
+  } catch (_error) {
+    logger.debug("Could not read veryfront package.json");
+    return {};
+  }
+}
 
-      const externalPackagesToResolve = ["zod"];
+export async function rewriteNodeExternalImports(
+  code: string,
+  projectDir: string,
+  fs: FileSystem,
+  userDeps: Map<string, string>,
+): Promise<string> {
+  const { pathToFileURL } = await import("node:url");
+  let transformed = code;
 
-      for (const name of userDeps.keys()) {
-        if (!externalPackagesToResolve.includes(name)) {
-          externalPackagesToResolve.push(name);
-        }
-      }
+  logger.debug(`Rewriting external imports for Node.js, projectDir: ${projectDir}`);
 
-      for (const pkg of externalPackagesToResolve) {
-        const escapedPkg = pkg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  for (const pkg of getNodeExternalPackagesToResolve(userDeps)) {
+    const escapedPkg = pkg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
-        // Match both exact imports (from "pkg") and subpath imports (from "pkg/sub")
-        const staticImportRegex = new RegExp(`from\\s*["']${escapedPkg}(/[^"']*)?["']`, "g");
-        const dynamicImportRegex = new RegExp(
-          `import\\s*\\(\\s*["']${escapedPkg}(/[^"']*)?["']\\s*\\)`,
-          "g",
-        );
+    const staticImportRegex = new RegExp(`from\\s*["']${escapedPkg}(/[^"']*)?["']`, "g");
+    const dynamicImportRegex = new RegExp(
+      `import\\s*\\(\\s*["']${escapedPkg}(/[^"']*)?["']\\s*\\)`,
+      "g",
+    );
 
-        const needsStatic = staticImportRegex.test(transformed);
-        staticImportRegex.lastIndex = 0;
-        const needsDynamic = dynamicImportRegex.test(transformed);
-        dynamicImportRegex.lastIndex = 0;
-        if (!needsStatic && !needsDynamic) continue;
-
-        const packageDir = pathToFileURL(pathHelper.join(projectDir, "node_modules", pkg)).href;
-        const resolvedUrl = await resolvePackageToFileUrl(pkg);
-
-        if (needsStatic) {
-          transformed = transformed.replace(staticImportRegex, (_, subpath) => {
-            if (subpath) {
-              const subUrl = `${packageDir}${subpath}`;
-              logger.debug(`Resolved ${pkg}${subpath} -> ${subUrl}`);
-              return `from "${subUrl}"`;
-            }
-            if (!resolvedUrl) return `from "${pkg}"`;
-            logger.debug(`Resolved ${pkg} -> ${resolvedUrl}`);
-            return `from "${resolvedUrl}"`;
-          });
+    const needsStatic = staticImportRegex.test(transformed);
+    staticImportRegex.lastIndex = 0;
+    const needsDynamic = dynamicImportRegex.test(transformed);
+    dynamicImportRegex.lastIndex = 0;
+    if (!needsStatic && !needsDynamic) continue;
+
+    const packageDir = pathToFileURL(pathHelper.join(projectDir, "node_modules", pkg)).href;
+    const resolvedUrl = await resolveNodePackageToFileUrl(projectDir, pkg, fs, pathToFileURL);
+
+    if (needsStatic) {
+      transformed = transformed.replace(staticImportRegex, (_, subpath) => {
+        if (subpath) {
+          const subUrl = `${packageDir}${subpath}`;
+          logger.debug(`Resolved ${pkg}${subpath} -> ${subUrl}`);
+          return `from "${subUrl}"`;
         }
+        if (!resolvedUrl) return `from "${pkg}"`;
+        logger.debug(`Resolved ${pkg} -> ${resolvedUrl}`);
+        return `from "${resolvedUrl}"`;
+      });
+    }
 
-        if (needsDynamic) {
-          transformed = transformed.replace(dynamicImportRegex, (_, subpath) => {
-            if (subpath) {
-              const subUrl = `${packageDir}${subpath}`;
-              return `import("${subUrl}")`;
-            }
-            if (!resolvedUrl) return `import("${pkg}")`;
-            return `import("${resolvedUrl}")`;
-          });
+    if (needsDynamic) {
+      transformed = transformed.replace(dynamicImportRegex, (_, subpath) => {
+        if (subpath) {
+          return `import("${packageDir}${subpath}")`;
         }
+        if (!resolvedUrl) return `import("${pkg}")`;
+        return `import("${resolvedUrl}")`;
+      });
+    }
+  }
+
+  const vfPackagePath = pathHelper.join(projectDir, "node_modules", "veryfront");
+  const exportsMap = await loadVeryfrontExportsMap(projectDir, fs);
+
+  transformed = transformed.replace(
+    /from\s+["'](veryfront\/[^"']+)["']/g,
+    (match, fullSpecifier: string) => {
+      const subpath = "./" + fullSpecifier.replace("veryfront/", "");
+      const exportEntry = exportsMap[subpath];
+      if (!exportEntry?.import) {
+        logger.warn(`No export found for ${subpath}`);
+        return match;
       }
 
-      const vfPackagePath = pathHelper.join(projectDir, "node_modules", "veryfront");
-      const vfPackageJsonPath = pathHelper.join(vfPackagePath, "package.json");
+      const resolvedPath = pathHelper.join(vfPackagePath, exportEntry.import);
+      logger.debug(`Resolved ${fullSpecifier} -> ${resolvedPath}`);
+      return `from "${pathToFileURL(resolvedPath).href}"`;
+    },
+  );
 
-      let exportsMap: Record<string, { import?: string }> = {};
-      try {
-        const pkgJson = JSON.parse(await fs.readTextFile(vfPackageJsonPath));
-        exportsMap = pkgJson.exports || {};
-      } catch (_error) {
-        logger.debug(`Could not read veryfront package.json: `);
-      }
+  transformed = transformed.replace(/from\s+["']veryfront["']/g, () => {
+    const exportEntry = exportsMap["."];
+    if (!exportEntry?.import) return 'from "veryfront"';
 
-      transformed = transformed.replace(
-        /from\s+["'](veryfront\/[^"']+)["']/g,
-        (match, fullSpecifier: string) => {
-          const subpath = "./" + fullSpecifier.replace("veryfront/", "");
-          const exportEntry = exportsMap[subpath];
-          if (!exportEntry?.import) {
-            logger.warn(`No export found for ${subpath}`);
-            return match;
-          }
+    const resolvedPath = pathHelper.join(vfPackagePath, exportEntry.import);
+    logger.debug(`Resolved veryfront -> ${resolvedPath}`);
+    return `from "${pathToFileURL(resolvedPath).href}"`;
+  });
 
-          const resolvedPath = pathHelper.join(vfPackagePath, exportEntry.import);
-          logger.debug(`Resolved ${fullSpecifier} -> ${resolvedPath}`);
-          return `from "${pathToFileURL(resolvedPath).href}"`;
-        },
-      );
+  return transformed;
+}
 
-      transformed = transformed.replace(/from\s+["']veryfront["']/g, () => {
-        const exportEntry = exportsMap["."];
-        if (!exportEntry?.import) return 'from "veryfront"';
+async function rewriteExternalImports(
+  code: string,
+  projectDir: string,
+  fs: FileSystem,
+  userDeps: Map<string, string> = new Map(),
+): Promise<string> {
+  let transformed = code;
 
-        const resolvedPath = pathHelper.join(vfPackagePath, exportEntry.import);
-        logger.debug(`Resolved veryfront -> ${resolvedPath}`);
-        return `from "${pathToFileURL(resolvedPath).href}"`;
-      });
+  if (isNode) {
+    try {
+      transformed = await rewriteNodeExternalImports(transformed, projectDir, fs, userDeps);
     } catch (e) {
       logger.warn(`Failed to import node:module: ${e}`);
     }

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.157";
+export const VERSION = "0.1.161";