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

package/dist/api.cjs

@@ -1084,13 +1084,13 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
   }
   const middleware = normalizeEndpointMiddleware(options.middleware);
   const errors = normalizeEndpointErrors(options.errors);
-  const fail = createEndpointFail(errors);
+  const error = createEndpointErrorHandler(errors);
   const wrappedHandler = /* @__PURE__ */ __name((async (ctx) => {
     const execution = await runEndpointMiddleware(
       middleware,
       ctx,
       handler,
-      fail,
+      error,
       options.invalidates
     );
     return execution.result;
@@ -1110,7 +1110,7 @@ function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
   endpoint.__method = options.method || "GET";
   endpoint.__autoPath = !path4;
   endpoint.__handler = wrappedHandler;
-  endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, fail, options.invalidates);
+  endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, error, options.invalidates);
   endpoint.__middleware = middleware;
   endpoint.__sourceHandler = handler;
   endpoint.__invalidates = options.invalidates;
@@ -1145,8 +1145,9 @@ function normalizeEndpointErrors(definitions) {
     if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
       throw new TypeError(`Endpoint error "${code}" status must be an integer between 400 and 599`);
     }
-    if (!definition.schema || typeof definition.schema.parse !== "function") {
-      throw new TypeError(`Endpoint error "${code}" requires a schema with parse()`);
+    const dataSchema = resolveEndpointErrorSchema(definition);
+    if (!dataSchema || typeof dataSchema.parse !== "function") {
+      throw new TypeError(`Endpoint error "${code}" requires a data schema with parse()`);
     }
     if (definition.message !== void 0 && typeof definition.message !== "string") {
       throw new TypeError(`Endpoint error "${code}" message must be a string`);
@@ -1156,20 +1157,27 @@ function normalizeEndpointErrors(definitions) {
   return Object.freeze(normalized);
 }
 __name(normalizeEndpointErrors, "normalizeEndpointErrors");
-function createEndpointFail(definitions) {
+function resolveEndpointErrorSchema(definition) {
+  if (definition.data && definition.schema) {
+    throw new TypeError("Endpoint errors cannot define both data and schema");
+  }
+  return definition.data ?? definition.schema;
+}
+__name(resolveEndpointErrorSchema, "resolveEndpointErrorSchema");
+function createEndpointErrorHandler(definitions) {
   return ((code, data) => {
     const definition = definitions[code];
     if (!definition) {
       throw new TypeError(`Endpoint error "${code}" is not declared`);
     }
-    const parsed = definition.schema.parse(data);
+    const parsed = resolveEndpointErrorSchema(definition).parse(data);
     throw new EndpointFailure(code, parsed, {
       status: definition.status,
       message: definition.message ?? "Request failed"
     });
   });
 }
-__name(createEndpointFail, "createEndpointFail");
+__name(createEndpointErrorHandler, "createEndpointErrorHandler");
 function normalizeEndpointMiddleware(middleware) {
   if (middleware === void 0) return EMPTY_ENDPOINT_MIDDLEWARE;
   if (!Array.isArray(middleware)) {
@@ -1184,7 +1192,7 @@ function normalizeEndpointMiddleware(middleware) {
   return Object.freeze(normalized);
 }
 __name(normalizeEndpointMiddleware, "normalizeEndpointMiddleware");
-async function runEndpointMiddleware(middleware, handlerContext, handler, fail, invalidations) {
+async function runEndpointMiddleware(middleware, handlerContext, handler, error, invalidations) {
   let context = createInitialEndpointContext(handlerContext.context);
   for (let index = 0; index < middleware.length; index++) {
     const result2 = await middleware[index]({ ...handlerContext, context });
@@ -1212,7 +1220,7 @@ async function runEndpointMiddleware(middleware, handlerContext, handler, fail,
     }
     context = mergeEndpointContext(context, result2, index);
   }
-  const result = await handler({ ...handlerContext, context, fail });
+  const result = await handler({ ...handlerContext, context, error, fail: error });
   return {
     result,
     context,