@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-VU3MYZPO.mjs

@@ -0,0 +1,432 @@
+// src/nitro/node-server-entry.ts
+var FARM_NODE_ENV_MODULE_FILE = "farm-node-env.mjs";
+var FARM_NODE_ENV_MODULE_SOURCE = `if (!process.env.NODE_ENV) process.env.NODE_ENV = "production";
+`;
+var FARM_DESKTOP_ENV_MODULE_FILE = "farm-desktop-env.mjs";
+var FARM_DESKTOP_ENV_MODULE_SOURCE = `process.env.FARM_PLATFORM = "desktop";
+${FARM_NODE_ENV_MODULE_SOURCE}`;
+var FARM_DESKTOP_READY_PREFIX = "farm:ready ";
+var nodeServerSource = (desktop) => `const socketPath = process.env.NITRO_UNIX_SOCKET;
+const server = serve({
+  manual: true,
+  silent: true,
+  gracefulShutdown: false,
+  port,
+  hostname: host,
+  node: socketPath ? { path: socketPath } : undefined,
+  tls: cert && key ? { cert, key } : undefined,
+  fetch: ${desktop ? "(request) => farmDesktopGuard(request) ?? nitroApp.fetch(request)" : "nitroApp.fetch"},
+  plugins: [...tracingSrvxPlugins],
+});
+const nodeServer = server.node?.server;
+if (!nodeServer) throw new Error("[Farm] Nitro did not create a Node server");
+
+nodeServer.headersTimeout = farmServerConfig.headersTimeout;
+nodeServer.requestTimeout = farmServerConfig.requestTimeout;
+nodeServer.keepAliveTimeout = farmServerConfig.keepAliveTimeout;
+
+let isShuttingDown = false;
+nodeServer.on("request", (_request, response) => {
+  response.once("finish", () => {
+    if (isShuttingDown) nodeServer.closeIdleConnections?.();
+  });
+});
+
+if (import.meta._websocket) {
+  const { handleUpgrade } = wsAdapter({ resolve: resolveWebsocketHooks });
+  nodeServer.on("upgrade", (request, socket, head) => {${desktop ? `
+    const blocked = farmDesktopGuard({
+      method: request.method || "GET",
+      url: request.url || "/",
+      headers: { get: (name) => [request.headers[name]].flat()[0] ?? null },
+    });
+    if (blocked) {
+      socket.end("HTTP/1.1 403 Forbidden\\r\\nConnection: close\\r\\nContent-Length: 0\\r\\n\\r\\n");
+      return;
+    }` : ""}
+    handleUpgrade(
+      request,
+      socket,
+      head,
+      new NodeRequest({ req: request, upgrade: { socket, head } }),
+    );
+  });
+}
+`;
+var bunServerSource = (desktop) => `const ws = import.meta._websocket ? wsAdapter({ resolve: resolveWebsocketHooks }) : undefined;
+const server = serve({
+  manual: true,
+  silent: true,
+  gracefulShutdown: false,
+  port,
+  hostname: host,
+  tls: cert && key ? { cert, key } : undefined,
+  fetch: ${desktop ? `(request) =>
+    farmDesktopGuard(request) ??
+    (import.meta._websocket && request.headers.get("upgrade") === "websocket"
+      ? ws.handleUpgrade(request, request.runtime.bun.server)
+      : nitroApp.fetch(request))` : `import.meta._websocket
+    ? (request) =>
+        request.headers.get("upgrade") === "websocket"
+          ? ws.handleUpgrade(request, request.runtime.bun.server)
+          : nitroApp.fetch(request)
+    : nitroApp.fetch`},
+  bun: { websocket: import.meta._websocket ? ws?.websocket : undefined },
+  plugins: [...tracingSrvxPlugins],
+});
+
+let isShuttingDown = false;
+`;
+function createFarmNodeServerEntry(options) {
+  return createFarmServerEntry({
+    ...options,
+    runtime: "node",
+    adapterModule: options.nodeAdapterModule
+  });
+}
+function createFarmBunServerEntry(options) {
+  return createFarmServerEntry({
+    ...options,
+    runtime: "bun",
+    adapterModule: options.bunAdapterModule
+  });
+}
+function createFarmServerEntry(options) {
+  const serverConfig = JSON.stringify(options.server);
+  const nitroEntryImport = `./${options.nitroEntryFile.replace(/^\.\//, "")}`;
+  const node = options.runtime === "node";
+  const desktop = options.desktop;
+  const envModule = desktop ? `import "./${FARM_DESKTOP_ENV_MODULE_FILE}";
+` : node ? `import "./${FARM_NODE_ENV_MODULE_FILE}";
+` : "";
+  return `
+${envModule}import "#nitro/virtual/polyfills";
+import { ${node ? "NodeRequest, " : ""}serve } from ${JSON.stringify(options.adapterModule)};
+import wsAdapter from ${JSON.stringify(options.websocketAdapterModule)};
+import { resolveWebsocketHooks, useNitroApp, useNitroHooks } from "#nitro/runtime/app";
+import { useRuntimeConfig } from "#nitro/runtime/runtime-config";
+import { trapUnhandledErrors } from "#nitro/runtime/error/hooks";
+import { setupCloseHooks } from "#nitro/runtime/shutdown";
+import { startScheduleRunner } from "#nitro/runtime/task";
+import { tracingSrvxPlugins } from "#nitro/virtual/tracing";
+import { farmProductionLifecycle } from ${JSON.stringify(nitroEntryImport)};${desktop ? `
+import { realpathSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { createFarmDesktopGuard } from ${JSON.stringify(desktop.guardModule)};
+${DESKTOP_START_SOURCE}
+async function startFarmDesktopServer(options) {
+let farmDesktopBoundPort;
+const farmDesktopGuard = createFarmDesktopGuard({
+  secret: options.secret,
+  handshakeToken: options.handshakeToken,
+  basePath: ${JSON.stringify(desktop.basePath)},
+  port: () => farmDesktopBoundPort,
+});
+if (typeof options.dataDir !== "string" || !options.dataDir) {
+  throw new TypeError("[Farm] start() needs dataDir, the directory appDataDir() returns.");
+}
+process.env.FARM_DESKTOP_DATA_DIR = options.dataDir;` : ""}
+
+const farmServerConfig = ${serverConfig};
+if (!process.env.NITRO_SHUTDOWN_TIMEOUT) {
+  process.env.NITRO_SHUTDOWN_TIMEOUT = String(farmServerConfig.gracefulShutdownTimeout);
+}
+const shutdownConfig = {
+  disabled: Boolean(process.env.NITRO_SHUTDOWN_DISABLED),
+  signals: (process.env.NITRO_SHUTDOWN_SIGNALS || "SIGTERM SIGINT")
+    .split(" ")
+    .map((signal) => signal.trim())
+    .filter(Boolean),
+  timeout: Number.parseInt(process.env.NITRO_SHUTDOWN_TIMEOUT || "", 10) || 30000,
+  forceExit: !process.env.NITRO_SHUTDOWN_NO_FORCE_EXIT,
+};
+
+const nitroApp = useNitroApp();
+useNitroHooks().hook("close", async () => {
+  try {
+    await farmProductionLifecycle.close("production-server-closed");
+  } catch (error) {
+    process.exitCode = 1;
+    throw error;
+  }
+});
+
+let startupSignal;
+let resolveStartupSignal;
+const startupSignalPromise = new Promise((resolve) => {
+  resolveStartupSignal = resolve;
+});
+const startupSignalListeners = new Map();
+if (!shutdownConfig.disabled) {
+  for (const signal of shutdownConfig.signals) {
+    const listener = (receivedSignal) => {
+      if (!startupSignal) {
+        startupSignal = receivedSignal;
+        resolveStartupSignal(receivedSignal);
+      }
+      farmProductionLifecycle.beginDrain(receivedSignal);
+    };
+    startupSignalListeners.set(signal, listener);
+    process.once(signal, listener);
+  }
+}
+
+try {
+  await Promise.race([
+    Promise.resolve().then(() => farmProductionLifecycle.start()),
+    startupSignalPromise,
+  ]);
+} catch (error) {
+  await farmProductionLifecycle.close("production-start-failed").catch((closeError) => {
+    console.error("[Farm] Runtime cleanup after startup failure failed:", closeError);
+  });
+  throw error;
+} finally {
+  for (const [signal, listener] of startupSignalListeners) {
+    process.removeListener(signal, listener);
+  }
+}
+
+if (startupSignal) {
+  let startupCloseTimer;
+  const startupCloseCompleted = await Promise.race([
+    Promise.resolve()
+      .then(() => farmProductionLifecycle.close(startupSignal))
+      .then(
+        () => true,
+        (error) => {
+          console.error("[Farm] Runtime shutdown during startup failed:", error);
+          process.exitCode = 1;
+          return true;
+        },
+      ),
+    new Promise((resolve) => {
+      startupCloseTimer = setTimeout(() => resolve(false), farmServerConfig.gracefulShutdownTimeout);
+    }),
+  ]);
+  clearTimeout(startupCloseTimer);
+  if (!startupCloseCompleted) {
+    console.warn("[Farm] Runtime startup did not settle before shutdown; forcing cleanup");
+    let forcedCloseTimer;
+    const forcedCloseCompleted = await Promise.race([
+      Promise.resolve()
+        .then(() => farmProductionLifecycle.forceClose(startupSignal))
+        .then(
+          () => true,
+          (error) => {
+            console.error("[Farm] Forced runtime shutdown during startup failed:", error);
+            process.exitCode = 1;
+            return true;
+          },
+        ),
+      new Promise((resolve) => {
+        forcedCloseTimer = setTimeout(
+          () => resolve(false),
+          farmServerConfig.gracefulShutdownTimeout,
+        );
+      }),
+    ]);
+    clearTimeout(forcedCloseTimer);
+    if (!forcedCloseCompleted) {
+      console.error("[Farm] Forced runtime shutdown during startup timed out");
+      process.exitCode = 1;
+    }
+  }
+  process.exit(process.exitCode || 0);
+}
+
+${desktop ? `// The shell picks the address. HOST and PORT from the user's environment never apply.
+const cert = undefined;
+const key = undefined;
+const port = options.port ?? 0;
+if (!Number.isInteger(port) || port < 0 || port > 65535) {
+  throw new TypeError("[Farm] start() port must be an integer from 0 to 65535.");
+}
+const host = options.host || "127.0.0.1";` : `const cert = process.env.NITRO_SSL_CERT;
+const key = process.env.NITRO_SSL_KEY;
+const configuredPort = Number(process.env.NITRO_PORT || process.env.PORT);
+const port = Number.isFinite(configuredPort) && configuredPort > 0 ? configuredPort : 3000;
+const host = process.env.NITRO_HOST || process.env.HOST;`}
+${node ? nodeServerSource(Boolean(desktop)) : bunServerSource(Boolean(desktop))}
+setupCloseHooks(server);
+trapUnhandledErrors();
+
+let shutdownPromise;
+async function shutdown(signal${desktop ? ", exitProcess = true" : ""}) {
+  isShuttingDown = true;
+  farmProductionLifecycle.beginDrain(signal);
+
+  const gracefulClose = server.close().then(
+    () => true,
+    (error) => {
+      console.error("[Farm] Runtime shutdown failed:", error);
+      process.exitCode = 1;
+      return true;
+    },
+  );
+  ${node ? "nodeServer.closeIdleConnections?.();" : ""}
+  let gracefulTimer;
+  const gracefullyClosed = await Promise.race([
+    gracefulClose,
+    new Promise((resolve) => {
+      gracefulTimer = setTimeout(() => resolve(false), shutdownConfig.timeout);
+    }),
+  ]);
+  clearTimeout(gracefulTimer);
+
+  if (!gracefullyClosed) {
+    console.warn("[Farm] Graceful shutdown timed out; forcing cleanup");
+    void server.close(true).catch((error) => {
+      console.error("[Farm] Forced server shutdown failed:", error);
+      process.exitCode = 1;
+    });
+
+    let forceTimer;
+    const forceClosed = await Promise.race([
+      Promise.resolve()
+        .then(() => farmProductionLifecycle.forceClose("production-server-closed"))
+        .then(
+          () => true,
+          (error) => {
+            console.error("[Farm] Forced runtime shutdown failed:", error);
+            process.exitCode = 1;
+            return true;
+          },
+        ),
+      new Promise((resolve) => {
+        forceTimer = setTimeout(() => resolve(false), shutdownConfig.timeout);
+      }),
+    ]);
+    clearTimeout(forceTimer);
+    if (!forceClosed) {
+      console.error("[Farm] Forced runtime shutdown timed out");
+      process.exitCode = 1;
+    }
+  }
+
+  if (shutdownConfig.forceExit${desktop ? " && exitProcess" : ""}) process.exit(process.exitCode || 0);
+}
+
+if (!shutdownConfig.disabled) {
+  for (const signal of shutdownConfig.signals) {
+    process.once(signal, (receivedSignal) => {
+      shutdownPromise ||= shutdown(receivedSignal);
+    });
+  }
+}
+
+try {
+  await server.serve();
+  const protocol = cert && key ? "https" : "http";
+  const addressInfo = ${node ? "nodeServer.address()" : "server.bun.server?.address"};${desktop ? `
+  farmDesktopBoundPort = ${node ? "addressInfo?.port" : "server.bun.server?.port"};` : ""}
+  if (typeof addressInfo === "string") {
+    console.log(\`Listening on unix socket \${addressInfo}\`);
+  } else if (addressInfo) {
+    const configuredBaseURL = useRuntimeConfig().app.baseURL || "";
+    const baseURL = configuredBaseURL.endsWith("/")
+      ? configuredBaseURL.slice(0, -1)
+      : configuredBaseURL;
+    const address = addressInfo.family === "IPv6"
+      ? \`[\${addressInfo.address}]\`
+      : addressInfo.address;
+    console.log(\`Listening on \${protocol}://\${address}:\${addressInfo.port}\${baseURL}\`);
+  }
+} catch (error) {
+  console.error(error);
+  process.exitCode = 1;
+  await farmProductionLifecycle.close("production-listen-error").catch((closeError) => {
+    console.error("[Farm] Runtime cleanup after listen failure failed:", closeError);
+  });
+  throw error;
+}
+
+if (import.meta._tasks) {
+  startScheduleRunner({ waitUntil: server.waitUntil });
+}
+${desktop ? `
+const farmDesktopHost = host.includes(":") ? \`[\${host}]\` : host;
+return {
+  origin: \`http://\${farmDesktopHost}:\${farmDesktopBoundPort}\`,
+  port: farmDesktopBoundPort,
+  stop: () => (shutdownPromise ||= shutdown("stop", false)),
+};
+}
+
+${DESKTOP_MAIN_SOURCE}
+` : ""}
+export default {};
+  `.trim();
+}
+var DESKTOP_START_SOURCE = `let farmDesktopServer;
+export function start(options = {}) {
+  farmDesktopServer ||= startFarmDesktopServer(options);
+  return farmDesktopServer;
+}`;
+var DESKTOP_MAIN_SOURCE = `function isFarmDesktopMainModule() {
+  if (typeof import.meta.main === "boolean") return import.meta.main;
+  try {
+    return Boolean(process.argv[1]) && pathToFileURL(realpathSync(process.argv[1])).href === import.meta.url;
+  } catch {
+    return false;
+  }
+}
+
+if (isFarmDesktopMainModule()) {
+  const env = process.env;
+  const server = await start({
+    secret: env.FARM_DESKTOP_SECRET,
+    handshakeToken: env.FARM_DESKTOP_HANDSHAKE_TOKEN,
+    dataDir: env.FARM_DESKTOP_DATA_DIR,
+    port: env.FARM_DESKTOP_PORT ? Number(env.FARM_DESKTOP_PORT) : 0,
+    host: env.FARM_DESKTOP_HOST,
+  });
+  // Child processes the app spawns must not inherit the session secret.
+  delete env.FARM_DESKTOP_SECRET;
+  delete env.FARM_DESKTOP_HANDSHAKE_TOKEN;
+  console.log(${JSON.stringify(FARM_DESKTOP_READY_PREFIX)} + JSON.stringify({ port: server.port }));
+}`;
+
+// src/build/production-node-env.ts
+var productionNodeEnvStateKey = /* @__PURE__ */ Symbol.for("@farm.js/core/production-node-env-state");
+function getProductionNodeEnvState() {
+  return Reflect.get(globalThis, productionNodeEnvStateKey);
+}
+async function withProductionNodeEnv(operation) {
+  let state = getProductionNodeEnvState();
+  if (state) {
+    state.depth += 1;
+  } else {
+    state = {
+      depth: 1,
+      original: process.env.NODE_ENV
+    };
+    Reflect.set(globalThis, productionNodeEnvStateKey, state);
+  }
+  process.env.NODE_ENV = "production";
+  try {
+    return await operation();
+  } finally {
+    state.depth -= 1;
+    if (state.depth > 0) {
+      process.env.NODE_ENV = "production";
+    } else {
+      Reflect.deleteProperty(globalThis, productionNodeEnvStateKey);
+      if (state.original === void 0) {
+        delete process.env.NODE_ENV;
+      } else {
+        process.env.NODE_ENV = state.original;
+      }
+    }
+  }
+}
+
+export {
+  FARM_NODE_ENV_MODULE_FILE,
+  FARM_NODE_ENV_MODULE_SOURCE,
+  FARM_DESKTOP_ENV_MODULE_FILE,
+  FARM_DESKTOP_ENV_MODULE_SOURCE,
+  createFarmNodeServerEntry,
+  createFarmBunServerEntry,
+  withProductionNodeEnv
+};

package/dist/chunk-VXCFJWK5.cjs

@@ -0,0 +1,59 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/environment.ts
+var FarmEnvironmentError = class extends Error {
+  constructor(api, expected, actual) {
+    super(`${api}() can only be called on the ${expected}. It was called on the ${actual}.`);
+    this.api = api;
+    this.expected = expected;
+    this.actual = actual;
+    this.code = "FARM_ENVIRONMENT_MISMATCH";
+    this.name = "FarmEnvironmentError";
+  }
+};
+function createServerOnlyFn(implementation, compiledActualEnvironment) {
+  if (compiledActualEnvironment) {
+    return createMismatchFunction("createServerOnlyFn", "server", compiledActualEnvironment);
+  }
+  if (getRuntimeEnvironment() !== "server") {
+    return createMismatchFunction("createServerOnlyFn", "server");
+  }
+  assertFunction(implementation, "createServerOnlyFn");
+  return implementation;
+}
+function createClientOnlyFn(implementation, compiledActualEnvironment) {
+  if (compiledActualEnvironment) {
+    return createMismatchFunction("createClientOnlyFn", "client", compiledActualEnvironment);
+  }
+  if (getRuntimeEnvironment() !== "client") {
+    return createMismatchFunction("createClientOnlyFn", "client");
+  }
+  assertFunction(implementation, "createClientOnlyFn");
+  return implementation;
+}
+function createIsomorphicFn(options) {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("createIsomorphicFn requires server and client functions");
+  }
+  assertFunction(options.server, "createIsomorphicFn server");
+  assertFunction(options.client, "createIsomorphicFn client");
+  return getRuntimeEnvironment() === "server" ? options.server : options.client;
+}
+function getRuntimeEnvironment() {
+  return typeof window === "undefined" ? "server" : "client";
+}
+function createMismatchFunction(api, expected, actual = expected === "server" ? "client" : "server") {
+  return function farmEnvironmentBoundary() {
+    throw new FarmEnvironmentError(api, expected, actual);
+  };
+}
+function assertFunction(value, label) {
+  if (typeof value !== "function") {
+    throw new TypeError(`${label} must be a function`);
+  }
+}
+
+
+
+
+
+
+exports.FarmEnvironmentError = FarmEnvironmentError; exports.createServerOnlyFn = createServerOnlyFn; exports.createClientOnlyFn = createClientOnlyFn; exports.createIsomorphicFn = createIsomorphicFn;