@marko/run 0.0.1-beta1 → 0.0.1-beta3

package/dist/adapter/default-entry.mjs

@@ -1,12 +1,16 @@
 import createStaticServe from "serve-static";
+import compression from "compression";
 import { createServer } from "http";
-import { createMiddleware } from "@hattip/adapter-node";
-import { handler } from "@marko/run";
+import createMiddleware from "@marko/run/adapter/middleware";
+import { router } from "@marko/run/router";
 
 const { PORT = 3456 } = process.env;
 
 const dir = process.cwd();
-const middleware = createMiddleware(handler);
+const middleware = createMiddleware(router);
+const compress = compression({
+  threshold: 500,
+});
 const staticServe = createStaticServe(dir, {
   index: false,
   immutable: true,
@@ -14,5 +18,7 @@ const staticServe = createStaticServe(dir, {
 });
 
 createServer((req, res) =>
+  compress(req, res, () => 
   staticServe(req, res, () => middleware(req, res))
+  )
 ).listen(PORT);

package/dist/adapter/dev-server.d.ts

@@ -1,4 +1,4 @@
 import { ViteDevServer } from "vite";
-import { type NodeMiddleware } from "@hattip/adapter-node";
+import { type NodeMiddleware } from "@marko/run/adapter/middleware";
 export declare function createViteDevMiddleware<T>(devServer: ViteDevServer, load: (prev: T | undefined) => Promise<T>, factory: (value: T) => NodeMiddleware): NodeMiddleware;
 export declare function createDevServer(configFile?: string): Promise<import("vite").Connect.Server>;

package/dist/adapter/index.cjs

@@ -36,7 +36,7 @@ var import_url = require("url");
 
 // src/adapter/dev-server.ts
 var import_vite = require("vite");
-var import_adapter_node = require("@hattip/adapter-node");
+var import_middleware = __toESM(require("@marko/run/adapter/middleware"), 1);
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;
@@ -64,8 +64,8 @@ async function createDevServer(configFile) {
   });
   const middleware = createViteDevMiddleware(
     devServer,
-    async () => (await devServer.ssrLoadModule("@marko/run")).handler,
-    import_adapter_node.createMiddleware
+    async () => (await devServer.ssrLoadModule("@marko/run/router")).router,
+    import_middleware.default
   );
   return devServer.middlewares.use(middleware);
 }
