@farm.js/core 0.1.37 → 0.1.39

package/dist/chunk-WW46B6HA.cjs

@@ -0,0 +1,318 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// 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";
+`;
+function createFarmNodeServerEntry(options) {
+  const serverConfig = JSON.stringify(options.server);
+  const nitroEntryImport = `./${options.nitroEntryFile.replace(/^\.\//, "")}`;
+  return `
+import "./${FARM_NODE_ENV_MODULE_FILE}";
+import "#nitro/virtual/polyfills";
+import { NodeRequest, serve } from ${JSON.stringify(options.nodeAdapterModule)};
+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)};
+
+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);
+}
+
+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;
+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: 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) => {
+    handleUpgrade(
+      request,
+      socket,
+      head,
+      new NodeRequest({ req: request, upgrade: { socket, head } }),
+    );
+  });
+}
+
+setupCloseHooks(server);
+trapUnhandledErrors();
+
+let shutdownPromise;
+async function shutdown(signal) {
+  isShuttingDown = true;
+  farmProductionLifecycle.beginDrain(signal);
+
+  const gracefulClose = server.close().then(
+    () => true,
+    (error) => {
+      console.error("[Farm] Runtime shutdown failed:", error);
+      process.exitCode = 1;
+      return true;
+    },
+  );
+  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) 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 = nodeServer.address();
+  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 });
+}
+
+export default {};
+  `.trim();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmNodeServerEntry, "createFarmNodeServerEntry");
+
+// 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);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getProductionNodeEnvState, "getProductionNodeEnvState");
+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;
+      }
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, withProductionNodeEnv, "withProductionNodeEnv");
+
+
+
+
+
+
+exports.FARM_NODE_ENV_MODULE_FILE = FARM_NODE_ENV_MODULE_FILE; exports.FARM_NODE_ENV_MODULE_SOURCE = FARM_NODE_ENV_MODULE_SOURCE; exports.createFarmNodeServerEntry = createFarmNodeServerEntry; exports.withProductionNodeEnv = withProductionNodeEnv;

package/dist/{chunk-D3C5LBQY.cjs → chunk-WXJLNP33.cjs}

@@ -6,7 +6,7 @@ var _chunkJ63ZH5OQcjs = require('./chunk-J63ZH5OQ.cjs');
 var _chunkE3UK5IIBcjs = require('./chunk-E3UK5IIB.cjs');
 
 
-var _chunkNICDYKBScjs = require('./chunk-NICDYKBS.cjs');
+var _chunk6XWDE2P2cjs = require('./chunk-6XWDE2P2.cjs');
 
 
 var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
@@ -299,7 +299,7 @@ function farmInfraAnalyticsPlugin(options, send) {
         context.state.unsubscribe = _chunkE3UK5IIBcjs.onFarmEvent.call(void 0, 
           (event) => {
             if (!isToolEvent(event)) return;
-            const request = _chunkNICDYKBScjs.getCurrentRequestOrNull.call(void 0, );
+            const request = _chunk6XWDE2P2cjs.getCurrentRequestOrNull.call(void 0, );
             if (!request) return;
             const metadata = context.requestContext.get(request, contextKey);
             if (!metadata) return;

package/dist/{chunk-NDILNQ4L.cjs → chunk-XKG2BLFN.cjs}

@@ -34,7 +34,7 @@ var _chunkS3A45T7Fcjs = require('./chunk-S3A45T7F.cjs');
 var _chunkZEG3OPIBcjs = require('./chunk-ZEG3OPIB.cjs');
 
 
-var _chunkNICDYKBScjs = require('./chunk-NICDYKBS.cjs');
+var _chunk6XWDE2P2cjs = require('./chunk-6XWDE2P2.cjs');
 
 
 var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
@@ -209,7 +209,7 @@ async function invokeAPIRouteEndpoint(endpoint, request, params = {}, bodySizeLi
     if (response2) return response2;
     throw error;
   }
-  const response = await _chunkNICDYKBScjs._runWithCurrentRequest.call(void 0, 
+  const response = await _chunk6XWDE2P2cjs._runWithCurrentRequest.call(void 0, 
     request,
     () => invokeAPIRouteEndpointInContext(endpoint, request, params)
   );