@absolutejs/sync 1.7.7 → 1.7.8

package/dist/engine/index.d.ts

@@ -42,7 +42,7 @@ export { defineSchedule } from './schedule';
 export type { ScheduleContext, ScheduleDefinition } from './schedule';
 export { defineMutation } from './mutation';
 export type { MutationActions, MutationDefinition, MutationHandler, TableWriter, TransactionRunner } from './mutation';
-export type { HandlerMetricsHook, HandlerMetricsRecord, SandboxConfig } from './sandbox';
+export type { BridgeFetchConfig, BridgeFetchEndpoint, BridgeFetchResponse, HandlerMetricsHook, HandlerMetricsRecord, SandboxConfig } from './sandbox';
 export { exponentialBackoff, isSerializationFailure, RetriesExhaustedError } from './retry';
 export type { ExponentialBackoffOptions, RetryPolicy } from './retry';
 export { CdcConsumerSlowError, createSyncEngine, MissedChangesError, SchemaError, UnauthorizedError } from './syncEngine';

package/dist/engine/index.js

@@ -1106,12 +1106,13 @@ var wrap = (source) => `
 			update: (table, data) => __dispatch(__callId, 'update', table, data),
 			delete: (table, row) => __dispatch(__callId, 'delete', table, row),
 			change: (collection, change) => __dispatch(__callId, 'change', collection, change),
-			now: () => __dispatch(__callId, 'now')
+			now: () => __dispatch(__callId, 'now'),
+			fetch: (url, init) => __dispatch(__callId, 'fetch', url, init)
 		};
 		return userFn(args, ctx, actions);
 	}
 `;
-var compile = async (source, config) => {
+var compile = async (source, config, bridgeFetch) => {
   const { createIsolate, Reference } = await loadIsolatedJsc();
   const isolate = await createIsolate({
     backend: config.backend ?? "auto",
@@ -1135,6 +1136,8 @@ var compile = async (source, config) => {
         return a.change(rest[0], rest[1]);
       case "now":
         return a.now();
+      case "fetch":
+        return runBridgeFetch(bridgeFetch, rest[0], rest[1]);
       default:
         throw new Error(`unknown sandbox action op: ${String(op)}`);
     }
@@ -1150,8 +1153,57 @@ var compile = async (source, config) => {
     timeoutMs: config.timeout ?? 5000
   };
 };
-var makeSandboxedHandler = (source, config = {}, metricsHook) => {
+var runBridgeFetch = async (config, url, init) => {
+  if (config === undefined) {
+    throw new Error("actions.fetch called but the engine has no `bridgeFetch` config \u2014 " + "pass `bridgeFetch: { ... }` to createSyncEngine.");
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`actions.fetch: invalid URL "${String(url)}"`);
+  }
+  const endpoint = config[parsed.hostname] ?? (Object.prototype.hasOwnProperty.call(config, "*") ? config["*"] : undefined);
+  if (endpoint === undefined) {
+    throw new Error(`actions.fetch: hostname "${parsed.hostname}" is not allowlisted in bridgeFetch config`);
+  }
+  const headers = { ...endpoint.headers ?? {} };
+  if (init?.headers !== undefined) {
+    const incoming = init.headers;
+    for (const [name, value] of Object.entries(incoming)) {
+      if (name.toLowerCase() === "authorization")
+        continue;
+      headers[name] = value;
+    }
+  }
+  if (endpoint.authorization !== undefined) {
+    let auth;
+    try {
+      auth = await endpoint.authorization();
+    } catch {
+      throw new Error("actions.fetch: authorization callback failed");
+    }
+    headers.Authorization = auth;
+  }
+  const response = await fetch(url, { ...init, headers });
+  const responseHeaders = {};
+  response.headers.forEach((value, name) => {
+    responseHeaders[name] = value;
+  });
+  const body = await response.text();
+  return {
+    body,
+    headers: responseHeaders,
+    ok: response.ok,
+    status: response.status,
+    statusText: response.statusText,
+    url: response.url
+  };
+};
+var makeSandboxedHandler = (source, config = {}, engineExtras) => {
   let pending;
+  const metricsHook = engineExtras?.metricsHook;
+  const bridgeFetch = engineExtras?.bridgeFetch;
   const getCompiled = async () => {
     if (pending !== undefined) {
       const compiled = await pending;
@@ -1159,7 +1211,7 @@ var makeSandboxedHandler = (source, config = {}, metricsHook) => {
         return compiled;
       pending = undefined;
     }
-    pending = compile(source, config);
+    pending = compile(source, config, bridgeFetch);
     return pending;
   };
   return async (args, ctx, actions) => {
@@ -2208,9 +2260,12 @@ var createSyncEngine = (options = {}) => {
       }
       mutations.set(mutation.name, mutation);
       if (mutation.sandboxedHandler !== undefined) {
-        sandboxRunners.set(mutation.name, makeSandboxedHandler(mutation.sandboxedHandler, mutation.sandbox, options.handlerMetrics === undefined ? undefined : {
-          mutationName: mutation.name,
-          onMetrics: options.handlerMetrics
+        sandboxRunners.set(mutation.name, makeSandboxedHandler(mutation.sandboxedHandler, mutation.sandbox, {
+          bridgeFetch: options.bridgeFetch,
+          metricsHook: options.handlerMetrics === undefined ? undefined : {
+            mutationName: mutation.name,
+            onMetrics: options.handlerMetrics
+          }
         }));
       }
     },
@@ -2835,5 +2890,5 @@ export {
   CdcConsumerSlowError
 };
 
-//# debugId=40AF85BFFA0EA08364756E2164756E21
+//# debugId=E4250C6CF5A6208E64756E2164756E21
 //# sourceMappingURL=index.js.map