@@ -73,16 +73,30 @@ async function createDevServer(configFile) {
 // src/vite/utils/server.ts
 var import_net = __toESM(require("net"), 1);
 var import_child_process = __toESM(require("child_process"), 1);
-async function spawnServer(cmd, port = 0, cwd = process.cwd(), wait = 3e4) {
+var import_dotenv = require("dotenv");
+var import_fs = __toESM(require("fs"), 1);
+async function parseEnv(envFile) {
+  if (import_fs.default.existsSync(envFile)) {
+    const content = await import_fs.default.promises.readFile(envFile, "utf8");
+    return (0, import_dotenv.parse)(content);
+  }
+}
+function loadEnv(envFile) {
+  (0, import_dotenv.config)({ path: envFile });
+}
+async function spawnServer(cmd, port = 0, env, cwd = process.cwd(), wait = 3e4) {
   if (port <= 0) {
     port = await getAvailablePort();
   }
+  if (typeof env === "string") {
+    env = await parseEnv(env);
+  }
   const proc = import_child_process.default.spawn(cmd, {
     cwd,
     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();
@@ -136,7 +150,8 @@ function adapter() {
       const entry = import_path.default.join(__dirname, "default-entry");
       return entry;
     },
-    async startDev(configFile, port) {
+    async startDev(configFile, port, envFile) {
+      envFile && await loadEnv(envFile);
       const server = await createDevServer(configFile);
       return new Promise((resolve) => {
         const listener = server.listen(port, () => {
@@ -146,8 +161,8 @@ function adapter() {
         });
       });
     },
-    async startPreview(dir, entry, port) {
-      const server = await spawnServer(`node ${entry}`, port, dir);
+    async startPreview(dir, entry, port, envFile) {
+      const server = await spawnServer(`node ${entry}`, port, envFile, dir);
       console.log(`Preview server started: http://localhost:${server.port}`);
     }
   };

package/dist/adapter/index.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from "url";
 
 // src/adapter/dev-server.ts
 import { createServer } from "vite";
-import { createMiddleware } from "@hattip/adapter-node";
+import createMiddleware from "@marko/run/adapter/middleware";
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;
@@ -32,7 +32,7 @@ async function createDevServer(configFile) {
   });
   const middleware = createViteDevMiddleware(
     devServer,
-    async () => (await devServer.ssrLoadModule("@marko/run")).handler,
+    async () => (await devServer.ssrLoadModule("@marko/run/router")).router,
     createMiddleware
   );
   return devServer.middlewares.use(middleware);
@@ -41,16 +41,30 @@ async function createDevServer(configFile) {
 // src/vite/utils/server.ts
 import net from "net";
 import cp from "child_process";
-async function spawnServer(cmd, port = 0, cwd = 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);
+  }
+}
+function loadEnv(envFile) {
+  config({ path: envFile });
+}
+async function spawnServer(cmd, port = 0, env, cwd = process.cwd(), wait = 3e4) {
   if (port <= 0) {
     port = await getAvailablePort();
   }
+  if (typeof env === "string") {
+    env = await parseEnv(env);
+  }
   const proc = cp.spawn(cmd, {
     cwd,
     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();
@@ -103,7 +117,8 @@ function adapter() {
       const entry = path.join(__dirname, "default-entry");
       return entry;
     },
-    async startDev(configFile, port) {
+    async startDev(configFile, port, envFile) {
+      envFile && await loadEnv(envFile);
       const server = await createDevServer(configFile);
       return new Promise((resolve) => {
         const listener = server.listen(port, () => {
@@ -113,8 +128,8 @@ function adapter() {
         });
       });
     },
-    async startPreview(dir, entry, port) {
-      const server = await spawnServer(`node ${entry}`, port, dir);
+    async startPreview(dir, entry, port, envFile) {
+      const server = await spawnServer(`node ${entry}`, port, envFile, dir);
       console.log(`Preview server started: http://localhost:${server.port}`);
     }
   };

package/dist/adapter/middleware.cjs

@@ -0,0 +1,200 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapter/middleware.ts
+var middleware_exports = {};
+__export(middleware_exports, {
+  default: () => createMiddleware,
+  getOrigin: () => getOrigin
+});
+module.exports = __toCommonJS(middleware_exports);
+var webStream = __toESM(require("stream/web"), 1);
+var import_crypto = __toESM(require("@hattip/polyfills/crypto"), 1);
+(0, import_crypto.default)();
+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 platform = {
+      ip,
+      request: req,
+      response: res,
+      setCookie(cookie) {
+        res.appendHeader("set-cookie", cookie);
+      }
+    };
+    const context = {
+      method: req.method,
+      url,
+      platform
+    };
+    Object.defineProperty(context, "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(context);
+    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);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getOrigin
+});

package/dist/adapter/middleware.d.ts

@@ -0,0 +1,59 @@
+import type { Router } from "@marko/run";
+import type { IncomingMessage, ServerResponse } from "http";
+declare module "net" {
+    interface Socket {
+        encrypted?: boolean;
+    }
+}
+declare module "http" {
+    interface IncomingMessage {
+        ip?: string;
+        protocol?: string;
+    }
+    interface ServerResponse {
+        appendHeader(key: string, value: string | string[]): this;
+    }
+}
+declare module "@marko/run" {
+    interface Platform extends NodePlatformInfo {
+    }
+}
+export interface NodePlatformInfo {
+    ip: string;
+    request: IncomingMessage;
+    response: ServerResponse;
+    setCookie(cookie: string): void;
+}
+/** Connect/Express style request listener/middleware */
+export declare type NodeMiddleware = (req: IncomingMessage, res: ServerResponse & {
+    flush?: () => void;
+}, next?: () => void) => void;
+/** Adapter options */
+export interface NodeAdapterOptions {
+    /**
+     * Set the origin part of the URL to a constant value.
+     * It defaults to `process.env.ORIGIN`. If neither is set,
+     * the origin is computed from the protocol and hostname.
+     * To determine the protocol, `req.protocol` is tried first.
+     * If `trustProxy` is set, `X-Forwarded-Proto` header is used.
+     * Otherwise, `req.socket.encrypted` is used.
+     * To determine the hostname, `X-Forwarded-Host`
+     * (if `trustProxy` is set) or `Host` header is used.
+     */
+    origin?: string;
+    /**
+     * Whether to trust `X-Forwarded-*` headers. `X-Forwarded-Proto`
+     * and `X-Forwarded-Host` are used to determine the origin when
+     * `origin` and `process.env.ORIGIN` are not set. `X-Forwarded-For`
+     * is used to determine the IP address. The leftmost values are used
+     * if multiple values are set. Defaults to true if `process.env.TRUST_PROXY`
+     * is set to `1`, otherwise false.
+     */
+    trustProxy?: boolean;
+}
+export declare function getOrigin(req: IncomingMessage, protocol?: string, host?: string, trustProxy?: boolean): string;
+/**
+ * Creates a request handler to be passed to http.createServer() or used as a
+ * middleware in Connect-style frameworks like Express.
+ */
+export default function createMiddleware(router: Router<NodePlatformInfo>, options?: NodeAdapterOptions): NodeMiddleware;

package/dist/adapter/middleware.js

@@ -0,0 +1,169 @@
+// 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 platform = {
+      ip,
+      request: req,
+      response: res,
+      setCookie(cookie) {
+        res.appendHeader("set-cookie", cookie);
+      }
+    };
+    const context = {
+      method: req.method,
+      url,
+      platform
+    };
+    Object.defineProperty(context, "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(context);
+    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);
+      }
+    }
+  };
+}
+export {
+  createMiddleware as default,
+  getOrigin
+};

package/dist/cli/default.config.mjs

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