@farm.js/core 0.1.0-beta.14 → 0.1.0-beta.17

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

@@ -0,0 +1,33 @@
+import { ServerFn } from './server-fn.mjs';
+import './cache.mjs';
+import './server-fn-error-DDh14a0V.mjs';
+
+type ServerFnActionStatus = "idle" | "pending" | "success" | "error";
+type ServerFnSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;
+type ServerFnOptimisticContext<TInput, TResult> = {
+    input: TInput | FormData | undefined;
+    formData?: FormData;
+    current: TResult | null;
+};
+type UseServerFnOptions<TResult, TError extends Error = Error, TInput = unknown> = {
+    initialResult?: TResult | null;
+    resetOnSubmit?: boolean;
+    throwOnFormError?: boolean;
+    optimistic?: (context: ServerFnOptimisticContext<TInput, TResult>) => TResult | null | undefined;
+    rollbackOnError?: boolean;
+    onSuccess?: (result: TResult) => void;
+    onError?: (error: TError) => void;
+    onSettled?: (result: TResult | null, error: TError | null) => void;
+};
+type UseServerFnReturn<TInput, TResult, TError extends Error = Error> = {
+    pending: boolean;
+    status: ServerFnActionStatus;
+    result: TResult | null;
+    error: TError | null;
+    submit: ServerFnSubmit<TInput, TResult>;
+    formAction: (formData: FormData) => Promise<void>;
+    reset: () => void;
+};
+declare function useServerFn<TInput, TResult, TError extends Error = Error>(serverFn: ServerFn<TInput, TResult, TError>, options?: UseServerFnOptions<TResult, TError, TInput>): UseServerFnReturn<TInput, TResult, TError>;
+
+export { type ServerFnActionStatus, type ServerFnOptimisticContext, type ServerFnSubmit, type UseServerFnOptions, type UseServerFnReturn, useServerFn };

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

@@ -0,0 +1,33 @@
+import { ServerFn } from './server-fn.js';
+import './cache.js';
+import './server-fn-error-DDh14a0V.js';
+
+type ServerFnActionStatus = "idle" | "pending" | "success" | "error";
+type ServerFnSubmit<TInput, TResult> = [unknown] extends [TInput] ? (input?: TInput | FormData) => Promise<TResult> : (input: TInput | FormData) => Promise<TResult>;
+type ServerFnOptimisticContext<TInput, TResult> = {
+    input: TInput | FormData | undefined;
+    formData?: FormData;
+    current: TResult | null;
+};
+type UseServerFnOptions<TResult, TError extends Error = Error, TInput = unknown> = {
+    initialResult?: TResult | null;
+    resetOnSubmit?: boolean;
+    throwOnFormError?: boolean;
+    optimistic?: (context: ServerFnOptimisticContext<TInput, TResult>) => TResult | null | undefined;
+    rollbackOnError?: boolean;
+    onSuccess?: (result: TResult) => void;
+    onError?: (error: TError) => void;
+    onSettled?: (result: TResult | null, error: TError | null) => void;
+};
+type UseServerFnReturn<TInput, TResult, TError extends Error = Error> = {
+    pending: boolean;
+    status: ServerFnActionStatus;
+    result: TResult | null;
+    error: TError | null;
+    submit: ServerFnSubmit<TInput, TResult>;
+    formAction: (formData: FormData) => Promise<void>;
+    reset: () => void;
+};
+declare function useServerFn<TInput, TResult, TError extends Error = Error>(serverFn: ServerFn<TInput, TResult, TError>, options?: UseServerFnOptions<TResult, TError, TInput>): UseServerFnReturn<TInput, TResult, TError>;
+
+export { type ServerFnActionStatus, type ServerFnOptimisticContext, type ServerFnSubmit, type UseServerFnOptions, type UseServerFnReturn, useServerFn };

package/dist/server-fn-client.mjs

