@marko/run 0.0.1-beta2 → 0.0.1-beta4

package/dist/cli/index.mjs

@@ -2,20 +2,24 @@
 
 // src/cli/index.ts
 import path from "path";
-import fs from "fs";
+import fs2 from "fs";
 import { fileURLToPath } from "url";
 import { build as viteBuild, resolveConfig } from "vite";
 import sade from "sade";
 
 // src/vite/utils/config.ts
-var KEY = "__MARKO_SERVE_OPTIONS__";
-function getMarkoServeOptions(viteConfig) {
-  return viteConfig[KEY];
+var PluginConfigKey = "__MARKO_RUN_PLUGIN_CONFIG__";
+var AdapterConfigKey = "__MARKO_RUN_ADAPTER_CONFIG__";
+function getConfig(obj, key) {
+  return obj[key];
 }
-function setMarkoServeOptions(viteConfig, options) {
-  viteConfig[KEY] = options;
-  return viteConfig;
+function setConfig(obj, key, value) {
+  obj[key] = value;
+  return obj;
 }
+var getExternalPluginOptions = (viteConfig) => getConfig(viteConfig, PluginConfigKey);
+var setExternalPluginOptions = (viteConfig, value) => setConfig(viteConfig, PluginConfigKey, value);
+var setExternalAdapterOptions = (viteConfig, value) => setConfig(viteConfig, AdapterConfigKey, value);
 
 // src/cli/index.ts
 import { MemoryStore } from "@marko/vite";
@@ -23,16 +27,27 @@ import { MemoryStore } from "@marko/vite";
 // src/vite/utils/server.ts
 import net from "net";
 import cp from "child_process";
-async function spawnServer(cmd, port = 0, cwd2 = process.cwd(), wait = 3e4) {
+import { parse, config } from "dotenv";
+import fs from "fs";
+async function parseEnv(envFile) {
+  if (fs.existsSync(envFile)) {
+    const content = await fs.promises.readFile(envFile, "utf8");
+    return parse(content);
+  }
+}
+async function spawnServer(cmd, port = 0, env, cwd2 = process.cwd(), wait = 3e4) {
   if (port <= 0) {
     port = await getAvailablePort();
   }
+  if (typeof env === "string") {
+    env = await parseEnv(env);
+  }
   const proc = cp.spawn(cmd, {
     cwd: cwd2,
     shell: true,
     stdio: "inherit",
     windowsHide: true,
-    env: { NODE_ENV: "development", ...process.env, PORT: `${port}` }
+    env: { ...env, NODE_ENV: "development", ...process.env, PORT: `${port}` }
   });
   const close = () => {
     proc.unref();
@@ -80,23 +95,25 @@ function sleep(ms) {
 var __dirname = fileURLToPath(new URL(".", import.meta.url));
 var cwd = process.cwd();
 var defaultPort = +process.env.PORT || 3e3;
-var prog = sade("marko-run").version("0.0.1").option("-c, --config", "Provide path to a Vite config");
-prog.command("preview [entry]", "", { default: true }).describe("Start production-like server against built assets").option("-o, --output", "Directory to serve files").option("-p, --port", "Port to use for dev server").option("-f, --file", "Output file to start").action(async (entry, opts) => {
-  const config = await getViteConfig(cwd, opts.config);
-  await build(entry, config, opts.output);
-  await preview(opts.entry, config, opts.port, opts.output);
+var defaultConfigFileBases = ["serve.config", "vite.config"];
+var defaultConfigFileExts = [".js", ".cjs", ".mjs", ".ts", ".mts"];
+var prog = sade("marko-run").version("0.0.1").option("-c, --config", `Provide path to a Vite config file (by default looks for a file starting with ${defaultConfigFileBases.join(" or ")} with one of these extensions: ${defaultConfigFileExts.join(", ")})`).option("-e, --env", "Provide path to a dotenv file");
+prog.command("serve [entry]", "", { default: true }).describe("Start a production-like server for already-built app files").option("-o, --output", "Directory to serve files from, and write asset files to if `--build` (default: )").option("-p, --port", "Port the server should listen on (defaults: `$PORT` env variable or 3000)").option("-f, --file", "Output file to start").action(async (entry, opts) => {
+  const config2 = await getViteConfig(cwd, opts.config);
+  await build(entry, config2, opts.output, false, opts.env);
+  await preview(opts.entry, config2, opts.port, opts.output, opts.env);
 });
-prog.command("dev [entry]").describe("Start dev server").option("-p, --port", "Port to use for dev server").example("dev --config vite.config.js").action(async (entry, opts) => {
+prog.command("dev [entry]").describe("Start development server in watch mode").option("-p, --port", "Port the dev server should listen on (defaults: 'preview.port' in config, or `$PORT` env variable, or 3000)").example("dev --config vite.config.js").action(async (entry, opts) => {
   const cmd = opts._.length ? `${entry} ${opts._.join(" ")}` : entry ? `node ${entry}` : void 0;
-  const config = await getViteConfig(cwd, opts.config);
-  await dev(cmd, config, opts.port);
+  const config2 = await getViteConfig(cwd, opts.config);
+  await dev(cmd, config2, opts.port, opts.env);
 });
-prog.command("build [entry]").describe("Build the application").option("-o, --output", "Directory to ouput built files").option("--skip-client", "Skip the client build").example("build --config vite.config.js").action(async (entry, opts) => {
-  const config = await getViteConfig(cwd, opts.config);
-  await build(entry, config, opts.ouput, opts["skip-client"]);
+prog.command("build [entry]").describe("Build the application (without serving it)").option("-o, --output", "Directory to write built files (default: )").option("--skip-client", "Skip the client-side build").example("build --config vite.config.js").action(async (entry, opts) => {
+  const config2 = await getViteConfig(cwd, opts.config);
+  await build(entry, config2, opts.ouput, opts["skip-client"], opts.env);
 });
 prog.parse(process.argv);
-async function preview(entry, configFile, port, outDir) {
+async function preview(entry, configFile, port, outDir, envFile) {
   const resolvedConfig = await resolveConfig(
     { root: cwd, configFile, build: { outDir } },
     "serve"
@@ -106,15 +123,18 @@ async function preview(entry, configFile, port, outDir) {
   }
   const adapter = await resolveAdapter(resolvedConfig);
   if (!adapter) {
-    throw new Error("No adapter specified for serve command");
+    throw new Error("No adapter specified for 'serve' command");
   } else if (!adapter.startPreview) {
-    throw new Error(`Adapter ${adapter.name} does not support serve command`);
+    throw new Error(`Adapter ${adapter.name} does not support 'serve' command`);
   }
   const dir = path.resolve(cwd, resolvedConfig.build.outDir);
   const entryFile = entry ? path.join(dir, entry) : await findFileWithExt(dir, "index", [".mjs", ".js"]);
-  await adapter.startPreview(dir, entryFile, port);
+  if (envFile) {
+    envFile = path.resolve(cwd, envFile);
+  }
+  await adapter.startPreview(dir, entryFile, port, envFile);
 }
-async function dev(cmd, configFile, port) {
+async function dev(cmd, configFile, port, envFile) {
   const resolvedConfig = await resolveConfig(
     { root: cwd, configFile },
     "build"
@@ -122,55 +142,63 @@ async function dev(cmd, configFile, port) {
   if (port === void 0) {
     port = resolvedConfig.preview.port ?? defaultPort;
   }
+  if (envFile) {
+    envFile = path.resolve(cwd, envFile);
+  }
   if (cmd) {
-    await spawnServer(cmd, port);
+    await spawnServer(cmd, port, envFile);
   } else {
     const adapter = await resolveAdapter(resolvedConfig);
     if (!adapter) {
       throw new Error(
-        "No adapter specified for dev command without custom target"
+        "No adapter specified for 'dev' command without custom target"
       );
     } else if (!adapter.startDev) {
-      throw new Error(`Adapter ${adapter.name} does not support serve command`);
+      throw new Error(`Adapter '${adapter.name}' does not support 'serve' command`);
     } else {
-      await adapter.startDev(configFile, port);
+      await adapter.startDev(configFile, port, envFile);
     }
   }
 }
-async function build(entry, configFile, outDir, skipClient = false) {
+async function build(entry, configFile, outDir, skipClient = false, envFile) {
   var _a;
+  const resolvedConfig = await resolveConfig(
+    { root: cwd, configFile },
+    "build"
+  );
+  const adapter = await resolveAdapter(resolvedConfig);
+  if (!adapter) {
+    throw new Error("No adapter specified for build command without entry");
+  }
   if (!entry) {
-    const resolvedConfig = await resolveConfig(
-      { root: cwd, configFile },
-      "build"
-    );
-    const adapter = await resolveAdapter(resolvedConfig);
-    if (!adapter) {
-      throw new Error("No adapter specified for build command without entry");
-    }
     entry = await ((_a = adapter.getEntryFile) == null ? void 0 : _a.call(adapter));
     if (!entry) {
       throw new Error(
-        `Adapter ${adapter.name} does not support build command without entry`
+        `Adapter '${adapter.name}' does not support building without an entry`
       );
     }
   }
-  const buildConfig = setMarkoServeOptions(
-    {
-      root: cwd,
-      configFile,
-      build: {
-        ssr: false,
-        outDir
-      }
-    },
-    {
-      store: new MemoryStore()
+  if (envFile) {
+    envFile = path.resolve(cwd, envFile);
+  }
+  let buildConfig = {
+    root: cwd,
+    configFile,
+    build: {
+      ssr: false,
+      outDir
     }
-  );
+  };
+  buildConfig = setExternalPluginOptions(buildConfig, {
+    store: new MemoryStore()
+  });
+  buildConfig = setExternalAdapterOptions(buildConfig, {
+    envFile
+  });
   await viteBuild({
     ...buildConfig,
     build: {
+      target: "esnext",
       ...buildConfig.build,
       ssr: entry,
       rollupOptions: {
@@ -190,19 +218,20 @@ async function build(entry, configFile, outDir, skipClient = false) {
     });
   }
 }
-function findFileWithExt(dir, base, extensions = [".js", ".cjs", ".mjs", ".ts", ".mts"]) {
+function findFileWithExt(dir, base, extensions = defaultConfigFileExts) {
   for (const ext of extensions) {
     const filePath = path.join(dir, base + ext);
-    if (fs.existsSync(filePath)) {
+    if (fs2.existsSync(filePath)) {
       return filePath;
     }
   }
   return void 0;
 }
-async function getViteConfig(dir, configFile, bases = ["serve.config", "vite.config"]) {
+async function getViteConfig(dir, configFile, bases = defaultConfigFileBases) {
   if (configFile) {
-    if (!fs.existsSync(path.join(dir, configFile))) {
-      throw new Error(`Unable to load config file '${configFile}' from ${dir}`);
+    const configFilePath = path.join(dir, configFile);
+    if (!fs2.existsSync(configFilePath)) {
+      throw new Error(`No config file found at '${configFilePath}'`);
     }
     return configFile;
   }
@@ -214,10 +243,10 @@ async function getViteConfig(dir, configFile, bases = ["serve.config", "vite.con
   }
   return path.join(__dirname, "default.config.mjs");
 }
-async function resolveAdapter(config) {
-  const options = getMarkoServeOptions(config);
+async function resolveAdapter(config2) {
+  const options = getExternalPluginOptions(config2);
   if (!options) {
-    throw new Error("Unable to resolve Marko Serve options");
+    throw new Error("Unable to resolve @marko/serve options");
   }
   return options.adapter;
 }

package/dist/runtime/index.cjs

@@ -3,10 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -19,16 +15,4 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 
 // src/runtime/index.ts
 var runtime_exports = {};
-__export(runtime_exports, {
-  getMatchedRoute: () => import_router.getMatchedRoute,
-  handler: () => import_router.handler,
-  router: () => import_router.router
-});
 module.exports = __toCommonJS(runtime_exports);
-var import_router = require("@marko/run/router");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getMatchedRoute,
-  handler,
-  router
-});

package/dist/runtime/index.d.ts

@@ -1,2 +1,10 @@
-export { router, getMatchedRoute, handler } from '@marko/run/router';
-export type { MatchedRoute, Handler, RouteContext, RouteHandler, RouteMatcher, Router } from './types';
+import type { HandlerLike, ParamsObject, Route } from "./types";
+declare global {
+    namespace Marko {
+        interface CurrentRoute extends Route {
+        }
+        type Handler<Params extends ParamsObject = {}, Meta = unknown> = HandlerLike<Route<Params, Meta, string>>;
+        function route<Params extends ParamsObject = {}, Meta = unknown>(handler: Handler<Params, Meta>): typeof handler;
+    }
+}
+export type { HandlerLike, InputObject, InvokeRoute, MatchRoute, NextFunction, RequestContext, Route, RouteContext, RouteContextExtensions, RouteHandler, RouteWithHandler, Router, } from "./types";

package/dist/runtime/index.js

@@ -1,7 +0,0 @@
-// src/runtime/index.ts
-import { router, getMatchedRoute, handler } from "@marko/run/router";
-export {
-  getMatchedRoute,
-  handler,
-  router
-};

package/dist/runtime/internal.cjs

@@ -0,0 +1,148 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  RequestNotHandled: () => RequestNotHandled,
+  RequestNotMatched: () => RequestNotMatched,
+  call: () => call,
+  compose: () => compose,
+  createInput: () => createInput,
+  noContent: () => noContent,
+  normalize: () => normalize,
+  notHandled: () => notHandled,
+  notMatched: () => notMatched
+});
+module.exports = __toCommonJS(internal_exports);
+globalThis.Marko ?? (globalThis.Marko = {});
+globalThis.Marko.route = (handler) => handler;
+var RequestNotHandled = Symbol();
+var RequestNotMatched = Symbol();
+function createInput(context) {
+  let existing;
+  return (data) => {
+    existing ?? (existing = {
+      $global: {
+        context
+      }
+    });
+    return data ? Object.assign(existing, data) : existing;
+  };
+}
+async function call(handler, next, context) {
+  let response;
+  if (process.env.NODE_ENV !== "production") {
+    let nextCallCount = 0;
+    let didThrow = false;
+    try {
+      response = await handler(context, () => {
+        nextCallCount++;
+        return next();
+      });
+    } catch (error) {
+      didThrow = true;
+      if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    } finally {
+      if (!response && !didThrow && nextCallCount > 0) {
+        console.warn(
+          `Handler '${handler.name}' called its next function but no response was returned. This will cause the next function to be called again which is wasteful. Either return or throw the result of calling \`next\`, return or throw a new Response object or finally \`throw null\` to skip handling the request`
+        );
+      } else if (nextCallCount > 1) {
+        console.warn(
+          `Handler '${handler.name}' called its next function more than once. Make sure this is intentional because it is inefficient.`
+        );
+      }
+    }
+  } else {
+    try {
+      response = await handler(context, next);
+    } catch (error) {
+      if (error == null) {
+        throw RequestNotHandled;
+      } else if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    }
+  }
+  if (response === null) {
+    throw RequestNotMatched;
+  }
+  return response || next();
+}
+function compose(handlers) {
+  const len = handlers.length;
+  if (!len) {
+    return (_context, next) => next();
+  } else if (len === 1) {
+    return handlers[0];
+  }
+  return (context, next) => {
+    let i = 0;
+    return function nextHandler() {
+      return i < len ? call(handlers[i++], nextHandler, context) : next();
+    }();
+  };
+}
+function normalize(obj) {
+  if (typeof obj === "function") {
+    return obj;
+  } else if (Array.isArray(obj)) {
+    return compose(obj);
+  } else if (obj instanceof Promise) {
+    const promise = obj.then((value) => {
+      fn = Array.isArray(value) ? compose(value) : value;
+    });
+    let fn = async (context, next) => {
+      await promise;
+      return fn(context, next);
+    };
+    return (context, next) => fn(context, next);
+  }
+  throw new Error(
+    `Invalid handler - expected function, array or Promise but received ${obj}`
+  );
+}
+function noContent() {
+  return new Response(null, {
+    status: 204
+  });
+}
+function notHandled() {
+  throw null;
+}
+function notMatched() {
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RequestNotHandled,
+  RequestNotMatched,
+  call,
+  compose,
+  createInput,
+  noContent,
+  normalize,
+  notHandled,
+  notMatched
+});

package/dist/runtime/internal.d.ts

@@ -0,0 +1,10 @@
+import type { InputObject, NextFunction, Route, RouteContext, RouteHandler } from "./types";
+export declare const RequestNotHandled: unique symbol;
+export declare const RequestNotMatched: unique symbol;
+export declare function createInput(context: RouteContext): (data: InputObject) => InputObject;
+export declare function call(handler: RouteHandler<Route>, next: NextFunction, context: RouteContext): Promise<Response>;
+export declare function compose(handlers: RouteHandler[]): RouteHandler;
+export declare function normalize(obj: RouteHandler | RouteHandler[] | Promise<RouteHandler | RouteHandler[]>): RouteHandler;
+export declare function noContent(): Response;
+export declare function notHandled(): void;
+export declare function notMatched(): null;

package/dist/runtime/internal.js

@@ -0,0 +1,115 @@
+// src/runtime/internal.ts
+globalThis.Marko ?? (globalThis.Marko = {});
+globalThis.Marko.route = (handler) => handler;
+var RequestNotHandled = Symbol();
+var RequestNotMatched = Symbol();
+function createInput(context) {
+  let existing;
+  return (data) => {
+    existing ?? (existing = {
+      $global: {
+        context
+      }
+    });
+    return data ? Object.assign(existing, data) : existing;
+  };
+}
+async function call(handler, next, context) {
+  let response;
+  if (process.env.NODE_ENV !== "production") {
+    let nextCallCount = 0;
+    let didThrow = false;
+    try {
+      response = await handler(context, () => {
+        nextCallCount++;
+        return next();
+      });
+    } catch (error) {
+      didThrow = true;
+      if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    } finally {
+      if (!response && !didThrow && nextCallCount > 0) {
+        console.warn(
+          `Handler '${handler.name}' called its next function but no response was returned. This will cause the next function to be called again which is wasteful. Either return or throw the result of calling \`next\`, return or throw a new Response object or finally \`throw null\` to skip handling the request`
+        );
+      } else if (nextCallCount > 1) {
+        console.warn(
+          `Handler '${handler.name}' called its next function more than once. Make sure this is intentional because it is inefficient.`
+        );
+      }
+    }
+  } else {
+    try {
+      response = await handler(context, next);
+    } catch (error) {
+      if (error == null) {
+        throw RequestNotHandled;
+      } else if (error instanceof Response) {
+        return error;
+      }
+      throw error;
+    }
+  }
+  if (response === null) {
+    throw RequestNotMatched;
+  }
+  return response || next();
+}
+function compose(handlers) {
+  const len = handlers.length;
+  if (!len) {
+    return (_context, next) => next();
+  } else if (len === 1) {
+    return handlers[0];
+  }
+  return (context, next) => {
+    let i = 0;
+    return function nextHandler() {
+      return i < len ? call(handlers[i++], nextHandler, context) : next();
+    }();
+  };
+}
+function normalize(obj) {
+  if (typeof obj === "function") {
+    return obj;
+  } else if (Array.isArray(obj)) {
+    return compose(obj);
+  } else if (obj instanceof Promise) {
+    const promise = obj.then((value) => {
+      fn = Array.isArray(value) ? compose(value) : value;
+    });
+    let fn = async (context, next) => {
+      await promise;
+      return fn(context, next);
+    };
+    return (context, next) => fn(context, next);
+  }
+  throw new Error(
+    `Invalid handler - expected function, array or Promise but received ${obj}`
+  );
+}
+function noContent() {
+  return new Response(null, {
+    status: 204
+  });
+}
+function notHandled() {
+  throw null;
+}
+function notMatched() {
+  return null;
+}
+export {
+  RequestNotHandled,
+  RequestNotMatched,
+  call,
+  compose,
+  createInput,
+  noContent,
+  normalize,
+  notHandled,
+  notMatched
+};

package/dist/runtime/router.cjs

@@ -20,20 +20,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/runtime/router.ts
 var router_exports = {};
 __export(router_exports, {
-  getMatchedRoute: () => getMatchedRoute,
-  handler: () => handler,
+  invokeRoute: () => invokeRoute,
+  matchRoute: () => matchRoute,
   router: () => router
 });
 module.exports = __toCommonJS(router_exports);
 function notImplemented() {
-  throw new Error("This should have been replaced by the @marko/run plugin at build/dev time");
+  throw new Error(
+    "This should have been replaced by the @marko/run plugin at build/dev time"
+  );
 }
-var handler = notImplemented;
 var router = notImplemented;
-var getMatchedRoute = notImplemented;
+var matchRoute = notImplemented;
+var invokeRoute = notImplemented;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getMatchedRoute,
-  handler,
+  invokeRoute,
+  matchRoute,
   router
 });

package/dist/runtime/router.d.ts

@@ -1,4 +1,4 @@
-import type { Handler, RouteMatcher, Router } from './types';
-export declare const handler: Handler;
-export declare const router: Router;
-export declare const getMatchedRoute: RouteMatcher;
+import type { MatchRoute, RequestContext, Route } from "./types";
+export declare const router: <T>(context: RequestContext<T>) => Promise<Response | void>;
+export declare const matchRoute: MatchRoute;
+export declare const invokeRoute: <T>(route: Route | null, context: RequestContext<T>) => Promise<Response | void>;

package/dist/runtime/router.js

@@ -1,12 +1,14 @@
 // src/runtime/router.ts
 function notImplemented() {
-  throw new Error("This should have been replaced by the @marko/run plugin at build/dev time");
+  throw new Error(
+    "This should have been replaced by the @marko/run plugin at build/dev time"
+  );
 }
-var handler = notImplemented;
 var router = notImplemented;
-var getMatchedRoute = notImplemented;
+var matchRoute = notImplemented;
+var invokeRoute = notImplemented;
 export {
-  getMatchedRoute,
-  handler,
+  invokeRoute,
+  matchRoute,
   router
 };