@farm.js/core 0.1.0-beta.13 → 0.1.0-beta.16

package/dist/server-query.cjs

@@ -806,6 +806,26 @@ __name(stableSerialize, "stableSerialize");
 
 // src/server-action-security.ts
 var import_node_async_hooks = require("async_hooks");
+
+// 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;
+
+// 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");
 function getServerActionExecutionContext() {
@@ -858,6 +878,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;
@@ -875,7 +897,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) {
@@ -905,6 +927,10 @@ function createServerFn(options) {
       value: options.output,
       enumerable: false
     },
+    __farmServerFnError: {
+      value: void 0,
+      enumerable: false
+    },
     __farmServerFnMiddleware: {
       value: middleware,
       enumerable: false
@@ -943,6 +969,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();