@marko/run 0.4.5 → 0.4.6

package/dist/vite/index.cjs

@@ -930,45 +930,6 @@ function writeRouteEntryHandler(writer, route, verb) {
   continuations.join();
   writer.writeBlockEnd("}");
 }
-function renderErrorRouter(error, options = {
-  trailingSlashes: "RedirectWithout"
-}) {
-  const writer = createStringWriter();
-  writer.write(`
-// @marko/run/router
-import { createContext } from '${virtualFilePrefix}/runtime/internal';
-import errorPage from '${virtualFilePrefix}/${markoRunFilePrefix}error.marko${serverEntryQuery}';
-
-const error = new Error(\`${error.message}\`);
-error.name = '${error.name}';`);
-  if (error.stack) {
-    writer.write(`
-error.stack = \`${error.stack}\`;`);
-  }
-  writer.write(`
-
-globalThis.__marko_run__ = { match, fetch, invoke };
-
-export function match() {
-  return { handler: errorPage, params: {}, meta: {}, path: '/*' }; // /$$
-}
-
-export async function invoke(route, request, platform, url) {
-  const [context, buildInput] = createContext(route, request, platform, url);
-  if (context.request.headers.get('Accept')?.includes('text/html')) {
-    return new Response(errorPage.stream(buildInput({ error })), {
-      status: 500,
-      headers: { "content-type": "text/html;charset=UTF-8" },
-    });
-  }
-  return new Response(error, {
-    status: 500,
-  });
-}
-`);
-  renderFetch(writer, options);
-  return writer.end();
-}
 function renderRouter(routes, options = {
   trailingSlashes: "RedirectWithout"
 }) {
@@ -1101,15 +1062,7 @@ export async function fetch(request, platform) {
     return await invoke(route, request, platform, url);
   } catch (error) {
     if (import.meta.env.DEV) {
-      let body;
-      if (error.cause) {
-        body = error.cause.stack || error.cause.message || error.cause;
-      } else {
-        body = error.stack || error.message || "Internal Server Error";
-      }
-      return new Response(body, {
-        status: 500
-      });
+      throw error;
     }
     return new Response(null, {
       status: 500
@@ -1549,6 +1502,29 @@ function getExportIdentifiers(astProgramNode) {
   }
   return result;
 }
+function getViteSSRExportIdentifiers(astProgramNode, exportObjectName = "__vite_ssr_exports__") {
+  const result = [];
+  if (t.isProgram(astProgramNode)) {
+    for (const node of astProgramNode.body) {
+      if (t.isExpressionStatement(node)) {
+        if (t.isAssignmentExpression(node.expression) && t.isMemberExpression(node.expression.left)) {
+          const { object, property } = node.expression.left;
+          if (t.isIdentifier(object) && object.name === exportObjectName && t.isIdentifier(property)) {
+            result.push(property.name);
+          }
+        } else if (t.isCallExpression(node.expression) && t.isMemberExpression(node.expression.callee)) {
+          const {
+            arguments: [arg0, arg1]
+          } = node.expression;
+          if (t.isIdentifier(arg0) && arg0.name === exportObjectName && (t.isStringLiteral(arg1) || "value" in arg1 && typeof arg1.value === "string")) {
+            result.push(arg1.value);
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
 
 // src/vite/utils/log.ts
 var import_node_zlib = __toESM(require("node:zlib"), 1);
@@ -1741,6 +1717,31 @@ process.once("beforeExit", (code) => {
   }
 });
 
+// src/adapter/utils.ts
+var import_supports_color = __toESM(require("supports-color"), 1);
+var import_kleur2 = __toESM(require("kleur"), 1);
+function stripAnsi(string) {
+  return string.replace(
+    /([\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><])/g,
+    ""
+  );
+}
+function cleanStack(stack) {
+  return stack.split(/\n/).filter((l) => /^\s*at/.test(l)).join("\n");
+}
+function prepareError(err) {
+  var _a;
+  return {
+    message: stripAnsi(err.message),
+    stack: stripAnsi(cleanStack(err.stack || "")),
+    id: err.id,
+    frame: stripAnsi(err.frame || ""),
+    plugin: err.plugin,
+    pluginCode: (_a = err.pluginCode) == null ? void 0 : _a.toString(),
+    loc: err.loc
+  };
+}
+
 // src/vite/plugin.ts
 var debug = (0, import_debug.default)("@marko/run");
 var __dirname = import_path3.default.dirname((0, import_url2.fileURLToPath)(__importMetaURL));
@@ -1764,11 +1765,10 @@ function markoRun(opts = {}) {
   let devServer;
   let routes;
   let routeData;
-  let extractVerbs;
+  let getExportsFromFile;
   let resolvedConfig;
   let typesFile;
-  let isStale = true;
-  let isRendered = false;
+  let seenErrors = /* @__PURE__ */ new Set();
   const virtualFiles = /* @__PURE__ */ new Map();
   let times = {
     routesBuild: 0,
@@ -1791,97 +1791,134 @@ function markoRun(opts = {}) {
       }
     }
   }
-  const buildVirtualFiles = single(async (render) => {
-    var _a;
-    const routerOptions = {
-      trailingSlashes: opts.trailingSlashes || "RedirectWithout"
-    };
-    try {
-      if (isStale) {
+  let buildVirtualFilesResult;
+  function buildVirtualFiles() {
+    return buildVirtualFilesResult ?? (buildVirtualFilesResult = new Promise(async (resolve, reject) => {
+      try {
         virtualFiles.clear();
-        isRendered = false;
-        const buildStartTime = performance.now();
         routes = await buildRoutes({
           walker: createFSWalker(resolvedRoutesDir),
           importPrefix: routesDir
         });
-        times.routesBuild = performance.now() - buildStartTime;
         if (!routes.list.length) {
           throw new Error("No routes generated");
         }
-      }
-      const renderStartTime = performance.now();
-      for (const route of routes.list) {
-        if (render && route.handler) {
-          route.handler.verbs = await extractVerbs(route.handler.filePath);
-          if (!route.handler.verbs.length) {
-            throw new Error(
-              `Did not find any valid exports in middleware entry file:'${route.handler.filePath}' - expected to find any of 'GET', 'POST', 'PUT' or 'DELETE'`
+        for (const route of routes.list) {
+          if (route.page) {
+            virtualFiles.set(
+              import_path3.default.posix.join(root, `${route.entryName}.marko`),
+              ""
             );
           }
+          virtualFiles.set(import_path3.default.posix.join(root, `${route.entryName}.js`), "");
         }
-        if (route.page) {
+        for (const route of Object.values(routes.special)) {
           virtualFiles.set(
             import_path3.default.posix.join(root, `${route.entryName}.marko`),
-            render ? renderRouteTemplate(route) : ""
+            ""
           );
         }
-        virtualFiles.set(
-          import_path3.default.posix.join(root, `${route.entryName}.js`),
-          render ? renderRouteEntry(route) : ""
-        );
-      }
-      for (const route of Object.values(routes.special)) {
-        virtualFiles.set(
-          import_path3.default.posix.join(root, `${route.entryName}.marko`),
-          render ? renderRouteTemplate(route) : ""
-        );
+        if (routes.middleware.length) {
+          virtualFiles.set(
+            import_path3.default.posix.join(root, `${markoRunFilePrefix}middleware.js`),
+            ""
+          );
+        }
+        virtualFiles.set("@marko/run/router", "");
+        resolve(routes);
+      } catch (err) {
+        reject(err);
       }
-      if (routes.middleware.length) {
+    }));
+  }
+  let renderVirtualFilesResult;
+  function renderVirtualFiles(context) {
+    return renderVirtualFilesResult ?? (renderVirtualFilesResult = new Promise(async (resolve) => {
+      var _a;
+      const routerOptions = {
+        trailingSlashes: opts.trailingSlashes || "RedirectWithout"
+      };
+      try {
+        const routes2 = await buildVirtualFiles();
+        for (const route of routes2.list) {
+          if (route.handler) {
+            const exports2 = await getExportsFromFile(
+              context,
+              route.handler.filePath
+            );
+            route.handler.verbs = [];
+            for (const name of exports2) {
+              const verb = name.toLowerCase();
+              if (name === verb.toUpperCase() && httpVerbs.includes(verb)) {
+                route.handler.verbs.push(verb);
+              }
+            }
+            if (!route.handler.verbs.length) {
+              context.warn(
+                `Did not find any http verb exports in handler '${import_path3.default.relative(root, route.handler.filePath)}' - expected ${httpVerbs.map((v) => v.toUpperCase()).join(", ")}`
+              );
+            }
+          }
+          if (route.page) {
+            virtualFiles.set(
+              import_path3.default.posix.join(root, `${route.entryName}.marko`),
+              renderRouteTemplate(route)
+            );
+          }
+          virtualFiles.set(
+            import_path3.default.posix.join(root, `${route.entryName}.js`),
+            renderRouteEntry(route)
+          );
+        }
+        for (const route of Object.values(routes2.special)) {
+          virtualFiles.set(
+            import_path3.default.posix.join(root, `${route.entryName}.marko`),
+            renderRouteTemplate(route)
+          );
+        }
+        if (routes2.middleware.length) {
+          for (const middleware of routes2.middleware) {
+            if (!(await getExportsFromFile(context, middleware.filePath)).includes("default")) {
+              context.warn(
+                `Did not find a default export in middleware '${import_path3.default.relative(root, middleware.filePath)}'`
+              );
+            }
+          }
+          virtualFiles.set(
+            import_path3.default.posix.join(root, `${markoRunFilePrefix}middleware.js`),
+            renderMiddleware(routes2.middleware)
+          );
+        }
         virtualFiles.set(
-          import_path3.default.posix.join(root, `${markoRunFilePrefix}middleware.js`),
-          render ? renderMiddleware(routes.middleware) : ""
+          "@marko/run/router",
+          renderRouter(routes2, routerOptions)
         );
-      }
-      virtualFiles.set(
-        "@marko/run/router",
-        render ? renderRouter(routes, routerOptions) : ""
-      );
-      times.routesRender = performance.now() - renderStartTime;
-      if (render) {
-        await writeTypesFile(routes);
+        await writeTypesFile(routes2);
         if (adapter == null ? void 0 : adapter.routesGenerated) {
           await adapter.routesGenerated(
-            routes,
+            routes2,
             new Map(virtualFiles.entries()),
             {
               buildTime: times.routesBuild,
               renderTime: times.routesRender
             }
           );
+          if (!isBuild) {
+            await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes2.list));
+          }
         }
-        if (!isBuild) {
-          await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes.list));
+      } catch (err) {
+        if (isBuild) {
+          throw err;
         }
-        isRendered = true;
-      }
-    } catch (err) {
-      if (isBuild) {
-        throw err;
+        virtualFiles.set(
+          "@marko/run/router",
+          `throw ${JSON.stringify(prepareError(err))}`
+        );
       }
-      console.error(err);
-      virtualFiles.set(
-        import_path3.default.posix.join(root, `${markoRunFilePrefix}error.marko`),
-        renderEntryTemplate(`${markoRunFilePrefix}error`, ["<dev-error-page>"])
-      );
-      virtualFiles.set(
-        "@marko/run/router",
-        renderErrorRouter(err, routerOptions)
-      );
-      isRendered = true;
-    }
-    isStale = false;
-  });
+      resolve();
+    }));
+  }
   return [
     {
       name: `${PLUGIN_NAME_PREFIX}:pre`,
@@ -2041,29 +2078,44 @@ function markoRun(opts = {}) {
         } else {
           ssrEntryFiles = [];
         }
+        const baseError = config2.logger.error;
+        config2.logger.error = function(msg, options) {
+          var _a;
+          if (!((_a = options == null ? void 0 : options.error) == null ? void 0 : _a.message)) {
+            baseError.call(this, msg, options);
+          } else if (!seenErrors.has(options.error.message)) {
+            seenErrors.add(options.error.message);
+            console.error((0, import_vite.buildErrorMessage)(options.error));
+          }
+        };
       },
       configureServer(_server) {
         devServer = _server;
         devServer.watcher.on("all", async (type, filename) => {
-          const routableFileType = matchRoutableFile(import_path3.default.parse(filename).base);
+          seenErrors.clear();
+          const routableFileType = matchRoutableFile(
+            import_path3.default.parse(filename).base
+          );
           if (filename.startsWith(resolvedRoutesDir) && routableFileType) {
-            if (type === "add") {
-              isStale = true;
-            } else if (type === "unlink") {
-              isStale = true;
-            } else if (type === "change") {
-              if (routableFileType === RoutableFileTypes.Handler) {
-                isStale = true;
-              }
-            }
-            if (isStale) {
-              for (const id of virtualFiles.keys()) {
-                devServer.watcher.emit("change", id);
-                break;
+            if (type === "add" || type === "unlink" || type === "change" && (routableFileType === RoutableFileTypes.Handler || routableFileType === RoutableFileTypes.Middleware)) {
+              buildVirtualFilesResult = void 0;
+              renderVirtualFilesResult = void 0;
+              const module2 = devServer.moduleGraph.getModuleById(filename);
+              const importers = module2 && getImporters(module2, filename);
+              if (importers == null ? void 0 : importers.size) {
+                for (const file of importers) {
+                  devServer.watcher.emit("change", file);
+                }
+              } else {
+                for (const file of virtualFiles.keys()) {
+                  if (!file.endsWith(".marko")) {
+                    devServer.watcher.emit("change", file);
+                  }
+                }
               }
             }
           }
-        });
+        }).unwatch(typesDir + "/*");
       },
       async buildStart(_options) {
         if (isBuild && !isSSRBuild) {
@@ -2079,10 +2131,10 @@ function markoRun(opts = {}) {
           for (const { key, code } of routeData.files) {
             virtualFiles.set(key, code);
           }
-          isStale = false;
-          isRendered = true;
+          buildVirtualFilesResult = Promise.resolve(routes);
+          renderVirtualFilesResult = Promise.resolve();
         } else {
-          extractVerbs = isBuild ? getVerbsFromFileBuild.bind(null, this) : getVerbsFromFileDev.bind(null, devServer);
+          getExportsFromFile = isBuild ? getExportsFromFileBuild : getExportsFromFileDev.bind(null, devServer);
         }
       },
       async resolveId(importee, importer) {
@@ -2095,8 +2147,8 @@ function markoRun(opts = {}) {
           importee = import_path3.default.resolve(root, "." + importee);
         }
         importee = normalizePath(importee);
-        if (isStale) {
-          await buildVirtualFiles(false);
+        if (!buildVirtualFilesResult) {
+          await buildVirtualFiles();
         }
         if (virtualFiles.has(importee)) {
           resolved = importee;
@@ -2113,11 +2165,13 @@ function markoRun(opts = {}) {
         if (id.endsWith(serverEntryQuery)) {
           id = id.slice(0, -serverEntryQuery.length);
         }
+        if (!renderVirtualFilesResult) {
+          await renderVirtualFiles(this);
+        }
         if (virtualFiles.has(id)) {
-          if (isStale || !isRendered) {
-            await buildVirtualFiles(true);
-          }
           return virtualFiles.get(id);
+        } else if (import_path3.default.basename(id).startsWith(markoRunFilePrefix) && /^\.(js|marko)$/.test(import_path3.default.extname(id))) {
+          return "";
         }
       }
     },
@@ -2175,57 +2229,20 @@ function markoRun(opts = {}) {
     }
   ];
 }
-async function getVerbsFromFileBuild(context, filePath) {
-  const verbs = [];
+async function getExportsFromFileBuild(context, filePath) {
   const result = await context.load({
     id: filePath,
     resolveDependencies: false
   });
-  if (result) {
-    const exportIds = getExportIdentifiers(result.ast);
-    for (const id of exportIds) {
-      const verb = id.toLowerCase();
-      if (id === verb.toUpperCase() && httpVerbs.includes(verb)) {
-        verbs.push(verb);
-      }
-    }
-  }
-  return verbs;
+  return result ? getExportIdentifiers(result.ast) : [];
 }
-async function getVerbsFromFileDev(devServer, filePath) {
-  const verbs = [];
+async function getExportsFromFileDev(devServer, context, filePath) {
   const result = await devServer.transformRequest(filePath, { ssr: true });
-  if (result && result.code) {
-    const verbMatchReg = /__vite_ssr_exports__,\s+["'](GET|POST|PUT|DELETE)["']/gi;
-    let match = verbMatchReg.exec(result.code);
-    while (match) {
-      const id = match[1];
-      const verb = id.toLowerCase();
-      if (httpVerbs.includes(verb)) {
-        if (id === verb.toUpperCase()) {
-          verbs.push(verb);
-        } else {
-          console.warn(
-            `Found export '${id}' in handler ${filePath} which is close to '${verb.toUpperCase()}'. Exported handlers need to be uppercase: GET, POST, PUT or DELETE.`
-          );
-        }
-      }
-      match = verbMatchReg.exec(result.code);
-    }
+  if (result) {
+    const ast = context.parse(result.code);
+    return getViteSSRExportIdentifiers(ast);
   }
-  return verbs;
-}
-function single(fn) {
-  let promise;
-  return async (...args) => {
-    if (promise) {
-      return promise;
-    }
-    promise = fn(...args);
-    const result = await promise;
-    promise = void 0;
-    return result;
-  };
+  return [];
 }
 async function globFileExists(root, pattern) {
   return (await (0, import_glob.glob)(pattern, { root })).length > 0;
@@ -2278,6 +2295,15 @@ function getEntryFileName(file) {
   const match = file && markoEntryFileRegex.exec(file);
   return match ? match[2] || "index" : void 0;
 }
+function getImporters(module2, fileName, seen = /* @__PURE__ */ new Set()) {
+  for (const importer of module2.importers) {
+    if (importer.id && !seen.has(importer.id)) {
+      seen.add(importer.id);
+      getImporters(importer, fileName, seen);
+    }
+  }
+  return seen;
+}
 
 // src/vite/utils/server.ts
 var import_net = __toESM(require("net"), 1);