@marko/run 0.1.4 → 0.1.6

package/dist/adapter/default-entry.mjs

@@ -5,6 +5,7 @@ import { createMiddleware } from "@marko/run/adapter/middleware";
 import { fetch } from "@marko/run/router";
 import { dirname } from 'path';
 import { fileURLToPath } from 'url';
+import zlib from 'zlib';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -12,6 +13,7 @@ const { PORT = 3456 } = process.env;
 
 const middleware = createMiddleware(fetch);
 const compress = compression({
+  flush: zlib.constants.Z_PARTIAL_FLUSH,
   threshold: 500,
 });
 const staticServe = createStaticServe(__dirname, {

package/dist/adapter/dev-entry.mjs

@@ -0,0 +1,36 @@
+import { createServer } from "vite";
+
+let activeDevServers;
+
+process
+  .on("message", (message) => {
+    switch (message.type) {
+      case "start":
+        return start(message.entry, message.config);
+      case "shutdown":
+        return shutdown();
+    }
+  })
+  .send("ready");
+
+async function start(entry, config) {
+  let changed = false;
+  const loader = await createServer(config);
+  ({ activeDevServers } = await loader.ssrLoadModule("@marko/run/adapter"));
+  await loader.ssrLoadModule(entry);
+
+  loader.watcher.on("change", (path) => {
+    if (!changed && loader.moduleGraph.getModulesByFile(path)) {
+      changed = true;
+      process.send("restart");
+    }
+  });
+}
+
+function shutdown() {
+  if (activeDevServers) {
+    for (const devServer of activeDevServers) {
+      devServer.ws.send({ type: "full-reload" });
+    }
+  }
+}

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

@@ -1,4 +1,6 @@
-import { ViteDevServer } from "vite";
+import { type InlineConfig, type ViteDevServer } from "vite";
 import type { NodeMiddleware } from "./middleware";
+export declare const activeDevServers: Set<ViteDevServer>;
 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>;
+export declare function createViteDevServer(config?: InlineConfig): Promise<ViteDevServer>;
+export declare function createDevServer(config?: InlineConfig): Promise<ViteDevServer>;

package/dist/adapter/index.cjs

@@ -26,8 +26,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/adapter/index.ts
 var adapter_exports = {};
 __export(adapter_exports, {
+  activeDevServers: () => activeDevServers,
   createDevServer: () => createDevServer,
   createViteDevMiddleware: () => createViteDevMiddleware,
+  createViteDevServer: () => createViteDevServer,
   default: () => adapter
 });
 module.exports = __toCommonJS(adapter_exports);
@@ -37,6 +39,7 @@ var import_url = require("url");
 // src/adapter/dev-server.ts
 var import_vite = require("vite");
 var import_strip_ansi = __toESM(require("strip-ansi"), 1);
+var activeDevServers = /* @__PURE__ */ new Set();
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;
@@ -59,12 +62,22 @@ function createViteDevMiddleware(devServer, load, factory) {
     }
   };
 }
