@farm.js/core 0.1.0-beta.1 → 0.1.0-beta.3

package/README.md

@@ -1,6 +1,6 @@
 # @farm.js/core
 
-Core Farm.js framework - A modern React meta-framework
+Core Farm.js framework for modern integrated apps
 
 Farm.js is currently in beta.
 

package/dist/agent-runtime.d.mts

@@ -1,5 +1,5 @@
 import { ChildProcess } from 'node:child_process';
-import { U as BundleResultPayload, V as FarmPlugin, W as FarmIntegration } from './client-plugins-g4bzuCmo.mjs';
+import { U as BundleResultPayload, V as FarmPlugin, W as FarmIntegration } from './client-plugins-Cnr0D3kk.mjs';
 import './plugin-BJDf43dc.mjs';
 import 'react';
 import 'http';

package/dist/agent-runtime.d.ts

@@ -1,5 +1,5 @@
 import { ChildProcess } from 'node:child_process';
-import { U as BundleResultPayload, V as FarmPlugin, W as FarmIntegration } from './client-plugins-BZnpeTGA.js';
+import { U as BundleResultPayload, V as FarmPlugin, W as FarmIntegration } from './client-plugins-CTnsZz_A.js';
 import './plugin-BJDf43dc.js';
 import 'react';
 import 'http';

package/dist/api/route-manager.cjs

@@ -170,6 +170,29 @@ function formatError(error) {
 }
 __name(formatError, "formatError");
 
+// src/cache-invalidation.ts
+var FARM_CACHE_INVALIDATION_HEADER = "x-farm-cache-invalidations";
+function encodeFarmCacheInvalidations(keys) {
+  const normalized = Array.from(
+    new Set(keys.filter((key) => typeof key === "string" && key.length > 0))
+  );
+  if (normalized.length === 0) return null;
+  return encodeURIComponent(JSON.stringify(normalized));
+}
+__name(encodeFarmCacheInvalidations, "encodeFarmCacheInvalidations");
+function decodeFarmCacheInvalidations(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(decodeURIComponent(value));
+    return Array.isArray(parsed) ? Array.from(
+      new Set(parsed.filter((key) => typeof key === "string" && key.length > 0))
+    ) : [];
+  } catch {
+    return [];
+  }
+}
+__name(decodeFarmCacheInvalidations, "decodeFarmCacheInvalidations");
+
 // src/i18n/bridge.ts
 var FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
 function _setFarmI18nSnapshotResolver(resolver) {
@@ -725,6 +748,26 @@ async function _runWithCurrentRequest(request, fn) {
 }
 __name(_runWithCurrentRequest, "_runWithCurrentRequest");
 
+// src/api/endpoint.ts
+var import_better_call = require("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");
+var EMPTY_ENDPOINT_MIDDLEWARE = Object.freeze([]);
+var EMPTY_ENDPOINT_CONTEXT = Object.freeze(/* @__PURE__ */ Object.create(null));
+
 // src/api/runtime.ts
 function matchAPIRoute(routes, pathname) {
   const exactRoute = routes.get(pathname);
@@ -757,10 +800,10 @@ __name(invokeAPIRouteEndpoint, "invokeAPIRouteEndpoint");
 async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
   const farmHandler = endpoint.__handler || (isFarmContextHandler(endpoint) ? endpoint : null);
   if (!farmHandler) {
-    const result2 = await endpoint(request, {
+    const result = await endpoint(request, {
       params: Promise.resolve(params)
     });
-    return normalizeRouteResponse(result2);
+    return normalizeRouteResponse(result);
   }
   const url = new URL(request.url);
   const query = {};
@@ -785,15 +828,30 @@ async function invokeAPIRouteEndpointInContext(endpoint, request, params) {
   if (headersValidation instanceof Response) {
     return headersValidation;
   }
-  const result = await farmHandler({
+  const handlerContext = {
     query: queryValidation,
     body: bodyValidation,
     headers: headersValidation,
     request,
     context: {},
     params
-  });
-  return normalizeRouteResponse(result);
+  };
+  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) {
@@ -813,6 +871,40 @@ 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;