@farm.js/core 0.1.15 → 0.1.16

package/dist/env.d.ts

@@ -31,8 +31,26 @@ type FarmPublicEnv = FarmEnvTypes extends {
     public: infer TPublic;
 } ? TPublic extends Record<string, any> ? TPublic : Record<string, unknown> : Record<string, unknown>;
 type FarmTypedEnv = ResolvedFarmEnv<FarmServerEnv, FarmPublicEnv>;
+type FarmEnvRuntimeType = "string" | "number" | "boolean" | "json";
+/**
+ * The env a server bundle carries. `runtime.server` lists server keys that are
+ * read from the server's environment instead of being stored in the bundle,
+ * with the type their parsed value had at build time.
+ */
+interface BundledFarmEnv extends ResolvedFarmEnv {
+    runtime?: {
+        server: Record<string, FarmEnvRuntimeType>;
+    };
+}
 declare function resolveEnv<TConfig extends FarmEnvConfig<any, any> | undefined>(config: TConfig, source?: Record<string, string | undefined>): InferEnv<NonNullable<TConfig>>;
-declare function setEnv(env: ResolvedFarmEnv): void;
+/**
+ * Prepare resolved env for a server bundle. Server values that came from the
+ * build environment are left out and read from `process.env` when the server
+ * uses them, so secrets never land in build output and a restart picks up a
+ * rotated value. Values a parser produced without an env var (defaults) stay.
+ */
+declare function createBundledEnv(env: ResolvedFarmEnv | FarmEnvConfig<any, any> | undefined, source?: Record<string, string | undefined>): BundledFarmEnv;
+declare function setEnv(env: ResolvedFarmEnv | BundledFarmEnv): void;
 declare function getResolvedEnv<TEnv extends ResolvedFarmEnv = FarmTypedEnv>(): TEnv;
 declare function getEnv<TServer extends Record<string, any> = FarmServerEnv>(): TServer;
 declare function getEnv<TKey extends Extract<keyof FarmServerEnv, string>>(key: TKey): FarmServerEnv[TKey];
@@ -42,4 +60,4 @@ declare const env: FarmServerEnv;
 declare const serverEnv: Record<string, unknown>;
 declare const publicEnv: FarmPublicEnv;
 
-export { type EnvParser, type EnvSchema, type EnvShape, type FarmEnvConfig, type FarmEnvTypes, type FarmPublicEnv, type FarmServerEnv, type FarmTypedEnv, type InferEnv, type InferEnvParser, type InferEnvShape, type ResolvedFarmEnv, env, getEnv, getPublicEnv, getResolvedEnv, publicEnv, resolveEnv, serverEnv, setEnv };
+export { type BundledFarmEnv, type EnvParser, type EnvSchema, type EnvShape, type FarmEnvConfig, type FarmEnvRuntimeType, type FarmEnvTypes, type FarmPublicEnv, type FarmServerEnv, type FarmTypedEnv, type InferEnv, type InferEnvParser, type InferEnvShape, type ResolvedFarmEnv, createBundledEnv, env, getEnv, getPublicEnv, getResolvedEnv, publicEnv, resolveEnv, serverEnv, setEnv };

package/dist/env.mjs