-async function createDevServer(configFile) {
+async function createViteDevServer(config2) {
   const devServer = await (0, import_vite.createServer)({
-    configFile,
+    ...config2,
     appType: "custom",
     server: { middlewareMode: true }
   });
+  const originalClose = devServer.close;
+  devServer.close = () => {
+    activeDevServers.delete(devServer);
+    return originalClose.call(devServer);
+  };
+  activeDevServers.add(devServer);
+  return devServer;
+}
+async function createDevServer(config2) {
+  const devServer = await createViteDevServer(config2);
   const { createMiddleware } = await devServer.ssrLoadModule(
     "@marko/run/adapter/middleware"
   );
@@ -73,7 +86,8 @@ async function createDevServer(configFile) {
     async () => await devServer.ssrLoadModule("@marko/run/router"),
     (module2) => createMiddleware(module2.fetch, { devServer })
   );
-  return devServer.middlewares.use(middleware);
+  devServer.middlewares.use(middleware);
+  return devServer;
 }
 
 // src/vite/utils/server.ts
@@ -81,6 +95,7 @@ var import_net = __toESM(require("net"), 1);
 var import_child_process = __toESM(require("child_process"), 1);
 var import_dotenv = require("dotenv");
 var import_fs = __toESM(require("fs"), 1);
+var import_cluster = __toESM(require("cluster"), 1);
 async function parseEnv(envFile) {
   if (import_fs.default.existsSync(envFile)) {
     const content = await import_fs.default.promises.readFile(envFile, "utf8");
@@ -90,14 +105,14 @@ async function parseEnv(envFile) {
 function loadEnv(envFile) {
   (0, import_dotenv.config)({ path: envFile });
 }
-async function spawnServer(cmd, port = 0, env, cwd = process.cwd(), wait = 3e4) {
+async function spawnServer(cmd, args = [], 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, {
+  const proc = import_child_process.default.spawn(cmd, args, {
     cwd,
     shell: true,
     stdio: "inherit",
@@ -108,30 +123,67 @@ async function spawnServer(cmd, port = 0, env, cwd = process.cwd(), wait = 3e4)
     proc.unref();
     proc.kill();
   };
+  try {
+    await waitForServer(port, wait);
+  } catch (err) {
+    close();
+    throw err;
+  }
+  return {
+    port,
+    close
+  };
+}
+async function spawnServerWorker(module2, args = [], port = 0, env) {
+  if (port <= 0) {
+    port = await getAvailablePort();
+  }
+  if (typeof env === "string") {
+    env = await parseEnv(env);
+  }
+  const originalExec = import_cluster.default.settings.exec;
+  const originalArgs = import_cluster.default.settings.execArgv;
+  try {
+    import_cluster.default.settings.exec = module2;
+    import_cluster.default.settings.execArgv = args;
+    const worker = import_cluster.default.fork({ ...env, NODE_ENV: "development", ...process.env, PORT: `${port}` });
+    return new Promise((resolve) => {
+      function ready(message) {
+        if (message === "ready") {
+          worker.off("message", ready);
+          resolve(worker);
+        }
+      }
+      worker.on("message", ready);
+    });
+  } finally {
+    import_cluster.default.settings.exec = originalExec;
+    import_cluster.default.settings.execArgv = originalArgs;
+  }
+}
+async function waitForServer(port, wait = 0) {
   let remaining = wait > 0 ? wait : Infinity;
-  while (!await isPortInUse(port)) {
+  let connection;
+  while (!(connection = await getConnection(port))) {
     if (remaining >= 100) {
       remaining -= 100;
       await sleep(100);
     } else {
-      close();
       throw new Error(
         `site-write: timeout while wating for server to start on port "${port}".`
       );
     }
   }
-  return {
-    port,
-    close
-  };
+  return connection;
 }
-async function isPortInUse(port) {
+async function getConnection(port) {
   return new Promise((resolve) => {
-    const connection = import_net.default.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => done(false)).on("connect", () => done(true));
-    function done(connected) {
+    const connection = import_net.default.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => {
       connection.end();
-      resolve(connected);
-    }
+      resolve(null);
+    }).on("connect", () => {
+      resolve(connection);
+    });
   });
 }
 async function getAvailablePort() {
@@ -147,34 +199,97 @@ function sleep(ms) {
 }
 
 // src/adapter/index.ts
+var import_parse_node_args = __toESM(require("parse-node-args"), 1);
 var import_meta = {};
 var __dirname = (0, import_url.fileURLToPath)(new URL(".", import_meta.url));
+var defaultEntry = import_path.default.join(__dirname, "default-entry");
+var loadDevWorker = import_path.default.join(__dirname, "load-dev-worker.mjs");
 function adapter() {
   return {
     name: "base-adapter",
     async getEntryFile() {
-      const entry = import_path.default.join(__dirname, "default-entry");
-      return entry;
+      return defaultEntry;
     },
-    async startDev(configFile, port, envFile) {
+    async startDev(entry, config2, options) {
+      const { port = 3e3, envFile } = options;
+      if (entry) {
+        const { nodeArgs } = (0, import_parse_node_args.default)(options.args);
+        let worker;
+        async function start() {
+          const nextWorker = await spawnServerWorker(
+            loadDevWorker,
+            nodeArgs,
+            port,
+            envFile
+          );
+          nextWorker.on("message", (messsage) => {
+            if (messsage === "restart") {
+              start();
+            }
+          }).send({ type: "start", entry, config: config2 });
+          await waitForWorker(nextWorker, port);
+          if (worker) {
+            const prevWorker = worker;
+            let timeout;
+            worker.once("disconnect", () => {
+              clearTimeout(timeout);
+            });
+            worker.send({ type: "shutdown" });
+            worker.disconnect();
+            timeout = setTimeout(() => {
+              prevWorker.kill();
+            }, 2e3);
+          }
+          worker = nextWorker;
+        }
+        await start();
+        return {
+          port,
+          close() {
+            worker.kill();
+          }
+        };
+      }
+      const devServer = await createDevServer(config2);
       envFile && await loadEnv(envFile);
-      const server = await createDevServer(configFile);
       return new Promise((resolve) => {
-        const listener = server.listen(port, () => {
+        const listener = devServer.middlewares.listen(port, () => {
           const address = listener.address();
           console.log(`Dev server started: http://localhost:${address.port}`);
-          resolve();
+          resolve({
+            port,
+            async close() {
+              await devServer.close();
+            }
+          });
         });
       });
     },
-    async startPreview(_dir, entry, port, envFile) {
-      const server = await spawnServer(`node ${entry}`, port, envFile);
+    async startPreview(entry, options) {
+      const { port, envFile } = options;
+      const { nodeArgs } = (0, import_parse_node_args.default)(options.args);
+      const args = [...nodeArgs, entry];
+      const server = await spawnServer("node", args, port, envFile);
       console.log(`Preview server started: http://localhost:${server.port}`);
+      return server;
     }
   };
 }
+async function waitForWorker(worker, port) {
+  return new Promise((resolve) => {
+    function listening(address) {
+      if (address.port === port) {
+        worker.off("listening", listening);
+        resolve();
+      }
+    }
+    worker.on("listening", listening);
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  activeDevServers,
   createDevServer,
-  createViteDevMiddleware
+  createViteDevMiddleware,
+  createViteDevServer
 });

package/dist/adapter/index.d.ts

@@ -1,5 +1,6 @@
 import type { Adapter } from "../vite";
-export { createDevServer, createViteDevMiddleware } from "./dev-server";
-export type { Adapter };
-export type { NodePlatformInfo } from './middleware';
+import { type SpawnedServer } from "../vite/utils/server";
+export { activeDevServers, createDevServer, createViteDevServer, createViteDevMiddleware, } from "./dev-server";
+export type { Adapter, SpawnedServer };
+export type { NodePlatformInfo } from "./middleware";
 export default function adapter(): Adapter;

package/dist/adapter/index.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from "url";
 // src/adapter/dev-server.ts
 import { createServer } from "vite";
 import stripAnsi from "strip-ansi";
+var activeDevServers = /* @__PURE__ */ new Set();
 function createViteDevMiddleware(devServer, load, factory) {
   let value;
   let middleware;
@@ -27,12 +28,22 @@ function createViteDevMiddleware(devServer, load, factory) {
     }
   };
 }
-async function createDevServer(configFile) {
+async function createViteDevServer(config2) {
   const devServer = await createServer({
-    configFile,
+    ...config2,
     appType: "custom",
     server: { middlewareMode: true }
   });
+  const originalClose = devServer.close;
+  devServer.close = () => {
+    activeDevServers.delete(devServer);
+    return originalClose.call(devServer);
+  };
+  activeDevServers.add(devServer);
+  return devServer;
+}
+async function createDevServer(config2) {
+  const devServer = await createViteDevServer(config2);
   const { createMiddleware } = await devServer.ssrLoadModule(
     "@marko/run/adapter/middleware"
   );
@@ -41,7 +52,8 @@ async function createDevServer(configFile) {
     async () => await devServer.ssrLoadModule("@marko/run/router"),
     (module) => createMiddleware(module.fetch, { devServer })
   );
-  return devServer.middlewares.use(middleware);
+  devServer.middlewares.use(middleware);
+  return devServer;
 }
 
 // src/vite/utils/server.ts
@@ -49,6 +61,7 @@ import net from "net";
 import cp from "child_process";
 import { parse, config } from "dotenv";
 import fs from "fs";
+import cluster from "cluster";
 async function parseEnv(envFile) {
   if (fs.existsSync(envFile)) {
     const content = await fs.promises.readFile(envFile, "utf8");
@@ -58,14 +71,14 @@ async function parseEnv(envFile) {
 function loadEnv(envFile) {
   config({ path: envFile });
 }
-async function spawnServer(cmd, port = 0, env, cwd = process.cwd(), wait = 3e4) {
+async function spawnServer(cmd, args = [], 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, {
+  const proc = cp.spawn(cmd, args, {
     cwd,
     shell: true,
     stdio: "inherit",
@@ -76,30 +89,67 @@ async function spawnServer(cmd, port = 0, env, cwd = process.cwd(), wait = 3e4)
     proc.unref();
     proc.kill();
   };
+  try {
+    await waitForServer(port, wait);
+  } catch (err) {
+    close();
+    throw err;
+  }
+  return {
+    port,
+    close
+  };
+}
+async function spawnServerWorker(module, args = [], port = 0, env) {
+  if (port <= 0) {
+    port = await getAvailablePort();
+  }
+  if (typeof env === "string") {
+    env = await parseEnv(env);
+  }
+  const originalExec = cluster.settings.exec;
+  const originalArgs = cluster.settings.execArgv;
+  try {
+    cluster.settings.exec = module;
+    cluster.settings.execArgv = args;
+    const worker = cluster.fork({ ...env, NODE_ENV: "development", ...process.env, PORT: `${port}` });
+    return new Promise((resolve) => {
+      function ready(message) {
+        if (message === "ready") {
+          worker.off("message", ready);
+          resolve(worker);
+        }
+      }
+      worker.on("message", ready);
+    });
+  } finally {
+    cluster.settings.exec = originalExec;
+    cluster.settings.execArgv = originalArgs;
+  }
+}
+async function waitForServer(port, wait = 0) {
   let remaining = wait > 0 ? wait : Infinity;
-  while (!await isPortInUse(port)) {
+  let connection;
+  while (!(connection = await getConnection(port))) {
     if (remaining >= 100) {
       remaining -= 100;
       await sleep(100);
     } else {
-      close();
       throw new Error(
         `site-write: timeout while wating for server to start on port "${port}".`
       );
     }
   }
-  return {
-    port,
-    close
-  };
+  return connection;
 }
-async function isPortInUse(port) {
+async function getConnection(port) {
   return new Promise((resolve) => {
-    const connection = net.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => done(false)).on("connect", () => done(true));
-    function done(connected) {
+    const connection = net.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => {
       connection.end();
-      resolve(connected);
-    }
+      resolve(null);
+    }).on("connect", () => {
+      resolve(connection);
+    });
   });
 }
 async function getAvailablePort() {
@@ -115,33 +165,96 @@ function sleep(ms) {
 }
 
 // src/adapter/index.ts
+import parseNodeArgs from "parse-node-args";
 var __dirname = fileURLToPath(new URL(".", import.meta.url));
+var defaultEntry = path.join(__dirname, "default-entry");
+var loadDevWorker = path.join(__dirname, "load-dev-worker.mjs");
 function adapter() {
   return {
     name: "base-adapter",
     async getEntryFile() {
-      const entry = path.join(__dirname, "default-entry");
-      return entry;
+      return defaultEntry;
     },
-    async startDev(configFile, port, envFile) {
+    async startDev(entry, config2, options) {
+      const { port = 3e3, envFile } = options;
+      if (entry) {
+        const { nodeArgs } = parseNodeArgs(options.args);
+        let worker;
+        async function start() {
+          const nextWorker = await spawnServerWorker(
+            loadDevWorker,
+            nodeArgs,
+            port,
+            envFile
+          );
+          nextWorker.on("message", (messsage) => {
+            if (messsage === "restart") {
+              start();
+            }
+          }).send({ type: "start", entry, config: config2 });
+          await waitForWorker(nextWorker, port);
+          if (worker) {
+            const prevWorker = worker;
+            let timeout;
+            worker.once("disconnect", () => {
+              clearTimeout(timeout);
+            });
+            worker.send({ type: "shutdown" });
+            worker.disconnect();
+            timeout = setTimeout(() => {
+              prevWorker.kill();
+            }, 2e3);
+          }
+          worker = nextWorker;
+        }
+        await start();
+        return {
+          port,
+          close() {
+            worker.kill();
+          }
+        };
+      }
+      const devServer = await createDevServer(config2);
       envFile && await loadEnv(envFile);
-      const server = await createDevServer(configFile);
       return new Promise((resolve) => {
-        const listener = server.listen(port, () => {
+        const listener = devServer.middlewares.listen(port, () => {
           const address = listener.address();
           console.log(`Dev server started: http://localhost:${address.port}`);
-          resolve();
+          resolve({
+            port,
+            async close() {
+              await devServer.close();
+            }
+          });
         });
       });
     },
-    async startPreview(_dir, entry, port, envFile) {
-      const server = await spawnServer(`node ${entry}`, port, envFile);
+    async startPreview(entry, options) {
+      const { port, envFile } = options;
+      const { nodeArgs } = parseNodeArgs(options.args);
+      const args = [...nodeArgs, entry];
+      const server = await spawnServer("node", args, port, envFile);
       console.log(`Preview server started: http://localhost:${server.port}`);
+      return server;
     }
   };
 }
+async function waitForWorker(worker, port) {
+  return new Promise((resolve) => {
+    function listening(address) {
+      if (address.port === port) {
+        worker.off("listening", listening);
+        resolve();
+      }
+    }
+    worker.on("listening", listening);
+  });
+}
 export {
+  activeDevServers,
   createDevServer,
   createViteDevMiddleware,
+  createViteDevServer,
   adapter as default
 };

package/dist/adapter/load-dev-worker.mjs

@@ -0,0 +1,37 @@
+import { createServer } from "vite";
+
+let activeDevServers;
+
+process
+  .on("message", (message) => {
+    switch (message.type) {
+      case "start":
+        return start(message.entry, message.config);
+      case "shutdown":
+        return shutdown();
+    }
+  })
+  .send("ready");
+
+async function start(entry, config) {
+  let changed = false;
+  const loader = await createServer(config);
+  ({ activeDevServers } = await loader.ssrLoadModule("@marko/run/adapter"));
+  await loader.ssrLoadModule(entry);
+
+  loader.watcher.on("change", (path) => {
+    if (!changed && loader.moduleGraph.getModulesByFile(path)) {
+      changed = true;
+      process.send("restart");
+    }
+  });
+}
+
+function shutdown() {
+  if (activeDevServers) {
+    for (const devServer of activeDevServers) {
+      devServer.ws.send({ type: "full-reload" });
+    }
+    activeDevServers.clear();
+  }
+}