@marko/run 0.0.1-beta1 → 0.0.1-beta10

package/dist/adapter/middleware.js

@@ -0,0 +1,209 @@
+// src/adapter/polyfill.ts
+import { ReadableStream as ReadableStream2, TransformStream, WritableStream } from "stream/web";
+import { webcrypto as crypto } from "crypto";
+import { fetch, Response, Request as Request2, Headers, FormData, File } from "undici";
+import { OutgoingMessage } from "http";
+var globals = {
+  crypto,
+  fetch,
+  Response,
+  Request: Request2,
+  Headers,
+  ReadableStream: ReadableStream2,
+  TransformStream,
+  WritableStream,
+  FormData,
+  File
+};
+if (typeof OutgoingMessage.prototype.appendHeader !== "function") {
+  const messageHeaders = /* @__PURE__ */ new WeakMap();
+  OutgoingMessage.prototype.appendHeader = function(name, value) {
+    let headers = messageHeaders.get(this);
+    if (!headers) {
+      headers = /* @__PURE__ */ new Map();
+      messageHeaders.set(this, headers);
+    }
+    const key = name.toLowerCase();
+    let existing = headers.get(key);
+    if (existing) {
+      if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        existing = [existing, value];
+      }
+      this.setHeader(name, existing);
+      headers.set(key, existing);
+    } else {
+      this.setHeader(name, value);
+      headers.set(key, value);
+    }
+    return this;
+  };
+}
+function installPolyfills() {
+  for (const name in globals) {
+    if (!(name in globalThis)) {
+      Object.defineProperty(globalThis, name, {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: globals[name]
+      });
+    }
+  }
+}
+
+// src/adapter/middleware.ts
+installPolyfills();
+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(fetch2, options = {}) {
+  const { trustProxy = process.env.TRUST_PROXY === "1", devServer } = 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 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"
+    });
+    const response = await fetch2(request, {
+      ip,
+      request: req,
+      response: res,
+      setCookie(cookie) {
+        res.appendHeader("set-cookie", cookie);
+      }
+    });
+    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(() => {
+      });
+      if (error) {
+        if (process.env.NODE_ENV !== "production" && devServer) {
+          res.end();
+          devServer.ws.send({
+            type: "error",
+            err: { message: error.message, stack: error.stack || "" }
+          });
+        } else {
+          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);
+      }
+    }
+  };
+}
+export {
+  createMiddleware,
+  getOrigin
+};

package/dist/adapter/polyfill.d.ts

@@ -0,0 +1,6 @@
+declare module 'http' {
+    interface OutgoingMessage {
+        appendHeader(this: OutgoingMessage, name: string, value: string): this;
+    }
+}
+export declare function installPolyfills(): void;

package/dist/cli/default.config.mjs

@@ -1,7 +1,7 @@
 import { defineConfig } from "vite";
 import marko from "@marko/run/vite";
-import staticAdapter from "@marko/run/adapter";
+import nodeAdapter from "@marko/run/adapter";
 
 export default defineConfig({
-  plugins: [marko({ adapter: staticAdapter() })],
+  plugins: [marko({ adapter: nodeAdapter() })]
 });

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,27 @@ 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("preview [entry]").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) => {
+  process.env.NODE_ENV = "production";
+  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]", "", { default: true }).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: 'build.outDir' in Vite config)").option("--skip-client", "Skip the client-side build").example("build --config vite.config.js").action(async (entry, opts) => {
+  process.env.NODE_ENV = "production";
+  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 +125,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 +144,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 +220,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 +245,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,21 @@
-export { router, getMatchedRoute, handler } from '@marko/run/router';
-export type { MatchedRoute, Handler, RouteContext, RouteHandler, RouteMatcher, Router } from './types';
+import type { HandlerLike, ParamsObject, Route as AnyRoute, Context as AnyContext } from "./types";
+declare global {
+    namespace Marko {
+        interface Global extends MarkoRun.Context {
+        }
+        interface Out {
+            global: Global;
+        }
+    }
+    namespace MarkoRun {
+        const NotHandled: unique symbol;
+        const NotMatched: unique symbol;
+        interface Route extends AnyRoute {
+        }
+        interface Context extends AnyContext<Route> {
+        }
+        type Handler<Params extends ParamsObject = {}, Meta = unknown> = HandlerLike<AnyRoute<Params, Meta, string>>;
+        function route<Params extends ParamsObject = {}, Meta = unknown>(handler: Handler<Params, Meta>): typeof handler;
+    }
+}
+export type { Fetch, HandlerLike, InputObject, Invoke, Match, NextFunction, PathTemplate, Route, Context, ContextExtensions, RouteHandler, RouteWithHandler, RuntimeModule, ValidateHref, ValidatePath, } 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
-};