@farm.js/core 0.1.0-beta.95 → 0.1.0-beta.97

package/dist/server-action-security.mjs

@@ -10,9 +10,9 @@ import {
   runWithServerActionRequest,
   sanitizeServerActionError,
   validateServerActionRequest
-} from "./chunk-VV24CC42.mjs";
+} from "./chunk-35NPLKQJ.mjs";
 import "./chunk-ZHQMHJAV.mjs";
-import "./chunk-RBRLLZL5.mjs";
+import "./chunk-34IAPZBG.mjs";
 import "./chunk-DZU3EKQP.mjs";
 import "./chunk-CGILA3WO.mjs";
 export {

package/dist/server-fn-client.cjs

@@ -27,10 +27,60 @@ __export(server_fn_client_exports, {
 });
 module.exports = __toCommonJS(server_fn_client_exports);
 var import_react = require("react");
+
+// src/client-observers.ts
+function notifyClientObserver(observer, args, label = "Client lifecycle") {
+  if (!observer) return;
+  const report = /* @__PURE__ */ __name((error) => {
+    const reportError = globalThis.reportError;
+    if (typeof reportError === "function") {
+      try {
+        reportError.call(globalThis, error);
+        return;
+      } catch {
+      }
+    }
+    try {
+      console.error(`[Farm.js] ${label} callback failed:`, error);
+    } catch {
+    }
+  }, "report");
+  try {
+    const result = observer(...args);
+    if (result && typeof result.then === "function")
+      void Promise.resolve(result).catch(report);
+  } catch (error) {
+    report(error);
+  }
+}
+__name(notifyClientObserver, "notifyClientObserver");
+
+// src/mutation-retry.ts
+async function invokeMutationWithRetry(invoke, retry, shouldContinue) {
+  const maxRetries = Math.max(0, retry?.count ?? 0);
+  let attempt = 0;
+  while (true) {
+    try {
+      return await invoke();
+    } catch (error) {
+      if (attempt >= maxRetries || !shouldContinue()) throw error;
+      attempt += 1;
+      const delay = typeof retry?.delay === "function" ? retry.delay(attempt) : retry?.delay ?? 0;
+      if (delay > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        if (!shouldContinue()) throw error;
+      }
+    }
+  }
+}
+__name(invokeMutationWithRetry, "invokeMutationWithRetry");
+
+// src/server-fn-client.ts
 function useServerFn(serverFn, options = {}) {
   const { initialResult = null, resetOnSubmit = true } = options;
   const callbacksRef = (0, import_react.useRef)({});
   const requestIdRef = (0, import_react.useRef)(0);
+  const lastResetIdRef = (0, import_react.useRef)(0);
   const initialState = {
     pendingCount: 0,
     status: "idle",
@@ -41,11 +91,9 @@ function useServerFn(serverFn, options = {}) {
   const [state, setState] = (0, import_react.useState)(initialState);
   const setActionState = (0, import_react.useCallback)(
     (value) => {
-      setState((current) => {
-        const next = typeof value === "function" ? value(current) : value;
-        stateRef.current = next;
-        return next;
-      });
+      const next = typeof value === "function" ? value(stateRef.current) : value;
+      stateRef.current = next;
+      setState(next);
     },
     []
   );
@@ -66,63 +114,88 @@ function useServerFn(serverFn, options = {}) {
         current: previousResult
       });
       const hasOptimisticResult = optimisticResult !== void 0;
-      setActionState((current) => ({
-        pendingCount: current.pendingCount + 1,
-        status: "pending",
-        result: hasOptimisticResult ? optimisticResult : resetOnSubmit ? null : current.result,
-        error: null
-      }));
+      setActionState((current) => {
+        if (requestId < lastResetIdRef.current) return current;
+        const pendingCount = current.pendingCount + 1;
+        if (requestId !== requestIdRef.current) return { ...current, pendingCount };
+        return {
+          pendingCount,
+          status: "pending",
+          result: hasOptimisticResult ? optimisticResult : resetOnSubmit ? null : current.result,
+          error: null
+        };
+      });
       try {
-        const result = await serverFn(input);
+        const result = await invokeMutationWithRetry(
+          () => serverFn(input),
+          options.retry,
+          // A reset disowns this submission; stop scheduling retries then.
+          () => requestId >= lastResetIdRef.current
+        );
         const isLatestRequest = requestId === requestIdRef.current;
         setActionState((current) => {
+          if (requestId < lastResetIdRef.current) return current;
           const pendingCount = Math.max(0, current.pendingCount - 1);
           if (!isLatestRequest) {
             return {
               ...current,
-              pendingCount,
-              status: pendingCount > 0 ? "pending" : current.status
+              pendingCount
             };
           }
           return {
             pendingCount,
-            status: pendingCount > 0 ? "pending" : "success",
+            status: "success",
             result,
             error: null
           };
         });
         if (isLatestRequest) {
-          callbacksRef.current.onSuccess?.(result);
-          callbacksRef.current.onSettled?.(result, null);
+          notifyClientObserver(callbacksRef.current.onSuccess, [result], "Action onSuccess");
+          if (requestId === requestIdRef.current) {
+            notifyClientObserver(
+              callbacksRef.current.onSettled,
+              [result, null],
+              "Action onSettled"
+            );
+          }
         }
         return result;
       } catch (cause) {
         const error = normalizeServerFnError(cause);
         const isLatestRequest = requestId === requestIdRef.current;
         setActionState((current) => {
+          if (requestId < lastResetIdRef.current) return current;
           const pendingCount = Math.max(0, current.pendingCount - 1);
           if (!isLatestRequest) {
             return {
               ...current,
-              pendingCount,
-              status: pendingCount > 0 ? "pending" : current.status
+              pendingCount
             };
           }
           return {
             pendingCount,
-            status: pendingCount > 0 ? "pending" : "error",
+            status: "error",
             result: hasOptimisticResult && options.rollbackOnError ? previousResult : resetOnSubmit ? null : current.result,
             error
           };
         });
         if (isLatestRequest) {
-          callbacksRef.current.onError?.(error);
-          callbacksRef.current.onSettled?.(null, error);
+          notifyClientObserver(callbacksRef.current.onError, [error], "Action onError");
+          if (requestId === requestIdRef.current) {
+            notifyClientObserver(callbacksRef.current.onSettled, [null, error], "Action onSettled");
+          }
         }
         throw error;
       }
     },
-    [options.optimistic, options.rollbackOnError, resetOnSubmit, serverFn, setActionState]
+    [
+      options.optimistic,
+      options.retry,
+      options.rollbackOnError,
+      resetOnSubmit,
+      serverFn,
+      setActionState
+    ]
   );
   const formAction = (0, import_react.useCallback)(
     async (formData) => {
@@ -137,7 +210,7 @@ function useServerFn(serverFn, options = {}) {
     [submit]
   );
   const reset = (0, import_react.useCallback)(() => {
-    requestIdRef.current += 1;
+    lastResetIdRef.current = ++requestIdRef.current;
     setActionState({
       pendingCount: 0,
       status: "idle",
@@ -162,14 +235,17 @@ __name(useServerFn, "useServerFn");
 function useAction(target, options = {}) {
   const serverFn = resolveServerFnTarget(target);
   const action = useServerFn(serverFn, options);
+  const formActionRef = (0, import_react.useRef)(action.formAction);
+  formActionRef.current = action.formAction;
   const Form = (0, import_react.useMemo)(() => {
+    const submitForm = /* @__PURE__ */ __name((formData) => formActionRef.current(formData), "submitForm");
     const ActionForm = /* @__PURE__ */ __name((props) => (0, import_react.createElement)("form", {
       ...props,
-      action: action.formAction
+      action: submitForm
     }), "ActionForm");
     ActionForm.displayName = "FarmActionForm";
     return ActionForm;
-  }, [action.formAction]);
+  }, []);
   return (0, import_react.useMemo)(() => {
     const call = /* @__PURE__ */ __name(((input) => action.submit(input)), "call");
     return Object.assign(call, {

package/dist/server-fn-client.d.mts

@@ -1,7 +1,11 @@
 import { FormHTMLAttributes, ComponentType } from 'react';
 import { ServerFn } from './server-fn.mjs';
+import { R as RetryOptions } from './client-DWoLZ3QU.mjs';
 import './cache.mjs';
 import './server-fn-error-DDh14a0V.mjs';
+import './integration-api-BT024nuJ.mjs';
+import './client-cache-CCK-fCe0.mjs';
+import './route-CvEr4Uc9.mjs';
 
 type ServerFnActionStatus = "idle" | "pending" | "success" | "error";
 type ServerFnSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;
@@ -16,6 +20,8 @@ type UseServerFnOptions<TResult, TError extends Error = Error, TInput = unknown>
     throwOnFormError?: boolean;
     optimistic?: (context: ServerFnOptimisticContext<TInput, TResult>) => TResult | null | undefined;
     rollbackOnError?: boolean;
+    /** Retry failed submissions with the API client's retry shape. Defaults to no retries. */
+    retry?: RetryOptions;
     onSuccess?: (result: TResult) => void;
     onError?: (error: TError) => void;
     onSettled?: (result: TResult | null, error: TError | null) => void;

package/dist/server-fn-client.d.ts

@@ -1,7 +1,11 @@
 import { FormHTMLAttributes, ComponentType } from 'react';
 import { ServerFn } from './server-fn.js';
+import { R as RetryOptions } from './client-DuQuQC1h.js';
 import './cache.js';
 import './server-fn-error-DDh14a0V.js';
+import './integration-api-BT024nuJ.js';
+import './client-cache-BMxuFqwH.js';
+import './route-4pd-EVtw.js';
 
 type ServerFnActionStatus = "idle" | "pending" | "success" | "error";
 type ServerFnSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;
@@ -16,6 +20,8 @@ type UseServerFnOptions<TResult, TError extends Error = Error, TInput = unknown>
     throwOnFormError?: boolean;
     optimistic?: (context: ServerFnOptimisticContext<TInput, TResult>) => TResult | null | undefined;
     rollbackOnError?: boolean;
+    /** Retry failed submissions with the API client's retry shape. Defaults to no retries. */
+    retry?: RetryOptions;
     onSuccess?: (result: TResult) => void;
     onError?: (error: TError) => void;
     onSettled?: (result: TResult | null, error: TError | null) => void;

package/dist/server-fn-client.mjs

@@ -2,7 +2,8 @@
 import {
   useAction,
   useServerFn
-} from "./chunk-SALMKQXH.mjs";
+} from "./chunk-6EJHNHH4.mjs";
+import "./chunk-DU3PKDVQ.mjs";
 import "./chunk-CGILA3WO.mjs";
 export {
   useAction,

package/dist/server-fn.cjs

@@ -46,16 +46,29 @@ function getFarmCacheInvalidationState() {
   });
 }
 __name(getFarmCacheInvalidationState, "getFarmCacheInvalidationState");
+function warnFarmCacheListenerError(scope, error) {
+  const detail = error instanceof Error ? error.stack ?? error.message : String(error);
+  console.warn(`[farm:cache] ${scope} listener failed: ${detail}`);
+}
+__name(warnFarmCacheListenerError, "warnFarmCacheListenerError");
 function notifyFarmCacheInvalidation(key) {
   if (typeof key !== "string" || key.length === 0) return;
   for (const listener of getFarmCacheInvalidationState().listeners) {
-    listener(key);
+    try {
+      listener(key);
+    } catch (error) {
+      warnFarmCacheListenerError("invalidation", error);
+    }
   }
 }
 __name(notifyFarmCacheInvalidation, "notifyFarmCacheInvalidation");
 function notifyFarmCacheTask(task) {
   for (const listener of getFarmCacheInvalidationState().taskListeners) {
-    listener(task);
+    try {
+      listener(task);
+    } catch (error) {
+      warnFarmCacheListenerError("task", error);
+    }
   }
 }
 __name(notifyFarmCacheTask, "notifyFarmCacheTask");
@@ -235,7 +248,13 @@ function recordFarmEventTrace(event) {
       activeSpan.addEvent(event.type, toEventAttributes(event), event.timestamp);
     }
     const error = event.type === "request.error" ? void 0 : getEventError(event);
-    if (error !== void 0) recordSpanError(activeSpan, error);
+    if (error !== void 0) {
+      if (event.type === "render.error") {
+        recordSpanException(activeSpan, error);
+      } else {
+        recordSpanError(activeSpan, error);
+      }
+    }
   }
   const completedTraceContext = recordCompletedEventSpan(event, activeContext);
   return traceContext ?? completedTraceContext;
@@ -332,12 +351,26 @@ function getCompletedSpanDescriptor(event) {
   }
 }
 __name(getCompletedSpanDescriptor, "getCompletedSpanDescriptor");
+function hashFarmCacheKey(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index++) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+__name(hashFarmCacheKey, "hashFarmCacheKey");
 function toEventAttributes(event) {
   const attributes = {};
+  const redactKey = typeof event.type === "string" && event.type.startsWith("cache.");
   for (const [key, value] of Object.entries(event)) {
     if (key === "timestamp" || key === "level" || key === "error" || key === "traceId" || key === "spanId" || key === "traceSampled" || value === void 0) {
       continue;
     }
+    if (redactKey && key === "key" && typeof value === "string") {
+      attributes["farm.key_hash"] = hashFarmCacheKey(value);
+      continue;
+    }
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
       attributes[`farm.${key}`] = value;
     } else if (Array.isArray(value)) {
@@ -357,9 +390,14 @@ function getEventError(event) {
   return "error" in event ? event.error : void 0;
 }
 __name(getEventError, "getEventError");
-function recordSpanError(span, error) {
+function recordSpanException(span, error) {
   const normalized = error instanceof Error ? error : new Error(String(error));
   span.recordException(normalized);
+  return normalized;
+}
+__name(recordSpanException, "recordSpanException");
+function recordSpanError(span, error) {
+  const normalized = recordSpanException(span, error);
   span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: normalized.message });
 }
 __name(recordSpanError, "recordSpanError");

package/dist/server-fn.mjs

@@ -3,19 +3,19 @@ import {
   _parseServerFnSchema,
   createServerFn,
   createServerMiddleware
-} from "./chunk-RLGUZ3HS.mjs";
+} from "./chunk-I3OOUWO5.mjs";
 import {
   FARM_SERVER_FN_FAILURE_SYMBOL,
   ServerActionError,
   ServerFnFailure,
   createServerFnTransportError,
   isServerFnFailure
-} from "./chunk-VV24CC42.mjs";
+} from "./chunk-35NPLKQJ.mjs";
 import "./chunk-ZHQMHJAV.mjs";
-import "./chunk-AXVJCMVF.mjs";
-import "./chunk-RBRLLZL5.mjs";
+import "./chunk-2HDOV47R.mjs";
+import "./chunk-34IAPZBG.mjs";
 import "./chunk-WZ5QFROO.mjs";
-import "./chunk-ZRBCBOEX.mjs";
+import "./chunk-N2FY2QZ7.mjs";
 import "./chunk-LM2YNO4U.mjs";
 import "./chunk-DZU3EKQP.mjs";
 import "./chunk-CGILA3WO.mjs";

package/dist/server-plugins.d.mts

@@ -1,8 +1,8 @@
-import { bz as RedirectConfig, Y as FarmRequest, Z as FarmResponse, aX as FarmPluginContext, a as FarmPlugin, bA as HeaderConfig, bB as RewriteConfig } from './client-plugins-BvClItiL.mjs';
-export { aZ as FarmPluginLifecycle, a_ as FarmRequestPluginContext, a$ as FarmRequestStore } from './client-plugins-BvClItiL.mjs';
+import { bx as RedirectConfig, Y as FarmRequest, Z as FarmResponse, aV as FarmPluginContext, a as FarmPlugin, by as HeaderConfig, bz as RewriteConfig } from './client-plugins-B6-07YmP.mjs';
+export { aX as FarmPluginLifecycle, aY as FarmRequestPluginContext, aZ as FarmRequestStore } from './client-plugins-B6-07YmP.mjs';
 import { R as ResolvedFarmI18nConfig } from './types-CnH8DOqo.mjs';
 import './lifecycle-De0vQG45.mjs';
-import './route-Cq3aObmj.mjs';
+import './route-CvEr4Uc9.mjs';
 import './cache.mjs';
 import './renderer.mjs';
 import 'http';
@@ -10,6 +10,7 @@ import './types-Cc8l9IqS.mjs';
 import 'db0';
 import 'unstorage';
 import 'react';
+import './integration-api-BT024nuJ.mjs';
 import '@farming-labs/orm';
 import './types-CKwggz9n.mjs';
 import '@farming-labs/docs';

package/dist/server-plugins.d.ts

@@ -1,8 +1,8 @@
-import { bz as RedirectConfig, Y as FarmRequest, Z as FarmResponse, aX as FarmPluginContext, a as FarmPlugin, bA as HeaderConfig, bB as RewriteConfig } from './client-plugins-B9Sq-iMg.js';
-export { aZ as FarmPluginLifecycle, a_ as FarmRequestPluginContext, a$ as FarmRequestStore } from './client-plugins-B9Sq-iMg.js';
+import { bx as RedirectConfig, Y as FarmRequest, Z as FarmResponse, aV as FarmPluginContext, a as FarmPlugin, by as HeaderConfig, bz as RewriteConfig } from './client-plugins-By6MVUX-.js';
+export { aX as FarmPluginLifecycle, aY as FarmRequestPluginContext, aZ as FarmRequestStore } from './client-plugins-By6MVUX-.js';
 import { R as ResolvedFarmI18nConfig } from './types-CnH8DOqo.js';
 import './lifecycle-De0vQG45.js';
-import './route-Y8lfz1wF.js';
+import './route-4pd-EVtw.js';
 import './cache.js';
 import './renderer.js';
 import 'http';
@@ -10,6 +10,7 @@ import './types-Cc8l9IqS.js';
 import 'db0';
 import 'unstorage';
 import 'react';
+import './integration-api-BT024nuJ.js';
 import '@farming-labs/orm';
 import './types-CKwggz9n.js';
 import '@farming-labs/docs';