@marko/run 0.0.1-beta3 → 0.0.1-beta5

package/dist/adapter/index.js

@@ -4,7 +4,173 @@ import { fileURLToPath } from "url";
 
 // src/adapter/dev-server.ts
 import { createServer } from "vite";
-import createMiddleware from "@marko/run/adapter/middleware";
+
+// src/adapter/middleware.ts
+import * as webStream from "stream/web";
+import installCrypto from "@hattip/polyfills/crypto";
+installCrypto();
+for (const key of Object.keys(webStream)) {
+  if (!(key in global)) {
+    global[key] = webStream[key];
+  }
+}
+function getForwardedHeader(req, name) {
+  const value = req.headers["x-forwarded-" + name];
+  if (value) {
+    if (typeof value === "string") {
+      const index = value.indexOf(",");
+      return index < 0 ? value : value.slice(0, index);
+    }
+    return value[0];
+  }
+}
+function getOrigin(req, protocol, host, trustProxy) {
+  var _a;
+  protocol ?? (protocol = req.protocol || trustProxy && getForwardedHeader(req, "proto") || ((_a = req.socket) == null ? void 0 : _a.encrypted) && "https" || "http");
+  host ?? (host = trustProxy && getForwardedHeader(req, "host") || req.headers.host);
+  if (!host) {
+    if (process.env.NODE_ENV !== "production") {
+      host = "localhost";
+      console.warn(
+        `Could not automatically determine the origin host, using 'localhost'. Use the 'origin' option or the 'ORIGIN' environment variable to set the origin explicitly.`
+      );
+    } else {
+      throw new Error(
+        `Could not automatically determine the origin host. Use the 'origin' option or the 'ORIGIN' environment variable to set the origin explicitly.`
+      );
+    }
+  }
+  return `${protocol}://${host}`;
+}
+function createMiddleware(router, options = {}) {
+  const { trustProxy = process.env.TRUST_PROXY === "1" } = options;
+  let { origin = process.env.ORIGIN } = options;
+  let protocol;
+  let host;
+  if (origin) {
+    ({ protocol, host } = new URL(origin));
+    protocol = protocol.slice(0, -1);
+  }
+  return async (req, res, next) => {
+    origin ?? (origin = getOrigin(req, protocol, host, trustProxy));
+    const url = new URL(req.url, origin);
+    const ip = req.ip || trustProxy && getForwardedHeader(req, "for") || req.socket.remoteAddress || "";
+    const requestContext = {
+      method: req.method,
+      url,
+      platform: {
+        ip,
+        request: req,
+        response: res,
+        setCookie(cookie) {
+          res.appendHeader("set-cookie", cookie);
+        }
+      }
+    };
+    Object.defineProperty(requestContext, "request", {
+      get() {
+        const headers = req.headers;
+        const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
+          start(controller) {
+            req.on("data", (chunk) => controller.enqueue(chunk));
+            req.on("end", () => controller.close());
+            req.on("error", (err) => controller.error(err));
+          }
+        });
+        const request = new Request(url, {
+          method: req.method,
+          headers,
+          body,
+          duplex: "half"
+        });
+        Object.defineProperty(this, "request", {
+          value: request,
+          enumerable: true,
+          configurable: true
+        });
+        return request;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    const response = await router(requestContext);
+    if (!response) {
+      if (next) {
+        next();
+      } else {
+        res.statusCode = 404;
+        res.setHeader("content-length", "0");
+        res.end();
+        return;
+      }
+      return;
+    }
+    res.statusCode = response.status;
+    for (const [key, value] of response.headers) {
+      if (key === "set-cookie") {
+        let sepIndex = value.indexOf(",") + 1;
+        if (!sepIndex) {
+          res.setHeader(key, value);
+        } else {
+          let index = 0;
+          do {
+            res.appendHeader(key, value.slice(index, sepIndex - 1));
+            index = sepIndex;
+            sepIndex = value.indexOf(",", sepIndex) + 1;
+          } while (sepIndex);
+          res.appendHeader(key, value.slice(index));
+        }
+      } else {
+        res.setHeader(key, value);
+      }
+    }
+    if (!response.body) {
+      if (!response.headers.has("content-length")) {
+        res.setHeader("content-length", "0");
+      }
+      res.end();
+      return;
+    }
+    const reader = response.body.getReader();
+    if (res.destroyed) {
+      reader.cancel();
+      return;
+    }
+    res.on("close", cancel);
+    res.on("error", cancel);
+    write();
+    function cancel(error) {
+      res.off("close", cancel);
+      res.off("error", cancel);
+      reader.cancel(error).catch(() => {
+      });
+      error && res.destroy(error);
+    }
+    async function write() {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            res.end();
+            return;
+          } else if (!res.write(value)) {
+            res.once("drain", write);
+            return;
+          } else if (res.flush) {
+            res.flush();
+          }
+        }
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Error while writing to node response", {
+          cause: err
+        });
+        cancel(error);
+      }
+    }
+  };
+}
+
+// src/adapter/dev-server.ts
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;