@@ -1,4 +1,5 @@
 import {
+  createBundledEnv,
   env,
   getEnv,
   getPublicEnv,
@@ -7,9 +8,10 @@ import {
   resolveEnv,
   serverEnv,
   setEnv
-} from "./chunk-FOGLGRDS.mjs";
+} from "./chunk-7HDZYYS4.mjs";
 import "./chunk-LPEX4YW6.mjs";
 export {
+  createBundledEnv,
   env,
   getEnv,
   getPublicEnv,

package/dist/index.cjs

@@ -22038,7 +22038,7 @@ var init_server3 = __esm({
 var version;
 var init_package = __esm({
   "package.json"() {
-    version = "0.1.15";
+    version = "0.1.16";
   }
 });
 
@@ -26373,21 +26373,40 @@ function resolveEnv(config, source = getProcessEnv()) {
   };
   return resolved;
 }
+function createBundledEnv(env2, source = getProcessEnv()) {
+  const resolved = normalizeResolvedEnv(env2 ?? {});
+  const server = {};
+  const runtime3 = {};
+  for (const [key, value] of Object.entries(resolved.server)) {
+    if (source[key] === void 0) {
+      server[key] = value;
+    } else {
+      runtime3[key] = getRuntimeEnvType(value);
+    }
+  }
+  return {
+    server,
+    public: resolved.public,
+    ...Object.keys(runtime3).length > 0 ? { runtime: { server: runtime3 } } : {}
+  };
+}
 function setEnv(env2) {
-  currentEnv = normalizeResolvedEnv(env2);
+  currentEnv = prepareEnv(env2);
   if (typeof window === "undefined") {
     farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
   }
 }
 function getResolvedEnv() {
-  return getCurrentEnv();
+  const env2 = getCurrentEnv();
+  if (typeof window === "undefined") readRuntimeServerEnv(env2);
+  return env2;
 }
 function getEnv(key) {
-  assertServerEnvAccess();
+  const server = getEnvScope("server");
   if (key === void 0) {
-    return getCurrentEnv().server;
+    return server;
   }
-  return getCurrentEnv().server[key];
+  return readServerEnvKey(server, key);
 }
 function getPublicEnv(key) {
   if (key === void 0) {
@@ -26428,7 +26447,7 @@ function createEnvProxy(scope) {
           return void 0;
         }
         const env2 = getEnvScope(scope);
-        return env2[property];
+        return scope === "server" ? readServerEnvKey(env2, property) : env2[property];
       },
       ownKeys() {
         return Reflect.ownKeys(getEnvScope(scope));
@@ -26451,10 +26470,75 @@ function createEnvProxy(scope) {
   );
 }
 function getEnvScope(scope) {
+  const env2 = getCurrentEnv();
   if (scope === "server") {
     assertServerEnvAccess();
+    readRuntimeServerEnv(env2);
+  }
+  return env2[scope] || {};
+}
+function readServerEnvKey(server, key) {
+  const value = server[key];
+  if (value === void 0) {
+    const state = getCurrentEnv()[FARM_ENV_RUNTIME_SYMBOL];
+    if (state && key in state.pending && !state.warned.has(key)) {
+      state.warned.add(key);
+      console.warn(
+        `[Farm] Server env "${key}" was set when this app was built but is not set where the server runs, so it reads as undefined. Farm reads server env at runtime and does not store it in the build output; set "${key}" in the server's environment.`
+      );
+    }
+  }
+  return value;
+}
+function readRuntimeServerEnv(env2) {
+  const state = env2[FARM_ENV_RUNTIME_SYMBOL];
+  if (!state) return;
+  const source = getProcessEnv();
+  for (const [key, type] of Object.entries(state.pending)) {
+    const raw = source[key];
+    if (raw === void 0) continue;
+    env2.server[key] = coerceRuntimeEnvValue(raw, type);
+    delete state.pending[key];
+  }
+}
+function getRuntimeEnvType(value) {
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (value !== null && typeof value === "object" && !(value instanceof Date)) return "json";
+  return "string";
+}
+function coerceRuntimeEnvValue(raw, type) {
+  if (type === "number") {
+    const value = Number(raw);
+    return raw.trim() !== "" && Number.isFinite(value) ? value : raw;
+  }
+  if (type === "boolean") {
+    if (/^(true|1)$/i.test(raw.trim())) return true;
+    if (/^(false|0|)$/i.test(raw.trim())) return false;
+    return raw;
+  }
+  if (type === "json") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
   }
-  return getCurrentEnv()[scope] || {};
+  return raw;
+}
+function prepareEnv(env2) {
+  const normalized = normalizeResolvedEnv(env2);
+  const runtime3 = env2.runtime?.server;
+  if (!isRecord4(runtime3) || Object.keys(runtime3).length === 0) return normalized;
+  const prepared = { server: { ...normalized.server }, public: normalized.public };
+  Object.defineProperty(prepared, FARM_ENV_RUNTIME_SYMBOL, {
+    value: {
+      pending: { ...runtime3 },
+      warned: /* @__PURE__ */ new Set()
+    },
+    enumerable: false
+  });
+  return prepared;
 }
 function assertServerEnvAccess() {
   if (typeof window !== "undefined") {
@@ -26483,7 +26567,7 @@ function getCurrentEnv() {
 function getInjectedEnv() {
   try {
     if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
-      return normalizeResolvedEnv(__FARM_ENV__);
+      return prepareEnv(__FARM_ENV__);
     }
   } catch {
   }
@@ -26513,14 +26597,16 @@ function getProcessEnv() {
   }
   return {};
 }
-var FARM_ENV_SYMBOL, farmEnvGlobal, currentEnv, env, serverEnv, publicEnv;
+var FARM_ENV_SYMBOL, FARM_ENV_RUNTIME_SYMBOL, farmEnvGlobal, currentEnv, env, serverEnv, publicEnv;
 var init_env = __esm({
   "src/env.ts"() {
     "use strict";
     FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
+    FARM_ENV_RUNTIME_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env.runtime");
     farmEnvGlobal = globalThis;
     currentEnv = getInitialEnv();
     __name(resolveEnv, "resolveEnv");
+    __name(createBundledEnv, "createBundledEnv");
     __name(setEnv, "setEnv");
     __name(getResolvedEnv, "getResolvedEnv");
     __name(getEnv, "getEnv");
@@ -26532,6 +26618,11 @@ var init_env = __esm({
     __name(parseEnvValue, "parseEnvValue");
     __name(createEnvProxy, "createEnvProxy");
     __name(getEnvScope, "getEnvScope");
+    __name(readServerEnvKey, "readServerEnvKey");
+    __name(readRuntimeServerEnv, "readRuntimeServerEnv");
+    __name(getRuntimeEnvType, "getRuntimeEnvType");
+    __name(coerceRuntimeEnvValue, "coerceRuntimeEnvValue");
+    __name(prepareEnv, "prepareEnv");
     __name(assertServerEnvAccess, "assertServerEnvAccess");
     __name(getInitialEnv, "getInitialEnv");
     __name(getCurrentEnv, "getCurrentEnv");
@@ -39798,7 +39889,7 @@ function getEnvDefines(config, configEnv) {
     )
   };
   if (configEnv?.isSsrBuild) {
-    defines.__FARM_ENV__ = JSON.stringify(getFullEnvDefine(config));
+    defines.__FARM_ENV__ = JSON.stringify(createBundledEnv(getFullEnvDefine(config)));
   }
   return defines;
 }
@@ -44193,6 +44284,7 @@ var fs14, path38, import_node_url11, ALL_TYPE_ARTIFACTS, createEmptyTypeArtifact
 var init_vite2 = __esm({
   "src/vite.ts"() {
     "use strict";
+    init_env();
     init_app();
     init_utils();
     init_plugin();
@@ -45263,7 +45355,7 @@ export const farmRegistry: {
   clientManifest?: any;
   routePaths?: Record<string, string>;
 } = {
-  env: ${JSON.stringify(config.env || { server: {}, public: {} }, null, 2)},
+  env: ${JSON.stringify(createBundledEnv(config.env), null, 2)},
   deploymentId: ${JSON.stringify(config.deploymentId)},
   basePath: ${JSON.stringify(config.basePath)},
   apiBasePath: ${JSON.stringify(apiBasePath)},
@@ -45767,7 +45859,7 @@ export default defineEventHandler(async (event: H3Event) => {
           farmRegistry.apiRouteManager = apiRouteManager;
           farmRegistry.routeManager = routeManager;
           farmRegistry.serverRenderer = serverRenderer;
-          farmRegistry.env = config.env || { server: {}, public: {} };
+          farmRegistry.env = createBundledEnv(config.env);
           farmRegistry.deploymentId = config.deploymentId;
           farmRegistry.basePath = config.basePath;
         };
@@ -45832,6 +45924,7 @@ var import_path16;
 var init_nitro = __esm({
   "src/nitro/index.ts"() {
     "use strict";
+    init_env();
     import_path16 = __toESM(require("path"));
     init_workflows();
     init_cron();
@@ -45914,7 +46007,11 @@ __export(src_exports, {
   ServerActionRequestError: () => ServerActionRequestError,
   ServerFnFailure: () => ServerFnFailure,
   UnsupportedRateLimitStorageError: () => UnsupportedRateLimitStorageError,
+  _attachServerFunctionDescriptor: () => _attachServerFunctionDescriptor,
+  _describeServerFunction: () => _describeServerFunction,
+  _invokeServerFunction: () => _invokeServerFunction,
   _parseServerFnSchema: () => _parseServerFnSchema,
+  _runServerFunctionForCaller: () => _runServerFunctionForCaller,
   _runWithAfterNodeResponse: () => _runWithAfterNodeResponse,
   _runWithAfterRequest: () => _runWithAfterRequest,
   _runWithMiddlewareContext: () => _runWithMiddlewareContext,
@@ -45960,6 +46057,7 @@ __export(src_exports, {
   cookies: () => cookies,
   createAPIClient: () => createAPIClient,
   createApiClients: () => createApiClients,
+  createBundledEnv: () => createBundledEnv,
   createClientOnlyFn: () => createClientOnlyFn,
   createClientPluginManager: () => createClientPluginManager,
   createCompressionPlugin: () => createCompressionPlugin,
@@ -46022,6 +46120,7 @@ __export(src_exports, {
   createServerActionRequestErrorResponse: () => createServerActionRequestErrorResponse,
   createServerFn: () => createServerFn,
   createServerFnTransportError: () => createServerFnTransportError,
+  createServerFunctionDescriptor: () => createServerFunctionDescriptor,
   createServerMiddleware: () => createServerMiddleware,
   createServerOnlyFn: () => createServerOnlyFn,
   createServerQuery: () => createServerQuery,
@@ -52793,8 +52892,74 @@ init_server_action_security();
 init_request_bridge();
 init_cache();
 init_server_fn_error();
+init_navigation_errors();
 init_server_fn_error();
 var FARM_SERVER_FN_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn");
+var FARM_SERVER_FUNCTION_DESCRIPTOR = /* @__PURE__ */ Symbol.for("farm.server-function.descriptor");
+var _ServerFnInputError = class _ServerFnInputError extends Error {
+  constructor(cause) {
+    super("Server function input is invalid");
+    this.cause = cause;
+  }
+};
+__name(_ServerFnInputError, "ServerFnInputError");
+var ServerFnInputError = _ServerFnInputError;
+function createServerFunctionDescriptor(kind, options, run) {
+  return Object.freeze({
+    kind,
+    input: options.input,
+    output: options.output,
+    mcp: options.mcp === void 0 ? void 0 : Object.freeze({ ...options.mcp }),
+    run
+  });
+}
+__name(createServerFunctionDescriptor, "createServerFunctionDescriptor");
+function _attachServerFunctionDescriptor(target, descriptor) {
+  Object.defineProperty(target, FARM_SERVER_FUNCTION_DESCRIPTOR, {
+    value: descriptor,
+    enumerable: false
+  });
+}
+__name(_attachServerFunctionDescriptor, "_attachServerFunctionDescriptor");
+function getServerFunctionRunner(value) {
+  if (typeof value !== "function") return void 0;
+  return value[FARM_SERVER_FUNCTION_DESCRIPTOR];
+}
+__name(getServerFunctionRunner, "getServerFunctionRunner");
+function _runServerFunctionForCaller(value, input) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) throw new TypeError("Expected a function created with createServerFn");
+  return runner.run(input);
+}
+__name(_runServerFunctionForCaller, "_runServerFunctionForCaller");
+function _describeServerFunction(value) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) return void 0;
+  const { kind, input, output, mcp } = runner;
+  return Object.freeze({ kind, input, output, mcp });
+}
+__name(_describeServerFunction, "_describeServerFunction");
+async function _invokeServerFunction(value, input, request2) {
+  const runner = getServerFunctionRunner(value);
+  if (!runner) {
+    throw new TypeError("Expected a function created with createServerFn or createServerQuery");
+  }
+  try {
+    const data = await runWithServerActionRequest(request2, () => runner.run(input));
+    return { ok: true, data };
+  } catch (error) {
+    if (error instanceof ServerFnInputError) {
+      return { ok: false, reason: "input", error: error.cause };
+    }
+    if (isServerFnFailure(error)) return { ok: false, reason: "failure", failure: error };
+    const redirect3 = getFarmRedirectError(error);
+    if (redirect3) {
+      return { ok: false, reason: "redirect", url: redirect3.url, status: redirect3.status };
+    }
+    return { ok: false, reason: "error", error };
+  }
+}
+__name(_invokeServerFunction, "_invokeServerFunction");
 var UNSAFE_FORM_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function createServerMiddleware(options) {
   if (!options || typeof options.handler !== "function") {
@@ -52818,10 +52983,15 @@ function createServerFn(options) {
   const middleware2 = resolveServerFnMiddleware(options.middleware);
   const errors = normalizeServerFnErrors(options.errors);
   const error = createServerFnErrorHandler(errors);
-  const serverFn = /* @__PURE__ */ __name(async (value) => {
+  const run = /* @__PURE__ */ __name(async (value, labelInputErrors) => {
     const formData = isFormData2(value) ? value : void 0;
     const rawInput = formData ? formDataToObject2(formData) : value;
-    const input = await _parseServerFnSchema(options.input, rawInput, "input");
+    let input;
+    try {
+      input = await _parseServerFnSchema(options.input, rawInput, "input");
+    } catch (cause) {
+      throw labelInputErrors ? new ServerFnInputError(cause) : cause;
+    }
     const executionContext = getServerActionExecutionContext();
     const request2 = executionContext?.request ?? _resolveCurrentRequest();
     const signal = executionContext?.signal ?? request2?.signal ?? getServerActionSignal();
@@ -52847,7 +53017,8 @@ function createServerFn(options) {
       await applyFarmCacheInvalidationTargets(declaration);
     }
     return parsedResult;
-  }, "serverFn");
+  }, "run");
+  const serverFn = /* @__PURE__ */ __name((value) => run(value, false), "serverFn");
   Object.defineProperties(serverFn, {
     [FARM_SERVER_FN_SYMBOL]: {
       value: true,
@@ -52878,6 +53049,10 @@ function createServerFn(options) {
       enumerable: false
     }
   });
+  _attachServerFunctionDescriptor(
+    serverFn,
+    createServerFunctionDescriptor("action", options, (value) => run(value, true))
+  );
   return serverFn;
 }
 __name(createServerFn, "createServerFn");
@@ -53429,6 +53604,16 @@ function createServerQuery(options) {
       enumerable: false
     }
   });
+  _attachServerFunctionDescriptor(
+    query,
+    createServerFunctionDescriptor("query", options, async (value) => {
+      const result = await _runServerFunctionForCaller(
+        execute,
+        value
+      );
+      return result.data;
+    })
+  );
   return query;
 }
 __name(createServerQuery, "createServerQuery");
@@ -53786,6 +53971,7 @@ init_deployment();
 init_generate_route_types();
 
 // src/build/index.ts
+init_env();
 init_config4();
 var import_path17 = __toESM(require("path"));
 var import_node_fs15 = require("fs");
@@ -53796,6 +53982,7 @@ init_server_path();
 init_layers();
 
 // src/nitro/universal-build.ts
+init_env();
 init_config4();
 
 // src/nitro/client-css-href.ts
@@ -58480,7 +58667,7 @@ async function buildSSRInMemory(productionVite, config, root, routeManager, apiR
       },
       define: {
         __FARM_API_BASE_URL__: JSON.stringify(config.api.baseURL),
-        __FARM_ENV__: JSON.stringify(config.env || { server: {}, public: {} }),
+        __FARM_ENV__: JSON.stringify(createBundledEnv(config.env)),
         __FARM_PUBLIC_ENV__: JSON.stringify(config.env?.public || {})
       },
       plugins: [
@@ -63931,7 +64118,7 @@ async function buildSSR(viteBuild, config, root, srcDir, outputDir) {
     },
     define: {
       __FARM_API_BASE_URL__: JSON.stringify(config.api.baseURL),
-      __FARM_ENV__: JSON.stringify(config.env || { server: {}, public: {} }),
+      __FARM_ENV__: JSON.stringify(createBundledEnv(config.env)),
       __FARM_PUBLIC_ENV__: JSON.stringify(config.env?.public || {})
     },
     plugins: [
@@ -64014,7 +64201,7 @@ async function buildNitro(config, routeManager, apiRouteManager, serverRenderer,
     farmRegistry.apiRouteManager = apiRouteManager;
     farmRegistry.routeManager = routeManager;
     farmRegistry.serverRenderer = serverRenderer;
-    farmRegistry.env = config.env || { server: {}, public: {} };
+    farmRegistry.env = createBundledEnv(config.env);
     const routePaths = {};
     for (const [pattern, entry] of routeManager.getRoutes()) {
       const bundledPath = entry.modulePath.replace(/.*\/src\/app\//, "").replace(/\.(tsx?|jsx?)$/, ".js");
@@ -67557,7 +67744,11 @@ __name(cookies, "cookies");
   ServerActionRequestError,
   ServerFnFailure,
   UnsupportedRateLimitStorageError,
+  _attachServerFunctionDescriptor,
+  _describeServerFunction,
+  _invokeServerFunction,
   _parseServerFnSchema,
+  _runServerFunctionForCaller,
   _runWithAfterNodeResponse,
   _runWithAfterRequest,
   _runWithMiddlewareContext,
@@ -67603,6 +67794,7 @@ __name(cookies, "cookies");
   cookies,
   createAPIClient,
   createApiClients,
+  createBundledEnv,
   createClientOnlyFn,
   createClientPluginManager,
   createCompressionPlugin,
@@ -67665,6 +67857,7 @@ __name(cookies, "cookies");
   createServerActionRequestErrorResponse,
   createServerFn,
   createServerFnTransportError,
+  createServerFunctionDescriptor,
   createServerMiddleware,
   createServerOnlyFn,
   createServerQuery,