veryfront 0.1.156 → 0.1.159

package/src/src/proxy/handler.ts

@@ -392,36 +392,19 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
     return `https://veryfront.com/sign-in?from=${encodeURIComponent(returnPath)}`;
   }
 
-  function makePreviewProjectNotFoundContext(
-    base: {
-      scope: TokenScope;
-      host: string;
-      parsedDomain: ParsedDomain;
-    },
-    token?: string,
-  ): ProxyContext {
-    return makeErrorContext(
-      base,
-      404,
-      "Preview project not found",
-      token,
-      undefined,
-      "project-not-found",
-    );
-  }
-
   function makeProjectNotFoundContext(
     base: {
       scope: TokenScope;
       host: string;
       parsedDomain: ParsedDomain;
     },
+    message: "Preview project not found" | "Project not found",
     token?: string,
   ): ProxyContext {
     return makeErrorContext(
       base,
       404,
-      "Project not found",
+      message,
       token,
       undefined,
       "project-not-found",
@@ -630,11 +613,11 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
         if (status === 404) {
           if (scope === "preview") {
             logger?.info("Preview project not found", { projectSlug, host });
-            return makePreviewProjectNotFoundContext(base);
+            return makeProjectNotFoundContext(base, "Preview project not found");
           }
 
           logger?.info("Project not found", { projectSlug, host, scope });
-          return makeProjectNotFoundContext(base);
+          return makeProjectNotFoundContext(base, "Project not found");
         }
 
         const message = scope === "preview"
@@ -727,7 +710,7 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
             scope,
             targetEnvName: parsedDomain.environment,
           });
-          return makeProjectNotFoundContext(base, token);
+          return makeProjectNotFoundContext(base, "Project not found", token);
         }
 
         projectId = resolved.projectId;
@@ -765,7 +748,7 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
 
         if (!resolved.projectId) {
           logger?.info("Preview project not found after lookup", { projectSlug, host });
-          return makePreviewProjectNotFoundContext(base, token);
+          return makeProjectNotFoundContext(base, "Preview project not found", token);
         }
 
         projectId = resolved.projectId;

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.156";
+export const VERSION = "0.1.159";