@farm.js/core 0.1.0-beta.4 → 0.1.0-beta.6

package/dist/chunk-PFE6GMNE.mjs

@@ -1,603 +0,0 @@
-import {
-  _runWithCurrentRequest
-} from "./chunk-RHIFZZUI.mjs";
-import {
-  isMultipartSchema
-} from "./chunk-ALCLXXTY.mjs";
-import {
-  applyFarmCacheInvalidationTargets
-} from "./chunk-V3XURYJO.mjs";
-import {
-  FARM_CACHE_INVALIDATION_HEADER,
-  decodeFarmCacheInvalidations,
-  encodeFarmCacheInvalidations
-} from "./chunk-RBRLLZL5.mjs";
-import {
-  __name
-} from "./chunk-CGILA3WO.mjs";
-
-// src/api/endpoint.ts
-import { createEndpoint as betterCallEndpoint } from "better-call";
-var _EndpointFailure = class _EndpointFailure extends Error {
-  constructor(code, data, options) {
-    super(options.message);
-    this.name = "EndpointFailure";
-    this.code = code;
-    this.data = data;
-    this.status = options.status;
-  }
-};
-__name(_EndpointFailure, "EndpointFailure");
-var EndpointFailure = _EndpointFailure;
-function isEndpointFailure(value) {
-  return value instanceof EndpointFailure;
-}
-__name(isEndpointFailure, "isEndpointFailure");
-function createEndpoint(pathOrOptions, optionsOrHandler, maybeHandler) {
-  let path;
-  let options;
-  let handler;
-  if (typeof pathOrOptions === "string") {
-    path = pathOrOptions;
-    options = optionsOrHandler;
-    handler = maybeHandler;
-  } else {
-    path = "";
-    options = pathOrOptions;
-    handler = optionsOrHandler;
-  }
-  if (typeof handler !== "function") {
-    throw new TypeError("createEndpoint requires a handler function");
-  }
-  const middleware = normalizeEndpointMiddleware(options.middleware);
-  const errors = normalizeEndpointErrors(options.errors);
-  const fail = createEndpointFail(errors);
-  const wrappedHandler = /* @__PURE__ */ __name((async (ctx) => {
-    const execution = await runEndpointMiddleware(
-      middleware,
-      ctx,
-      handler,
-      fail,
-      options.invalidates
-    );
-    return execution.result;
-  }), "wrappedHandler");
-  const {
-    middleware: _middleware,
-    errors: _errors,
-    invalidates: _invalidates,
-    ...betterCallOptions
-  } = options;
-  const endpoint = betterCallEndpoint(
-    path || "/__farm_auto_path__",
-    betterCallOptions,
-    wrappedHandler
-  );
-  endpoint.__path = path || void 0;
-  endpoint.__method = options.method || "GET";
-  endpoint.__autoPath = !path;
-  endpoint.__handler = wrappedHandler;
-  endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, fail, options.invalidates);
-  endpoint.__middleware = middleware;
-  endpoint.__sourceHandler = handler;
-  endpoint.__invalidates = options.invalidates;
-  endpoint.__errors = errors;
-  endpoint.__types = {
-    body: options.body,
-    inputBody: isMultipartSchema(options.body) ? "form-data" : options.body,
-    query: options.query,
-    headers: options.headers,
-    response: null,
-    errors
-  };
-  return endpoint;
-}
-__name(createEndpoint, "createEndpoint");
-var EMPTY_ENDPOINT_MIDDLEWARE = Object.freeze([]);
-var EMPTY_ENDPOINT_CONTEXT = Object.freeze(/* @__PURE__ */ Object.create(null));
-var UNSAFE_ENDPOINT_CONTEXT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function normalizeEndpointErrors(definitions) {
-  if (definitions === void 0) return Object.freeze({});
-  if (!isPlainEndpointContext(definitions)) {
-    throw new TypeError("createEndpoint 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("Endpoint error codes cannot be empty");
-    }
-    if (!definition || typeof definition !== "object") {
-      throw new TypeError(`Endpoint error "${code}" must be an object`);
-    }
-    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()`);
-    }
-    if (definition.message !== void 0 && typeof definition.message !== "string") {
-      throw new TypeError(`Endpoint error "${code}" message must be a string`);
-    }
-    normalized[code] = Object.freeze({ ...definition });
-  }
-  return Object.freeze(normalized);
-}
-__name(normalizeEndpointErrors, "normalizeEndpointErrors");
-function createEndpointFail(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);
-    throw new EndpointFailure(code, parsed, {
-      status: definition.status,
-      message: definition.message ?? "Request failed"
-    });
-  });
-}
-__name(createEndpointFail, "createEndpointFail");
-function normalizeEndpointMiddleware(middleware) {
-  if (middleware === void 0) return EMPTY_ENDPOINT_MIDDLEWARE;
-  if (!Array.isArray(middleware)) {
-    throw new TypeError("createEndpoint middleware must be an array of functions");
-  }
-  const normalized = [...middleware];
-  for (const entry of normalized) {
-    if (typeof entry !== "function") {
-      throw new TypeError("createEndpoint middleware entries must be functions");
-    }
-  }
-  return Object.freeze(normalized);
-}
-__name(normalizeEndpointMiddleware, "normalizeEndpointMiddleware");
-async function runEndpointMiddleware(middleware, handlerContext, handler, fail, invalidations) {
-  let context = createInitialEndpointContext(handlerContext.context);
-  for (let index = 0; index < middleware.length; index++) {
-    const result2 = await middleware[index]({ ...handlerContext, context });
-    if (isEndpointResponse(result2)) {
-      return {
-        result: result2,
-        context,
-        handlerExecuted: false,
-        invalidations: []
-      };
-    }
-    if (result2 === false) {
-      return {
-        result: forbiddenEndpointResponse(),
-        context,
-        handlerExecuted: false,
-        invalidations: []
-      };
-    }
-    if (result2 === true) continue;
-    if (!isPlainEndpointContext(result2)) {
-      throw new TypeError(
-        `Endpoint middleware ${index + 1} must return an object, true, false, or a Response`
-      );
-    }
-    context = mergeEndpointContext(context, result2, index);
-  }
-  const result = await handler({ ...handlerContext, context, fail });
-  return {
-    result,
-    context,
-    handlerExecuted: true,
-    invalidations: await applyEndpointInvalidations(
-      invalidations,
-      {
-        ...handlerContext,
-        context,
-        result
-      },
-      result
-    )
-  };
-}
-__name(runEndpointMiddleware, "runEndpointMiddleware");
-async function applyEndpointInvalidations(declaration, context, result) {
-  if (!declaration || isEndpointResponse(result) && result.status >= 400) {
-    return [];
-  }
-  const targets = typeof declaration === "function" ? await declaration(context) : declaration;
-  if (!Array.isArray(targets)) {
-    throw new TypeError(
-      "Endpoint invalidates must resolve to an array of { key }, { path }, or { tag } targets"
-    );
-  }
-  return applyFarmCacheInvalidationTargets(targets);
-}
-__name(applyEndpointInvalidations, "applyEndpointInvalidations");
-function createInitialEndpointContext(value) {
-  if (value === void 0 || value === null) return EMPTY_ENDPOINT_CONTEXT;
-  if (!isPlainEndpointContext(value)) {
-    throw new TypeError("Endpoint context must be a plain object");
-  }
-  return mergeEndpointContext(EMPTY_ENDPOINT_CONTEXT, value);
-}
-__name(createInitialEndpointContext, "createInitialEndpointContext");
-function mergeEndpointContext(current, added, middlewareIndex) {
-  const next = Object.assign(/* @__PURE__ */ Object.create(null), current);
-  for (const key of Reflect.ownKeys(added)) {
-    if (!Object.prototype.propertyIsEnumerable.call(added, key)) continue;
-    if (typeof key === "string" && UNSAFE_ENDPOINT_CONTEXT_KEYS.has(key)) {
-      throw new TypeError(`Endpoint middleware cannot provide the unsafe context key "${key}"`);
-    }
-    if (Object.prototype.hasOwnProperty.call(current, key)) {
-      const source = middlewareIndex === void 0 ? "Endpoint context" : `Endpoint middleware ${middlewareIndex + 1}`;
-      throw new TypeError(`${source} cannot replace the existing context key "${String(key)}"`);
-    }
-    next[key] = added[key];
-  }
-  return Object.freeze(next);
-}
-__name(mergeEndpointContext, "mergeEndpointContext");
-function isPlainEndpointContext(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-__name(isPlainEndpointContext, "isPlainEndpointContext");
-function isEndpointResponse(value) {
-  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
-}
-__name(isEndpointResponse, "isEndpointResponse");
-function forbiddenEndpointResponse() {
-  return new Response(JSON.stringify({ error: "Forbidden" }), {
-    status: 403,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-__name(forbiddenEndpointResponse, "forbiddenEndpointResponse");
-function GET(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "GET" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "GET" }, args[1]);
-}
-__name(GET, "GET");
-function HEAD(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "HEAD" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "HEAD" }, args[1]);
-}
-__name(HEAD, "HEAD");
-function POST(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "POST" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "POST" }, args[1]);
-}
-__name(POST, "POST");
-function PUT(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "PUT" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "PUT" }, args[1]);
-}
-__name(PUT, "PUT");
-function DELETE(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "DELETE" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "DELETE" }, args[1]);
-}
-__name(DELETE, "DELETE");
-function PATCH(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "PATCH" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "PATCH" }, args[1]);
-}
-__name(PATCH, "PATCH");
-function OPTIONS(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "OPTIONS" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "OPTIONS" }, args[1]);
-}
-__name(OPTIONS, "OPTIONS");
-
-// src/api/runtime.ts
-function matchAPIRoute(routes, pathname) {
-  const exactRoute = routes.get(pathname);
-  if (exactRoute) {
-    return { route: exactRoute, params: {} };
-  }
-  const normalizedPathname = normalizePathname(pathname);
-  if (normalizedPathname !== pathname) {
-    const normalizedRoute = routes.get(normalizedPathname);
-    if (normalizedRoute) {
-      return { route: normalizedRoute, params: {} };
-    }
-  }
-  for (const route of routes.values()) {
-    const params = matchRoutePath(route.path, pathname);
-    if (params) {
-      return { route, params };
-    }
-  }
-  return null;
-}
-__name(matchAPIRoute, "matchAPIRoute");
-async function invokeAPIRouteEndpoint(endpoint, request, params = {}) {
-  return _runWithCurrentRequest(
-    request,
-    () => invokeAPIRouteEndpointInContext(endpoint, request, params)
-  );
-}
-__name(invokeAPIRouteEndpoint, "invokeAPIRouteEndpoint");
-async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
-  const farmHandler = endpoint.__handler || (isFarmContextHandler(endpoint) ? endpoint : null);
-  if (!farmHandler) {
-    const result = await endpoint(request, {
-      params: Promise.resolve(params)
-    });
-    return normalizeRouteResponse(result);
-  }
-  const url = new URL(request.url);
-  const query = {};
-  url.searchParams.forEach((value, key) => {
-    query[key] = value;
-  });
-  let body = void 0;
-  if (request.method.toUpperCase() !== "GET" && request.method.toUpperCase() !== "HEAD") {
-    body = await readRequestBody(request);
-  }
-  const headers = Object.fromEntries(request.headers.entries());
-  const types = endpoint.__types || {};
-  const queryValidation = validateInput(types.query, query, "Invalid query parameters");
-  if (queryValidation instanceof Response) {
-    return queryValidation;
-  }
-  const bodyValidation = validateInput(types.body, body, "Invalid request body");
-  if (bodyValidation instanceof Response) {
-    return bodyValidation;
-  }
-  const headersValidation = validateInput(types.headers, headers, "Invalid request headers");
-  if (headersValidation instanceof Response) {
-    return headersValidation;
-  }
-  const handlerContext = {
-    query: queryValidation,
-    body: bodyValidation,
-    headers: headersValidation,
-    request,
-    context: {},
-    params
-  };
-  let execution;
-  try {
-    execution = typeof endpoint.__farmInvoke === "function" ? await endpoint.__farmInvoke(handlerContext) : {
-      result: await farmHandler(handlerContext),
-      context: handlerContext.context,
-      handlerExecuted: true,
-      invalidations: []
-    };
-  } catch (error) {
-    if (isEndpointFailure(error)) {
-      return createEndpointFailureResponse(error);
-    }
-    throw error;
-  }
-  const response = normalizeRouteResponse(execution.result);
-  return attachEndpointInvalidations(response, execution.invalidations);
-}
-__name(invokeAPIRouteEndpointInContext, "invokeAPIRouteEndpointInContext");
-function normalizeRouteResponse(result) {
-  if (isWebResponse(result)) {
-    return result;
-  }
-  if (result === void 0) {
-    return new Response(null, { status: 204 });
-  }
-  return new Response(JSON.stringify(result), {
-    status: 200,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-__name(normalizeRouteResponse, "normalizeRouteResponse");
-function isWebResponse(value) {
-  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
-}
-__name(isWebResponse, "isWebResponse");
-function attachEndpointInvalidations(response, keys) {
-  const existing = decodeFarmCacheInvalidations(
-    response.headers.get(FARM_CACHE_INVALIDATION_HEADER)
-  );
-  const encoded = encodeFarmCacheInvalidations([...existing, ...keys]);
-  if (!encoded) return response;
-  const headers = new Headers(response.headers);
-  headers.set(FARM_CACHE_INVALIDATION_HEADER, encoded);
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
-__name(attachEndpointInvalidations, "attachEndpointInvalidations");
-function createEndpointFailureResponse(failure) {
-  return new Response(
-    JSON.stringify({
-      error: {
-        code: failure.code,
-        message: failure.message,
-        data: failure.data
-      }
-    }),
-    {
-      status: failure.status,
-      headers: {
-        "cache-control": "no-store",
-        "content-type": "application/json"
-      }
-    }
-  );
-}
-__name(createEndpointFailureResponse, "createEndpointFailureResponse");
-function isFarmContextHandler(endpoint) {
-  if (typeof endpoint !== "function") {
-    return false;
-  }
-  const source = Function.prototype.toString.call(endpoint).trim();
-  const arrowMatch = source.match(/^(?:async\s*)?(?:\(([^)]*)\)|([A-Za-z_$][\w$]*))\s*=>/);
-  const functionMatch = source.match(/^(?:async\s*)?function[^(]*\(([^)]*)\)/);
-  const firstParameter = (arrowMatch?.[1] || arrowMatch?.[2] || functionMatch?.[1] || "").split(",")[0].trim();
-  return firstParameter === "ctx" || firstParameter === "context" || firstParameter.startsWith("{");
-}
-__name(isFarmContextHandler, "isFarmContextHandler");
-async function readRequestBody(request) {
-  const contentType = request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
-  try {
-    if (contentType === "multipart/form-data") {
-      return formDataToObject(await request.clone().formData());
-    }
-    const text = await request.clone().text();
-    if (!text) return void 0;
-    if (contentType === "application/x-www-form-urlencoded") {
-      return searchParamsToObject(new URLSearchParams(text));
-    }
-    if (contentType === "application/json" || contentType?.endsWith("+json")) {
-      return JSON.parse(text);
-    }
-    return JSON.parse(text);
-  } catch {
-  }
-  return void 0;
-}
-__name(readRequestBody, "readRequestBody");
-function formDataToObject(formData) {
-  return entriesToObject(formData.entries());
-}
-__name(formDataToObject, "formDataToObject");
-function searchParamsToObject(searchParams) {
-  return entriesToObject(searchParams.entries());
-}
-__name(searchParamsToObject, "searchParamsToObject");
-function entriesToObject(entries) {
-  const output = /* @__PURE__ */ Object.create(null);
-  for (const [key, value] of entries) {
-    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
-    const current = output[key];
-    if (current === void 0) {
-      output[key] = value;
-    } else if (Array.isArray(current)) {
-      current.push(value);
-    } else {
-      output[key] = [current, value];
-    }
-  }
-  return output;
-}
-__name(entriesToObject, "entriesToObject");
-function validateInput(schema, value, error) {
-  if (!schema || typeof schema.parse !== "function") {
-    return value;
-  }
-  try {
-    return schema.parse(value);
-  } catch (validationError) {
-    return new Response(
-      JSON.stringify({
-        error,
-        details: validationError.errors || validationError.issues || validationError.message
-      }),
-      {
-        status: 400,
-        headers: { "Content-Type": "application/json" }
-      }
-    );
-  }
-}
-__name(validateInput, "validateInput");
-function matchRoutePath(routePath, pathname) {
-  const routeSegments = getPathSegments(routePath);
-  const pathnameSegments = getPathSegments(pathname);
-  const params = {};
-  let pathIndex = 0;
-  for (const routeSegment of routeSegments) {
-    const dynamicSegment = parseDynamicSegment(routeSegment);
-    if (dynamicSegment?.catchAll) {
-      const remainingSegments = pathnameSegments.slice(pathIndex).map(decodePathSegment);
-      if (remainingSegments.length === 0 && !dynamicSegment.optional) {
-        return null;
-      }
-      if (remainingSegments.length > 0) {
-        params[dynamicSegment.name] = remainingSegments;
-      }
-      pathIndex = pathnameSegments.length;
-      continue;
-    }
-    const pathnameSegment = pathnameSegments[pathIndex];
-    if (pathnameSegment === void 0) {
-      return null;
-    }
-    if (dynamicSegment) {
-      params[dynamicSegment.name] = decodePathSegment(pathnameSegment);
-      pathIndex++;
-      continue;
-    }
-    if (routeSegment !== pathnameSegment) {
-      return null;
-    }
-    pathIndex++;
-  }
-  return pathIndex === pathnameSegments.length ? params : null;
-}
-__name(matchRoutePath, "matchRoutePath");
-function getPathSegments(pathname) {
-  return normalizePathname(pathname).split("/").filter((segment) => segment.length > 0);
-}
-__name(getPathSegments, "getPathSegments");
-function normalizePathname(pathname) {
-  if (pathname.length > 1 && pathname.endsWith("/")) {
-    return pathname.replace(/\/+$/, "");
-  }
-  return pathname;
-}
-__name(normalizePathname, "normalizePathname");
-function parseDynamicSegment(segment) {
-  const optionalCatchAll = segment.match(/^\[\[\.\.\.(.+)\]\]$/);
-  if (optionalCatchAll?.[1]) {
-    return { name: optionalCatchAll[1], catchAll: true, optional: true };
-  }
-  const catchAll = segment.match(/^\[\.\.\.(.+)\]$/);
-  if (catchAll?.[1]) {
-    return { name: catchAll[1], catchAll: true, optional: false };
-  }
-  const dynamic = segment.match(/^\[(.+)\]$/);
-  if (dynamic?.[1]) {
-    return { name: dynamic[1], catchAll: false, optional: false };
-  }
-  return null;
-}
-__name(parseDynamicSegment, "parseDynamicSegment");
-function decodePathSegment(segment) {
-  try {
-    return decodeURIComponent(segment);
-  } catch {
-    return segment;
-  }
-}
-__name(decodePathSegment, "decodePathSegment");
-
-export {
-  EndpointFailure,
-  isEndpointFailure,
-  createEndpoint,
-  GET,
-  HEAD,
-  POST,
-  PUT,
-  DELETE,
-  PATCH,
-  OPTIONS,
-  matchAPIRoute,
-  invokeAPIRouteEndpoint,
-  normalizeRouteResponse,
-  isWebResponse,
-  createEndpointFailureResponse
-};
-//# sourceMappingURL=chunk-PFE6GMNE.mjs.map