package/dist/adapter/middleware.cjs

@@ -79,20 +79,19 @@ function createMiddleware(router, options = {}) {
     origin ?? (origin = getOrigin(req, protocol, host, trustProxy));
     const url = new URL(req.url, origin);
     const ip = req.ip || trustProxy && getForwardedHeader(req, "for") || req.socket.remoteAddress || "";
-    const platform = {
-      ip,
-      request: req,
-      response: res,
-      setCookie(cookie) {
-        res.appendHeader("set-cookie", cookie);
-      }
-    };
-    const context = {
+    const requestContext = {
       method: req.method,
       url,
-      platform
+      platform: {
+        ip,
+        request: req,
+        response: res,
+        setCookie(cookie) {
+          res.appendHeader("set-cookie", cookie);
+        }
+      }
     };
-    Object.defineProperty(context, "request", {
+    Object.defineProperty(requestContext, "request", {
       get() {
         const headers = req.headers;
         const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
@@ -118,7 +117,7 @@ function createMiddleware(router, options = {}) {
       enumerable: true,
       configurable: true
     });
-    const response = await router(context);
+    const response = await router(requestContext);
     if (!response) {
       if (next) {
         next();

package/dist/adapter/middleware.d.ts

@@ -1,4 +1,4 @@
-import type { Router } from "@marko/run";
+import type { Router } from "../runtime";
 import type { IncomingMessage, ServerResponse } from "http";
 declare module "net" {
     interface Socket {
@@ -14,10 +14,6 @@ declare module "http" {
         appendHeader(key: string, value: string | string[]): this;
     }
 }
-declare module "@marko/run" {
-    interface Platform extends NodePlatformInfo {
-    }
-}
 export interface NodePlatformInfo {
     ip: string;
     request: IncomingMessage;

package/dist/adapter/middleware.js

@@ -48,20 +48,19 @@ function createMiddleware(router, options = {}) {
     origin ?? (origin = getOrigin(req, protocol, host, trustProxy));
     const url = new URL(req.url, origin);
     const ip = req.ip || trustProxy && getForwardedHeader(req, "for") || req.socket.remoteAddress || "";
-    const platform = {
-      ip,
-      request: req,
-      response: res,
-      setCookie(cookie) {
-        res.appendHeader("set-cookie", cookie);
-      }
-    };
-    const context = {
+    const requestContext = {
       method: req.method,
       url,
-      platform
+      platform: {
+        ip,
+        request: req,
+        response: res,
+        setCookie(cookie) {
+          res.appendHeader("set-cookie", cookie);
+        }
+      }
     };
-    Object.defineProperty(context, "request", {
+    Object.defineProperty(requestContext, "request", {
       get() {
         const headers = req.headers;
         const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
@@ -87,7 +86,7 @@ function createMiddleware(router, options = {}) {
       enumerable: true,
       configurable: true
     });
-    const response = await router(context);
+    const response = await router(requestContext);
     if (!response) {
       if (next) {
         next();

package/dist/cli/index.mjs

@@ -8,14 +8,18 @@ import { build as viteBuild, resolveConfig } from "vite";
 import sade from "sade";
 
 // src/vite/utils/config.ts
-var KEY = "__MARKO_SERVE_OPTIONS__";
-function getMarkoRunOptions(viteConfig) {
-  return viteConfig[KEY];
+var PluginConfigKey = "__MARKO_RUN_PLUGIN_CONFIG__";
+var AdapterConfigKey = "__MARKO_RUN_ADAPTER_CONFIG__";
+function getConfig(obj, key) {
+  return obj[key];
 }
-function setMarkoRunOptions(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";
@@ -91,18 +95,20 @@ 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").option("-e, --env", "Provide path to a dotenv file");
-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) => {
+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 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) => {
+prog.command("build [entry]").describe("Build the application (without serving it)").option("-o, --output", "Directory to write built files (default: 'build.outDir' in Vite config)").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);
 });
@@ -117,9 +123,9 @@ async function preview(entry, configFile, port, outDir, envFile) {
   }
   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"]);
@@ -145,10 +151,10 @@ async function dev(cmd, configFile, port, envFile) {
     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, envFile);
     }
@@ -156,38 +162,39 @@ async function dev(cmd, configFile, port, envFile) {
 }
 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`
       );
     }
   }
   if (envFile) {
     envFile = path.resolve(cwd, envFile);
   }
-  const buildConfig = setMarkoRunOptions(
-    {
-      root: cwd,
-      configFile,
-      build: {
-        ssr: false,
-        outDir
-      }
-    },
-    {
-      store: new MemoryStore()
+  let buildConfig = {
+    root: cwd,
+    configFile,
+    build: {
+      ssr: false,
+      outDir
     }
-  );
+  };
+  buildConfig = setExternalPluginOptions(buildConfig, {
+    store: new MemoryStore()
+  });
+  buildConfig = setExternalAdapterOptions(buildConfig, {
+    envFile
+  });
   await viteBuild({
     ...buildConfig,
     build: {
@@ -211,7 +218,7 @@ async function build(entry, configFile, outDir, skipClient = false, envFile) {
     });
   }
 }
-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 (fs2.existsSync(filePath)) {
@@ -220,10 +227,11 @@ function findFileWithExt(dir, base, extensions = [".js", ".cjs", ".mjs", ".ts",
   }
   return void 0;
 }
-async function getViteConfig(dir, configFile, bases = ["serve.config", "vite.config"]) {
+async function getViteConfig(dir, configFile, bases = defaultConfigFileBases) {
   if (configFile) {
-    if (!fs2.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;
   }
@@ -236,9 +244,9 @@ async function getViteConfig(dir, configFile, bases = ["serve.config", "vite.con
   return path.join(__dirname, "default.config.mjs");
 }
 async function resolveAdapter(config2) {
-  const options = getMarkoRunOptions(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.d.ts

@@ -1,10 +1,17 @@
-import type { HandlerLike, ParamsObject, Route } from "./types";
+import type { HandlerLike, ParamsObject, Route, RouteContext } from "./types";
 declare global {
     namespace Marko {
+        interface Global {
+            context: RouteContext;
+        }
+    }
+    namespace MarkoRun {
         interface CurrentRoute extends Route {
         }
+        interface CurrentContext extends RouteContext<CurrentRoute> {
+        }
         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";
+export type { HandlerLike, InputObject, InvokeRoute, MatchRoute, NextFunction, PathTemplate, RequestContext, Route, RouteContext, RouteContextExtensions, RouteHandler, RouteWithHandler, Router, ValidateHref, ValidatePath, } from "./types";

package/dist/runtime/internal.cjs

@@ -31,8 +31,8 @@ __export(internal_exports, {
   notMatched: () => notMatched
 });
 module.exports = __toCommonJS(internal_exports);
-globalThis.Marko ?? (globalThis.Marko = {});
-globalThis.Marko.route = (handler) => handler;
+globalThis.MarkoRun ?? (globalThis.MarkoRun = {});
+globalThis.MarkoRun.route = (handler) => handler;
 var RequestNotHandled = Symbol();
 var RequestNotMatched = Symbol();
 function createInput(context) {

package/dist/runtime/internal.js

@@ -1,6 +1,6 @@
 // src/runtime/internal.ts
-globalThis.Marko ?? (globalThis.Marko = {});
-globalThis.Marko.route = (handler) => handler;
+globalThis.MarkoRun ?? (globalThis.MarkoRun = {});
+globalThis.MarkoRun.route = (handler) => handler;
 var RequestNotHandled = Symbol();
 var RequestNotMatched = Symbol();
 function createInput(context) {

package/dist/runtime/router.cjs

@@ -26,7 +26,9 @@ __export(router_exports, {
 });
 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 router = notImplemented;
 var matchRoute = notImplemented;

package/dist/runtime/router.d.ts

@@ -1,4 +1,4 @@
-import type { InvokeRoute, MatchRoute, Router } from './types';
-export declare const router: Router<import("./types").Platform>;
+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: InvokeRoute<import("./types").Platform>;
+export declare const invokeRoute: <T>(route: Route | null, context: RequestContext<T>) => Promise<Response | void>;

package/dist/runtime/router.js

@@ -1,6 +1,8 @@
 // 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 router = notImplemented;
 var matchRoute = notImplemented;

package/dist/runtime/types.d.ts

@@ -5,11 +5,9 @@ declare type Combine<T> = T extends object ? {
 } : T;
 export interface RouteContextExtensions {
 }
-export interface Platform {
-}
 export declare type ParamsObject = Record<string, string>;
 export declare type InputObject = Record<PropertyKey, any>;
-export interface RequestContext<T = Platform> {
+export interface RequestContext<T = unknown> {
     url: URL;
     method: string;
     request: Request;
@@ -32,6 +30,14 @@ export interface RouteWithHandler<Params extends ParamsObject = {}, Meta = unkno
     handler: RouteHandler<this>;
 }
 export declare type MatchRoute = (method: string, pathname: string) => RouteWithHandler | null;
-export declare type Router<T = Platform> = (context: RequestContext<T>) => Promise<Response | void>;
-export declare type InvokeRoute<T = Platform> = (route: Route | null, context: RequestContext<T>) => Promise<Response | void>;
+export declare type Router<T = unknown> = (context: RequestContext<T>) => Promise<Response | void>;
+export declare type InvokeRoute<T = unknown> = (route: Route | null, context: RequestContext<T>) => Promise<Response | void>;
+declare type Member<T, U> = T extends T ? (U extends T ? T : never) : never;
+declare type Segments<T extends string, Acc extends string[] = []> = T extends "" ? Acc : T extends `${infer Left}/${infer Rest}` ? Segments<Rest, [...Acc, Left]> : [...Acc, T];
+declare type GTE<A extends any[], B extends any[]> = A["length"] extends B["length"] ? 1 : A extends [infer _Ha, ...infer Ta] ? B extends [infer _Hb, ...infer Tb] ? GTE<Ta, Tb> : 1 : 0;
+declare type MatchSegments<A extends string, B extends string> = A extends `${infer P}/${string}*` ? 1 extends GTE<Segments<B>, Segments<P>> ? `${P}/${string}` : never : Segments<B>["length"] extends Segments<A>["length"] ? A : never;
+declare type PathPattern<T extends string> = T extends `${infer Left}/\${${string}}/${infer Rest}` ? PathPattern<`${Left}/${string}/${Rest}`> : T extends `${infer Left}/\${...${string}}` ? PathPattern<`${Left}/${string}*`> : T extends `${infer Left}/\${${string}}` ? PathPattern<`${Left}/${string}`> : T;
+export declare type PathTemplate<Path extends string> = Path extends `${infer Left}/\${${string}}/${infer Rest}` ? PathTemplate<`${Left}/${string}/${Rest}`> : Path extends `${infer Left}/\${${string}}` ? PathTemplate<`${Left}/${string}`> : Path;
+export declare type ValidatePath<Paths extends string, Path extends string> = Paths | (Path extends `/${string}` ? MatchSegments<Member<PathPattern<Paths>, Path>, Path> : Path);
+export declare type ValidateHref<Paths extends string, Href extends string> = Href extends `${infer P}#${infer H}?${infer Q}` ? `${ValidatePath<Paths, P>}#${H}?${Q}` : Href extends `${infer P}?${infer Q}` ? `${ValidatePath<Paths, P>}?${Q}` : Href extends `${infer P}#${infer H}` ? `${ValidatePath<Paths, P>}#${H}` : ValidatePath<Paths, Href>;
 export {};