@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-MEASUNVY.mjs

@@ -1,440 +0,0 @@
-import {
-  applyFarmCacheInvalidationTargets
-} from "./chunk-B2GSRB3P.mjs";
-import {
-  isMultipartSchema
-} from "./chunk-EMLAPBEM.mjs";
-import {
-  assertBrowserStableRoutePath,
-  assertUniqueRouteParameters,
-  getRoutePatternShape
-} from "./chunk-55YI3RRB.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.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 === "function") {
-    path = "";
-    options = {};
-    handler = pathOrOptions;
-  } else 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");
-  }
-  if (options.use !== void 0) {
-    throw new TypeError(
-      "createEndpoint does not support the `use` option. Move these functions to `middleware`: each receives the endpoint context and returns an object, true, false, or a Response."
-    );
-  }
-  const middleware = normalizeEndpointMiddleware(options.middleware);
-  const errors = normalizeEndpointErrors(options.errors);
-  const error = createEndpointErrorHandler(errors);
-  const wrappedHandler = /* @__PURE__ */ __name((async (ctx) => {
-    const execution = await runEndpointMiddleware(
-      middleware,
-      ctx,
-      handler,
-      error,
-      options.invalidates
-    );
-    return execution.result;
-  }), "wrappedHandler");
-  const {
-    middleware: _middleware,
-    errors: _errors,
-    invalidates: _invalidates,
-    openapi: _openapi,
-    mcp: _mcp,
-    ...betterCallOptions
-  } = options;
-  const endpoint = betterCallEndpoint(
-    path || "/__farm_auto_path__",
-    betterCallOptions,
-    wrappedHandler
-  );
-  endpoint.__path = path || void 0;
-  endpoint.__method = options.method || (path ? "GET" : void 0);
-  endpoint.__autoPath = !path;
-  endpoint.__handler = wrappedHandler;
-  endpoint.__farmInvoke = (ctx) => runEndpointMiddleware(middleware, ctx, handler, error, options.invalidates);
-  endpoint.__middleware = middleware;
-  endpoint.__sourceHandler = handler;
-  endpoint.__invalidates = options.invalidates;
-  endpoint.__errors = errors;
-  endpoint.__openapi = options.openapi;
-  endpoint.__mcp = options.mcp;
-  endpoint.__types = {
-    body: options.body,
-    inputBody: isMultipartSchema(options.body) ? "form-data" : options.body,
-    query: options.query,
-    inputQuery: 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`);
-    }
-    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`);
-    }
-    normalized[code] = Object.freeze({ ...definition });
-  }
-  return Object.freeze(normalized);
-}
-__name(normalizeEndpointErrors, "normalizeEndpointErrors");
-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 = resolveEndpointErrorSchema(definition).parse(data);
-    throw new EndpointFailure(code, parsed, {
-      status: definition.status,
-      message: definition.message ?? "Request failed"
-    });
-  });
-}
-__name(createEndpointErrorHandler, "createEndpointErrorHandler");
-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, error, 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, error, fail: error });
-  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 QUERY(...args) {
-  if (args.length === 1) {
-    return createEndpoint("", { method: "QUERY" }, args[0]);
-  }
-  return createEndpoint("", { ...args[0], method: "QUERY" }, args[1]);
-}
-__name(QUERY, "QUERY");
-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/route.ts
-var unavailablePluginLocalAPI = Object.freeze({
-  available: false,
-  get() {
-    return void 0;
-  },
-  list() {
-    return [];
-  }
-});
-function createRouteFactory() {
-  return createRouteFactoryAt("");
-}
-__name(createRouteFactory, "createRouteFactory");
-function createRouteFactoryAt(prefix) {
-  const factory = {
-    scope(child) {
-      return createRouteFactoryAt(joinRoutePath(prefix, child));
-    }
-  };
-  for (const method of [
-    "GET",
-    "HEAD",
-    "QUERY",
-    "POST",
-    "PUT",
-    "PATCH",
-    "DELETE",
-    "OPTIONS"
-  ]) {
-    factory[method.toLowerCase()] = (child, options) => {
-      const path = joinRoutePath(prefix, child);
-      const input = options.input ?? {};
-      const endpoint = createEndpoint(
-        path,
-        {
-          method,
-          body: input.body,
-          query: input.query,
-          headers: input.headers,
-          middleware: options.middleware,
-          mcp: options.mcp
-        },
-        (ctx) => options.handler(ctx.request, {
-          input: { body: ctx.body, query: ctx.query, headers: ctx.headers, params: ctx.params },
-          params: ctx.params,
-          context: ctx.context
-        })
-      );
-      endpoint.__types.params = input.params;
-      endpoint.__output = options.output;
-      return Object.freeze({ path, method, endpoint });
-    };
-  }
-  return Object.freeze(factory);
-}
-__name(createRouteFactoryAt, "createRouteFactoryAt");
-function joinRoutePath(prefix, child) {
-  if (typeof child !== "string") throw new TypeError("Route paths must be strings.");
-  const path = child === "" ? prefix : `${prefix}/${child.replace(/^\//, "")}`;
-  if (!(path === "/api" || path.startsWith("/api/")) || /[?#]|\/\/|\/$/.test(path)) {
-    throw new TypeError(
-      `Plugin route "${path}" must be a canonical /api path without a query, hash, or empty segment.`
-    );
-  }
-  assertBrowserStableRoutePath(path);
-  assertUniqueRouteParameters(path, "api");
-  getRoutePatternShape(path, "api");
-  for (const segment of path.split("/")) {
-    if (["__proto__", "constructor", "prototype", "$params"].includes(segment)) {
-      throw new TypeError(`Route segment "${segment}" is reserved.`);
-    }
-  }
-  return path;
-}
-__name(joinRoutePath, "joinRoutePath");
-function resolvePluginRoutes(plugins = [], context = {}) {
-  return plugins.flatMap((plugin) => {
-    if (!plugin.routes) return [];
-    const routes = plugin.routes({
-      route: createRouteFactory(),
-      api: context.api ?? unavailablePluginLocalAPI
-    });
-    if (!Array.isArray(routes))
-      throw new TypeError(`Plugin "${plugin.name}" routes must return an array synchronously.`);
-    for (const route of routes) {
-      if (!route || joinRoutePath("", route.path) !== route.path || typeof route.endpoint !== "function" || !["GET", "HEAD", "QUERY", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"].includes(
-        route.method
-      )) {
-        throw new TypeError(`Plugin "${plugin.name}" returned an invalid API route.`);
-      }
-    }
-    return routes;
-  });
-}
-__name(resolvePluginRoutes, "resolvePluginRoutes");
-
-export {
-  EndpointFailure,
-  isEndpointFailure,
-  createEndpoint,
-  GET,
-  HEAD,
-  QUERY,
-  POST,
-  PUT,
-  DELETE,
-  PATCH,
-  OPTIONS,
-  createRouteFactory,
-  resolvePluginRoutes
-};

package/dist/chunk-MGMF4VP7.mjs

@@ -1,102 +0,0 @@
-import {
-  getRequestSourceOrigin,
-  matchesAllowedOrigin,
-  matchesHostHeader,
-  normalizeAllowedOriginPattern
-} from "./chunk-FP2INE7H.mjs";
-import {
-  __name
-} from "./chunk-LPEX4YW6.mjs";
-
-// src/integration-request-security.ts
-function resolveIntegrationAllowedOrigins(values, label) {
-  return Object.freeze((values ?? []).map((value) => normalizeAllowedOriginPattern(value, label)));
-}
-__name(resolveIntegrationAllowedOrigins, "resolveIntegrationAllowedOrigins");
-function validateIntegrationRequestOrigin(request, policy = {}) {
-  const allowedOrigins = policy.allowedOrigins ?? [];
-  const requireOriginMetadata = policy.requireOriginMetadata ?? true;
-  const fetchSite = request.headers.get("sec-fetch-site")?.trim().toLowerCase();
-  const source = getRequestSourceOrigin(request);
-  if (!source.ok) {
-    return { ok: false, reason: source.reason };
-  }
-  if (source.origin === null) {
-    if (fetchSite === "same-origin") {
-      return { ok: true };
-    }
-    if (requireOriginMetadata) {
-      return { ok: false, reason: fetchSite === "cross-site" ? "cross-site" : "missing-origin" };
-    }
-    return fetchSite === "cross-site" ? { ok: false, reason: "cross-site" } : { ok: true };
-  }
-  const requestUrl = new URL(request.url);
-  const matchesConfiguredOrigin = allowedOrigins.some(
-    (pattern) => matchesAllowedOrigin(source.origin, pattern)
-  );
-  const matchesRequest = source.origin === requestUrl.origin || matchesHostHeader(source.origin, request);
-  if (!matchesRequest && !matchesConfiguredOrigin) {
-    return { ok: false, reason: "cross-site" };
-  }
-  if (fetchSite === "cross-site" && !matchesConfiguredOrigin) {
-    return { ok: false, reason: "cross-site" };
-  }
-  return { ok: true };
-}
-__name(validateIntegrationRequestOrigin, "validateIntegrationRequestOrigin");
-function describeIntegrationOriginRejection(reason) {
-  switch (reason) {
-    case "missing-origin":
-      return "Request is missing same-origin metadata.";
-    case "opaque-origin":
-      return "Opaque origins are not allowed.";
-    case "invalid-origin":
-      return "Invalid request origin.";
-    case "cross-site":
-      return "Cross-site request was rejected.";
-  }
-}
-__name(describeIntegrationOriginRejection, "describeIntegrationOriginRejection");
-
-// src/api/route-schema.ts
-async function parseRouteSchema(schema, value) {
-  if (schema.parseAsync) return schema.parseAsync(value);
-  if (schema["~standard"]) {
-    const result = await schema["~standard"].validate(value);
-    if (result.issues)
-      throw Object.assign(new Error("Validation failed"), { issues: result.issues });
-    return result.value;
-  }
-  if (schema.parse) return schema.parse(value);
-  throw new TypeError("Route validators must implement Standard Schema or parse().");
-}
-__name(parseRouteSchema, "parseRouteSchema");
-var PUBLIC_MESSAGE_CODES = /* @__PURE__ */ new Set(["custom", "invalid_type"]);
-function toPublicValidationIssues(error) {
-  const issues = error?.issues;
-  const list = Array.isArray(issues) ? issues : Array.isArray(error?.errors) ? error.errors : [];
-  return list.map((issue) => {
-    const { path, code, message } = issue ?? {};
-    return {
-      path: Array.isArray(path) ? path.map(toPublicPathSegment) : [],
-      ...typeof code === "string" ? { code } : {},
-      message: PUBLIC_MESSAGE_CODES.has(code) && typeof message === "string" && message ? message : "Invalid value"
-    };
-  });
-}
-__name(toPublicValidationIssues, "toPublicValidationIssues");
-function toPublicPathSegment(segment) {
-  const key = segment && typeof segment === "object" && "key" in segment ? segment.key : segment;
-  if (typeof key === "number") return key;
-  if (typeof key === "symbol") return key.description || key.toString();
-  return String(key);
-}
-__name(toPublicPathSegment, "toPublicPathSegment");
-
-export {
-  resolveIntegrationAllowedOrigins,
-  validateIntegrationRequestOrigin,
-  describeIntegrationOriginRejection,
-  parseRouteSchema,
-  toPublicValidationIssues
-};