@@ -1,7 +1,7 @@
 "use client";
 import {
   useServerFn
-} from "./chunk-32W4QEJP.mjs";
+} from "./chunk-KFTGPFRD.mjs";
 import "./chunk-CGILA3WO.mjs";
 export {
   useServerFn

package/dist/server-fn-error-DDh14a0V.d.mts

@@ -0,0 +1,26 @@
+declare const FARM_SERVER_FN_FAILURE_SYMBOL: unique symbol;
+type SerializedServerFnFailure = {
+    name: "ServerFnFailure";
+    message: string;
+    code: string;
+    status: number;
+    data: unknown;
+};
+declare class ServerFnFailure<TCode extends string = string, TData = unknown, TStatus extends number = number> extends Error {
+    readonly name: "ServerFnFailure";
+    readonly code: TCode;
+    readonly data: TData;
+    readonly status: TStatus;
+    constructor(code: TCode, data: TData, options: {
+        status: TStatus;
+        message: string;
+    });
+}
+declare class ServerActionError extends Error {
+    readonly name: "ServerActionError";
+    constructor(message?: string);
+}
+declare function isServerFnFailure(value: unknown): value is ServerFnFailure;
+declare function createServerFnTransportError(value: unknown): ServerFnFailure | ServerActionError;
+
+export { FARM_SERVER_FN_FAILURE_SYMBOL as F, ServerFnFailure as S, ServerActionError as a, type SerializedServerFnFailure as b, createServerFnTransportError as c, isServerFnFailure as i };

package/dist/server-fn-error-DDh14a0V.d.ts

@@ -0,0 +1,26 @@
+declare const FARM_SERVER_FN_FAILURE_SYMBOL: unique symbol;
+type SerializedServerFnFailure = {
+    name: "ServerFnFailure";
+    message: string;
+    code: string;
+    status: number;
+    data: unknown;
+};
+declare class ServerFnFailure<TCode extends string = string, TData = unknown, TStatus extends number = number> extends Error {
+    readonly name: "ServerFnFailure";
+    readonly code: TCode;
+    readonly data: TData;
+    readonly status: TStatus;
+    constructor(code: TCode, data: TData, options: {
+        status: TStatus;
+        message: string;
+    });
+}
+declare class ServerActionError extends Error {
+    readonly name: "ServerActionError";
+    constructor(message?: string);
+}
+declare function isServerFnFailure(value: unknown): value is ServerFnFailure;
+declare function createServerFnTransportError(value: unknown): ServerFnFailure | ServerActionError;
+
+export { FARM_SERVER_FN_FAILURE_SYMBOL as F, ServerFnFailure as S, ServerActionError as a, type SerializedServerFnFailure as b, createServerFnTransportError as c, isServerFnFailure as i };

package/dist/server-fn.cjs

@@ -21,10 +21,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/server-fn.ts
 var server_fn_exports = {};
 __export(server_fn_exports, {
+  FARM_SERVER_FN_FAILURE_SYMBOL: () => FARM_SERVER_FN_FAILURE_SYMBOL,
   FARM_SERVER_FN_SYMBOL: () => FARM_SERVER_FN_SYMBOL,
+  ServerActionError: () => ServerActionError,
+  ServerFnFailure: () => ServerFnFailure,
   _parseServerFnSchema: () => _parseServerFnSchema,
   createServerFn: () => createServerFn,
-  createServerMiddleware: () => createServerMiddleware
+  createServerFnTransportError: () => createServerFnTransportError,
+  createServerMiddleware: () => createServerMiddleware,
+  isServerFnFailure: () => isServerFnFailure
 });
 module.exports = __toCommonJS(server_fn_exports);
 
@@ -67,6 +72,55 @@ function subscribeFarmCacheTask(listener) {
 }
 __name(subscribeFarmCacheTask, "subscribeFarmCacheTask");
 
+// src/server-fn-error.ts
+var FARM_SERVER_FN_FAILURE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn.failure");
+var _ServerFnFailure = class _ServerFnFailure extends Error {
+  constructor(code, data, options) {
+    super(options.message);
+    this.name = "ServerFnFailure";
+    this.code = code;
+    this.data = data;
+    this.status = options.status;
+    Object.defineProperty(this, FARM_SERVER_FN_FAILURE_SYMBOL, {
+      value: true,
+      enumerable: false
+    });
+  }
+};
+__name(_ServerFnFailure, "ServerFnFailure");
+var ServerFnFailure = _ServerFnFailure;
+var _ServerActionError = class _ServerActionError extends Error {
+  constructor(message = "Server function failed") {
+    super(message);
+    this.name = "ServerActionError";
+  }
+};
+__name(_ServerActionError, "ServerActionError");
+var ServerActionError = _ServerActionError;
+function isServerFnFailure(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate[FARM_SERVER_FN_FAILURE_SYMBOL] === true && candidate.name === "ServerFnFailure" && typeof candidate.code === "string" && Number.isInteger(candidate.status) && (candidate.status ?? 0) >= 400 && (candidate.status ?? 0) <= 599;
+}
+__name(isServerFnFailure, "isServerFnFailure");
+function createServerFnTransportError(value) {
+  if (isSerializedServerFnFailure(value)) {
+    return new ServerFnFailure(value.code, value.data, {
+      status: value.status,
+      message: value.message
+    });
+  }
+  const message = value && typeof value === "object" && "message" in value && typeof value.message === "string" ? value.message : "Server function failed";
+  return new ServerActionError(message);
+}
+__name(createServerFnTransportError, "createServerFnTransportError");
+function isSerializedServerFnFailure(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate.name === "ServerFnFailure" && typeof candidate.message === "string" && typeof candidate.code === "string" && Number.isInteger(candidate.status) && (candidate.status ?? 0) >= 400 && (candidate.status ?? 0) <= 599 && "data" in candidate;
+}
+__name(isSerializedServerFnFailure, "isSerializedServerFnFailure");
+
 // src/server-action-security.ts
 var SERVER_ACTION_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionStorage");
 var FALLBACK_ABORT_CONTROLLER_KEY = /* @__PURE__ */ Symbol.for("farm.serverActionFallbackAbortController");
@@ -877,6 +931,8 @@ function createServerFn(options) {
     throw new TypeError("createServerFn requires a handler function");
   }
   const middleware = resolveServerFnMiddleware(options.middleware);
+  const errors = normalizeServerFnErrors(options.errors);
+  const error = createServerFnErrorHandler(errors);
   const serverFn = /* @__PURE__ */ __name(async (value) => {
     const formData = isFormData(value) ? value : void 0;
     const rawInput = formData ? formDataToObject(formData) : value;
@@ -894,7 +950,7 @@ function createServerFn(options) {
     let resolvedContext = Object.freeze(/* @__PURE__ */ Object.create(null));
     const result = await runServerFnMiddleware(middleware, handlerContext, async (context) => {
       resolvedContext = context.context;
-      return options.handler(context);
+      return options.handler({ ...context, error });
     });
     const parsedResult = await _parseServerFnSchema(options.output, result, "output");
     if (options.invalidates) {
@@ -924,6 +980,10 @@ function createServerFn(options) {
       value: options.output,
       enumerable: false
     },
+    __farmServerFnError: {
+      value: void 0,
+      enumerable: false
+    },
     __farmServerFnMiddleware: {
       value: middleware,
       enumerable: false
@@ -962,6 +1022,78 @@ async function runServerFnMiddleware(middleware, handlerContext, handler) {
   return dispatch(0, Object.freeze(/* @__PURE__ */ Object.create(null)));
 }
 __name(runServerFnMiddleware, "runServerFnMiddleware");
+function normalizeServerFnErrors(definitions) {
+  if (definitions === void 0) return Object.freeze({});
+  if (!isPlainServerFnObject(definitions)) {
+    throw new TypeError("createServerFn errors must be an object");
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [code, definition] of Object.entries(definitions)) {
+    if (!code.trim()) {
+      throw new TypeError("Server function error codes cannot be empty");
+    }
+    if (!definition || typeof definition !== "object") {
+      throw new TypeError(`Server function error "${code}" must be an object`);
+    }
+    if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
+      throw new TypeError(
+        `Server function error "${code}" status must be an integer between 400 and 599`
+      );
+    }
+    if (!definition.data || typeof definition.data.parse !== "function" && typeof definition.data.safeParse !== "function") {
+      throw new TypeError(
+        `Server function error "${code}" data must provide synchronous parse() or safeParse()`
+      );
+    }
+    if (definition.message !== void 0 && typeof definition.message !== "string") {
+      throw new TypeError(`Server function error "${code}" message must be a string`);
+    }
+    normalized[code] = Object.freeze({ ...definition });
+  }
+  return Object.freeze(normalized);
+}
+__name(normalizeServerFnErrors, "normalizeServerFnErrors");
+function createServerFnErrorHandler(definitions) {
+  return ((code, data) => {
+    const definition = definitions[code];
+    if (!definition) {
+      throw new TypeError(`Server function error "${code}" is not declared`);
+    }
+    const parsed = parseServerFnFailureData(code, definition.data, data);
+    throw new ServerFnFailure(code, parsed, {
+      status: definition.status,
+      message: definition.message ?? "Server function failed"
+    });
+  });
+}
+__name(createServerFnErrorHandler, "createServerFnErrorHandler");
+function parseServerFnFailureData(code, schema, value) {
+  if (typeof schema.safeParse === "function") {
+    const result2 = schema.safeParse(value);
+    if (isPromiseLike(result2)) {
+      throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+    }
+    return unwrapSafeParseResult(result2);
+  }
+  const result = schema.parse(value);
+  if (isPromiseLike(result)) {
+    throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+  }
+  return result;
+}
+__name(parseServerFnFailureData, "parseServerFnFailureData");
+function isPlainServerFnObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainServerFnObject, "isPlainServerFnObject");
+function isPromiseLike(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function"
+  );
+}
+__name(isPromiseLike, "isPromiseLike");
 function resolveServerFnMiddleware(middleware) {
   const resolved = [];
   const seen = /* @__PURE__ */ new Set();
@@ -1058,9 +1190,14 @@ function isFormData(value) {
 __name(isFormData, "isFormData");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  FARM_SERVER_FN_FAILURE_SYMBOL,
   FARM_SERVER_FN_SYMBOL,
+  ServerActionError,
+  ServerFnFailure,
   _parseServerFnSchema,
   createServerFn,
-  createServerMiddleware
+  createServerFnTransportError,
+  createServerMiddleware,
+  isServerFnFailure
 });
 //# sourceMappingURL=server-fn.cjs.map