alinea/dist/cli/serve/StartServer.js

Headless git-based CMS

import "../../chunks/chunk-NZLE2WMY.js";

// src/cli/serve/StartServer.ts
import http from "node:http";
import { fromNodeRequest, respondTo } from "alinea/backend/router/NodeHandler";
import { createEmitter } from "../util/Emitter.js";
import { reportWarning } from "../util/Report.js";
async function startBunServer(port = 4500, attempt = 0, silent = false) {
  const messages = createEmitter();
  try {
    const server = Bun.serve({
      port,
      fetch(request) {
        const { resolve, promise } = Promise.withResolvers();
        messages.emit({
          request,
          async respondWith(response) {
            resolve(response);
          }
        });
        return promise;
      }
    });
    return {
      port,
      close() {
        server.stop();
      },
      async *serve(abortController) {
        if (abortController)
          abortController.signal.addEventListener(
            "abort",
            () => messages.return(),
            true
          );
        yield* messages;
      }
    };
  } catch (err) {
    if (attempt > 10) throw err;
    const incrementedPort = port + 1;
    if (err.code === "EADDRINUSE" && incrementedPort < 65535) {
      if (!silent)
        reportWarning(
          `Port ${port} is in use, attempting ${incrementedPort} instead`
        );
      return startBunServer(incrementedPort, attempt++, silent);
    }
    throw err;
  }
}
async function startNodeServer(port = 4500, attempt = 0, silent = false) {
  const messages = createEmitter();
  function serve(incoming, outgoing) {
    messages.emit({
      request: fromNodeRequest(incoming),
      respondWith(response) {
        return respondTo(outgoing, response);
      }
    });
  }
  return new Promise((resolve, reject) => {
    const server = http.createServer(serve);
    server.on("error", reject);
    server.on("listening", () => resolve(server));
    server.on("close", () => messages.return());
    server.listen(port);
  }).then((server) => {
    return {
      port,
      close() {
        server.close();
      },
      async *serve(abortController) {
        if (abortController)
          abortController.signal.addEventListener(
            "abort",
            () => messages.return(),
            true
          );
        yield* messages;
      }
    };
  }).catch((err) => {
    if (attempt > 10) throw err;
    const incrementedPort = port + 1;
    if (err.code === "EADDRINUSE" && incrementedPort < 65535) {
      if (!silent)
        reportWarning(
          `Port ${port} is in use, attempting ${incrementedPort} instead`
        );
      return startNodeServer(incrementedPort, attempt++, silent);
    }
    throw err;
  });
}
var startServer = "Bun" in globalThis ? startBunServer : startNodeServer;
export {
  startServer
};