@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-4PNUXIVU.cjs

@@ -0,0 +1,472 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkWPYFSQKKcjs = require('./chunk-WPYFSQKK.cjs');
+
+
+
+var _chunkI4J452B7cjs = require('./chunk-I4J452B7.cjs');
+
+
+var _chunkWMAPPDMMcjs = require('./chunk-WMAPPDMM.cjs');
+
+
+var _chunkTKJZFIMLcjs = require('./chunk-TKJZFIML.cjs');
+
+
+
+
+var _chunkEM6SBQKMcjs = require('./chunk-EM6SBQKM.cjs');
+
+
+
+var _chunkG7HXGLECcjs = require('./chunk-G7HXGLEC.cjs');
+
+
+
+var _chunkS3A45T7Fcjs = require('./chunk-S3A45T7F.cjs');
+
+
+
+
+var _chunkZEG3OPIBcjs = require('./chunk-ZEG3OPIB.cjs');
+
+
+var _chunk5ZSWG4UXcjs = require('./chunk-5ZSWG4UX.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// 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().");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, parseRouteSchema, "parseRouteSchema");
+
+// src/api/plugin-route-runtime.ts
+function mergePluginAPIRoutes(existing, plugins, expected, options = {}) {
+  const routes = /* @__PURE__ */ new Map();
+  const shapes = /* @__PURE__ */ new Map();
+  for (const route of existing) {
+    _chunkWMAPPDMMcjs.registerAPIRouteShape.call(void 0, shapes, route.path, route.filePath || route.path, "app");
+    routes.set(route.path, {
+      ...route,
+      filePath: route.filePath || "",
+      methods: [...route.methods],
+      endpoints: { ...route.endpoints }
+    });
+  }
+  const api = createPluginLocalAPI(existing, options.bodySizeLimit);
+  for (const definition of _chunkI4J452B7cjs.resolvePluginRoutes.call(void 0, plugins, { api })) {
+    _chunkWMAPPDMMcjs.registerAPIRouteShape.call(void 0, shapes, definition.path, `plugin:${definition.path}`, "app");
+    let route = routes.get(definition.path);
+    if (_optionalChain([route, 'optionalAccess', _ => _.methods, 'access', _2 => _2.includes, 'call', _3 => _3(definition.method)])) {
+      throw new Error(
+        `Duplicate API route for ${definition.method} ${definition.path}. Plugin routes cannot override app or other plugin endpoints.`
+      );
+    }
+    if (!route) {
+      route = { path: definition.path, filePath: "", methods: [], endpoints: {} };
+      routes.set(definition.path, route);
+    }
+    route.methods.push(definition.method);
+    route.pluginMethods = [..._nullishCoalesce(route.pluginMethods, () => ( [])), definition.method];
+    route.endpoints[definition.method] = definition.endpoint;
+  }
+  const result = [...routes.values()];
+  if (expected) {
+    const signature = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (entries) => entries.map(({ path, methods }) => `${path}:${[...methods].sort().join(",")}`).sort().join("\n"), "signature");
+    const actualSignature = signature(result);
+    const expectedSignature = signature(expected);
+    if (actualSignature !== expectedSignature) {
+      throw new Error(
+        `Plugin API routes changed between build and runtime. Route paths and methods must be stable across environments; rebuild the app.
+Expected:
+${expectedSignature || "(none)"}
+Received:
+${actualSignature || "(none)"}`
+      );
+    }
+  }
+  return result;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, mergePluginAPIRoutes, "mergePluginAPIRoutes");
+function createPluginLocalAPI(routes, bodySizeLimit) {
+  const endpoints = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    for (const method of route.methods) {
+      const normalizedMethod = method.toUpperCase();
+      const endpoint = route.endpoints[normalizedMethod];
+      if (typeof endpoint !== "function") continue;
+      const descriptor = Object.freeze({
+        path: route.path,
+        method: normalizedMethod,
+        input: Object.freeze({
+          body: _optionalChain([endpoint, 'access', _4 => _4.__types, 'optionalAccess', _5 => _5.body]),
+          query: _optionalChain([endpoint, 'access', _6 => _6.__types, 'optionalAccess', _7 => _7.query]),
+          params: _optionalChain([endpoint, 'access', _8 => _8.__types, 'optionalAccess', _9 => _9.params]),
+          headers: _optionalChain([endpoint, 'access', _10 => _10.__types, 'optionalAccess', _11 => _11.headers])
+        }),
+        output: endpoint.__output,
+        mcp: endpoint.__mcp === true ? true : endpoint.__mcp ? Object.freeze({ ...endpoint.__mcp }) : void 0,
+        invoke(request, params = {}) {
+          return invokeAPIRouteEndpoint(endpoint, request, { ...params }, bodySizeLimit);
+        }
+      });
+      endpoints.set(`${normalizedMethod} ${route.path}`, descriptor);
+    }
+  }
+  const listedEndpoints = Object.freeze(Array.from(endpoints.values()));
+  return Object.freeze({
+    available: true,
+    get(method, path) {
+      return endpoints.get(`${method.toUpperCase()} ${path}`);
+    },
+    list() {
+      return listedEndpoints;
+    }
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createPluginLocalAPI, "createPluginLocalAPI");
+
+// src/api/runtime.ts
+var API_ROUTE_METHODS = [
+  "GET",
+  "HEAD",
+  "QUERY",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "OPTIONS"
+];
+function resolveAPIRouteEndpoint(route, method) {
+  const normalizedMethod = method.toUpperCase();
+  return _nullishCoalesce(route.endpoints[normalizedMethod], () => ( (normalizedMethod === "HEAD" ? route.endpoints.GET : void 0)));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveAPIRouteEndpoint, "resolveAPIRouteEndpoint");
+function getAllowedAPIRouteMethods(route) {
+  const methods = [...route.methods];
+  const getIndex = methods.indexOf("GET");
+  if (getIndex >= 0 && !methods.includes("HEAD")) {
+    methods.splice(getIndex + 1, 0, "HEAD");
+  }
+  return methods;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getAllowedAPIRouteMethods, "getAllowedAPIRouteMethods");
+function matchAPIRouteAtBasePath(routes, pathname, serverBasePath = _chunkS3A45T7Fcjs.DEFAULT_FARM_API_BASE_PATH) {
+  const directMatch = _chunkG7HXGLECcjs.matchAPIRoute.call(void 0, routes, pathname);
+  if (directMatch) return directMatch;
+  const canonicalPathname = _chunkWPYFSQKKcjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
+  return canonicalPathname === pathname ? null : _chunkG7HXGLECcjs.matchAPIRoute.call(void 0, routes, canonicalPathname);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, matchAPIRouteAtBasePath, "matchAPIRouteAtBasePath");
+function createStaticAPIRouteMatcherAtBasePath(routes, serverBasePath = _chunkS3A45T7Fcjs.DEFAULT_FARM_API_BASE_PATH) {
+  const match = _chunkG7HXGLECcjs.createStaticAPIRouteMatcher.call(void 0, routes);
+  return (pathname) => {
+    const directMatch = match(pathname);
+    if (directMatch) return directMatch;
+    const canonicalPathname = _chunkWPYFSQKKcjs.resolveFarmAPICanonicalPathname.call(void 0, pathname, serverBasePath);
+    return canonicalPathname === pathname ? null : match(canonicalPathname);
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createStaticAPIRouteMatcherAtBasePath, "createStaticAPIRouteMatcherAtBasePath");
+function isFarmAPIPathname(pathname, serverBasePath = _chunkS3A45T7Fcjs.DEFAULT_FARM_API_BASE_PATH) {
+  const basePath = _chunkS3A45T7Fcjs.normalizeFarmAPIBasePath.call(void 0, serverBasePath);
+  return basePath !== "/" && (pathname === basePath || pathname.startsWith(`${basePath}/`));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isFarmAPIPathname, "isFarmAPIPathname");
+async function invokeAPIRouteEndpoint(endpoint, request, params = {}, bodySizeLimit = _chunkEM6SBQKMcjs.DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT) {
+  try {
+    request = await _chunkEM6SBQKMcjs.bufferFarmRequestBody.call(void 0, request, bodySizeLimit);
+  } catch (error) {
+    const response2 = _chunkEM6SBQKMcjs.createFarmRequestBodyErrorResponse.call(void 0, error);
+    if (response2) return response2;
+    throw error;
+  }
+  const response = await _chunk5ZSWG4UXcjs._runWithCurrentRequest.call(void 0, 
+    request,
+    () => invokeAPIRouteEndpointInContext(endpoint, request, params)
+  );
+  if (request.method.toUpperCase() !== "HEAD") {
+    return response;
+  }
+  return _chunkTKJZFIMLcjs.omitFarmResponseBody.call(void 0, response);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, invokeAPIRouteEndpoint, "invokeAPIRouteEndpoint");
+async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
+  const queryContentTypeError = validateQueryContentType(request);
+  if (queryContentTypeError) {
+    return queryContentTypeError;
+  }
+  const farmHandler = endpoint.__handler || null;
+  if (!farmHandler) {
+    const result = await endpoint(request, {
+      params: Promise.resolve(params)
+    });
+    return normalizeRouteResponse(result);
+  }
+  const url = new URL(request.url);
+  const query = {
+    ...searchParamsToObject(url.searchParams)
+  };
+  let body = void 0;
+  if (request.method.toUpperCase() !== "GET" && request.method.toUpperCase() !== "HEAD") {
+    const parsedBody = await readRequestBody(request);
+    if (parsedBody.error) return parsedBody.error;
+    body = parsedBody.body;
+  }
+  const headers = Object.fromEntries(request.headers.entries());
+  const types = endpoint.__types || {};
+  const queryValidation = await validateInput(types.query, query, "Invalid query parameters");
+  if (queryValidation instanceof Response) {
+    return queryValidation;
+  }
+  const bodyValidation = await validateInput(types.body, body, "Invalid request body");
+  if (bodyValidation instanceof Response) {
+    return bodyValidation;
+  }
+  const headersValidation = await validateInput(types.headers, headers, "Invalid request headers");
+  if (headersValidation instanceof Response) {
+    return headersValidation;
+  }
+  const paramsValidation = await validateInput(types.params, params, "Invalid route parameters");
+  if (paramsValidation instanceof Response) return paramsValidation;
+  const handlerContext = {
+    query: queryValidation,
+    body: bodyValidation,
+    headers: headersValidation,
+    request,
+    context: {},
+    params: paramsValidation
+  };
+  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 (_chunkI4J452B7cjs.isEndpointFailure.call(void 0, error)) {
+      return createEndpointFailureResponse(error);
+    }
+    throw error;
+  }
+  if (execution.handlerExecuted && endpoint.__output && !isWebResponse(execution.result)) {
+    try {
+      execution.result = await parseRouteSchema(endpoint.__output, execution.result);
+    } catch (e) {
+      throw new Error("API route returned a value that does not match its output schema.");
+    }
+  }
+  const response = normalizeRouteResponse(execution.result);
+  return attachEndpointInvalidations(response, execution.invalidations);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, invokeAPIRouteEndpointInContext, "invokeAPIRouteEndpointInContext");
+function validateQueryContentType(request) {
+  if (request.method.toUpperCase() !== "QUERY" || request.headers.has("content-type")) {
+    return null;
+  }
+  return new Response(
+    JSON.stringify({
+      error: "Invalid QUERY request",
+      message: "QUERY requests must include a Content-Type header."
+    }),
+    {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    }
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, validateQueryContentType, "validateQueryContentType");
+function normalizeRouteResponse(result) {
+  if (isWebResponse(result)) {
+    return result;
+  }
+  if (result === void 0) {
+    return new Response(null, { status: 204 });
+  }
+  let body;
+  try {
+    body = JSON.stringify(result);
+  } catch (error) {
+    const serializationError = new TypeError(
+      "API route result must be a JSON-serializable value or a Response."
+    );
+    serializationError.cause = error;
+    throw serializationError;
+  }
+  if (body === void 0) {
+    throw new TypeError("API route result must be a JSON-serializable value or a Response.");
+  }
+  return new Response(body, {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeRouteResponse, "normalizeRouteResponse");
+function isWebResponse(value) {
+  return value instanceof Response || typeof value === "object" && value !== null && "headers" in value && "status" in value && typeof value.arrayBuffer === "function";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isWebResponse, "isWebResponse");
+function attachEndpointInvalidations(response, keys) {
+  const existing = _chunkZEG3OPIBcjs.decodeFarmCacheInvalidations.call(void 0, 
+    response.headers.get(_chunkZEG3OPIBcjs.FARM_CACHE_INVALIDATION_HEADER)
+  );
+  const encoded = _chunkZEG3OPIBcjs.encodeFarmCacheInvalidations.call(void 0, [...existing, ...keys]);
+  if (!encoded) return response;
+  const headers = new Headers(response.headers);
+  headers.set(_chunkZEG3OPIBcjs.FARM_CACHE_INVALIDATION_HEADER, encoded);
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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"
+      }
+    }
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createEndpointFailureResponse, "createEndpointFailureResponse");
+async function readRequestBody(request) {
+  const contentType = _optionalChain([request, 'access', _12 => _12.headers, 'access', _13 => _13.get, 'call', _14 => _14("content-type"), 'optionalAccess', _15 => _15.split, 'call', _16 => _16(";", 1), 'access', _17 => _17[0], 'optionalAccess', _18 => _18.trim, 'call', _19 => _19(), 'access', _20 => _20.toLowerCase, 'call', _21 => _21()]);
+  if (contentType === "multipart/form-data") {
+    try {
+      return { body: formDataToObject(await request.clone().formData()) };
+    } catch (e2) {
+      return invalidRequestBody("The request body is not valid multipart form data.");
+    }
+  }
+  let text;
+  try {
+    text = await request.clone().text();
+  } catch (e3) {
+    if (contentType === "application/json" || _optionalChain([contentType, 'optionalAccess', _22 => _22.endsWith, 'call', _23 => _23("+json")])) {
+      return invalidRequestBody("The request body is not valid JSON.");
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      return invalidRequestBody("The request body is not valid URL-encoded form data.");
+    }
+    return { body: void 0 };
+  }
+  if (contentType === "application/json" || _optionalChain([contentType, 'optionalAccess', _24 => _24.endsWith, 'call', _25 => _25("+json")])) {
+    if (!text && request.method.toUpperCase() === "QUERY") {
+      return { body: void 0 };
+    }
+    try {
+      return { body: JSON.parse(text) };
+    } catch (e4) {
+      return invalidRequestBody("The request body is not valid JSON.");
+    }
+  }
+  if (contentType === "application/x-www-form-urlencoded") {
+    return { body: searchParamsToObject(new URLSearchParams(text)) };
+  }
+  if (!text) return { body: void 0 };
+  if (contentType === void 0) {
+    try {
+      return { body: JSON.parse(text) };
+    } catch (e5) {
+      return { body: void 0 };
+    }
+  }
+  return { body: void 0 };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readRequestBody, "readRequestBody");
+function invalidRequestBody(message) {
+  return {
+    error: new Response(
+      JSON.stringify({
+        error: "Invalid request body",
+        message
+      }),
+      {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      }
+    )
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, invalidRequestBody, "invalidRequestBody");
+function formDataToObject(formData) {
+  return entriesToObject(formData.entries());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, formDataToObject, "formDataToObject");
+function searchParamsToObject(searchParams) {
+  return entriesToObject(searchParams.entries());
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, entriesToObject, "entriesToObject");
+async function validateInput(schema, value, error) {
+  if (!schema) return value;
+  try {
+    return await parseRouteSchema(schema, value);
+  } catch (validationError) {
+    return Response.json(
+      {
+        error,
+        details: (validationError.issues || validationError.errors || []).map((issue) => ({
+          path: issue.path,
+          message: issue.message,
+          code: issue.code
+        }))
+      },
+      { status: 400 }
+    );
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, validateInput, "validateInput");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.parseRouteSchema = parseRouteSchema; exports.API_ROUTE_METHODS = API_ROUTE_METHODS; exports.resolveAPIRouteEndpoint = resolveAPIRouteEndpoint; exports.getAllowedAPIRouteMethods = getAllowedAPIRouteMethods; exports.matchAPIRouteAtBasePath = matchAPIRouteAtBasePath; exports.createStaticAPIRouteMatcherAtBasePath = createStaticAPIRouteMatcherAtBasePath; exports.isFarmAPIPathname = isFarmAPIPathname; exports.invokeAPIRouteEndpoint = invokeAPIRouteEndpoint; exports.normalizeRouteResponse = normalizeRouteResponse; exports.isWebResponse = isWebResponse; exports.createEndpointFailureResponse = createEndpointFailureResponse; exports.mergePluginAPIRoutes = mergePluginAPIRoutes;

package/dist/chunk-4PPEPOZZ.cjs

@@ -0,0 +1,21 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunk72ADZ6GQcjs = require('./chunk-72ADZ6GQ.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/api/server-context.ts
+var _async_hooks = require('async_hooks');
+var API_RUNTIME_STORAGE = /* @__PURE__ */ Symbol.for("@farm.js/core/api-request-storage");
+var runtimeGlobal = globalThis;
+var storage = _nullishCoalesce(runtimeGlobal[API_RUNTIME_STORAGE], () => ( (runtimeGlobal[API_RUNTIME_STORAGE] = new (0, _async_hooks.AsyncLocalStorage)())));
+_chunk72ADZ6GQcjs.setAPIRequestRuntimeResolver.call(void 0, () => storage.getStore());
+function _runWithAPIRequestRuntime(runtime, run) {
+  return storage.run(runtime, run);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithAPIRequestRuntime, "_runWithAPIRequestRuntime");
+
+
+
+exports._runWithAPIRequestRuntime = _runWithAPIRequestRuntime;