@absolutejs/sync 1.10.0 → 1.12.0

package/dist/testing.js

@@ -318,7 +318,7 @@ var wrap = (source) => `
 		const userFn = (${source});
 		if (typeof userFn !== 'function') {
 			throw new Error(
-				'sandboxedHandler must evaluate to (args, ctx, actions) => result; got ' +
+				'sandboxedHandler must evaluate to (args, ctx, actions, unsafeHost) => result; got ' +
 					typeof userFn
 			);
 		}
@@ -330,12 +330,24 @@ var wrap = (source) => `
 			now: () => __dispatch(__callId, 'now'),
 			fetch: (url, init) => __dispatch(__callId, 'fetch', url, init)
 		};
-		return userFn(args, ctx, actions);
+		// Escape hatch \u2014 host fns the mutation explicitly opted in to.
+		// The Proxy means every property access is a host call; the
+		// engine throws if the property name isn't declared in the
+		// mutation's sandbox.unsafeHost map.
+		const unsafeHost = new Proxy({}, {
+			get: (_target, fnName) => {
+				if (typeof fnName !== 'string') return undefined;
+				return (...callArgs) =>
+					__dispatch(__callId, 'unsafeHost', fnName, callArgs);
+			}
+		});
+		return userFn(args, ctx, actions, unsafeHost);
 	}
 `;
 var compile = async (source, config, bridgeFetch) => {
   const { Reference, createIsolatedRunner, resolveIsolatePolicy } = await loadIsolatedJsc();
   const callMap = new Map;
+  const unsafeHost = config.unsafeHost;
   const dispatch = new Reference((callId, op, ...rest) => {
     const a = callMap.get(callId);
     if (a === undefined) {
@@ -354,6 +366,14 @@ var compile = async (source, config, bridgeFetch) => {
         return a.now();
       case "fetch":
         return runBridgeFetch(bridgeFetch, rest[0], rest[1]);
+      case "unsafeHost": {
+        const fnName = rest[0];
+        const callArgs = rest[1] ?? [];
+        if (unsafeHost === undefined || typeof unsafeHost[fnName] !== "function") {
+          throw new Error(`sandboxedHandler called unsafeHost.${fnName}() but it was not declared in the mutation's sandbox.unsafeHost config. Declare it (and only the host fns you intend to expose) to opt in to the escape hatch.`);
+        }
+        return unsafeHost[fnName](...callArgs);
+      }
       default:
         throw new Error(`unknown sandbox action op: ${String(op)}`);
     }
@@ -1643,6 +1663,55 @@ var createSyncEngine = (options = {}) => {
       }
       throw lastError;
     },
+    runMutations: async (specs, ctx) => {
+      if (specs.length === 0)
+        return [];
+      const resolved = specs.map((spec) => {
+        const mutation = mutations.get(spec.name);
+        if (mutation === undefined) {
+          throw new Error(`Unknown mutation "${spec.name}"`);
+        }
+        return { args: spec.args, mutation, name: spec.name };
+      });
+      const runBatch = async (tx) => {
+        const results = [];
+        const accumulated = [];
+        for (const { args, mutation, name } of resolved) {
+          if (mutation.authorize !== undefined) {
+            const allowed = await mutation.authorize(args, ctx);
+            if (!allowed) {
+              throw new UnauthorizedError(`run mutation "${name}"`);
+            }
+          }
+          const sandboxRunner = sandboxRunners.get(name);
+          const invokeHandler = sandboxRunner !== undefined ? sandboxRunner : (a, c, actions2) => Promise.resolve(mutation.handler(a, c, actions2));
+          const { actions, buffered } = makeActions(tx, ctx, true);
+          const result = await invokeHandler(args, ctx, actions);
+          results.push(result);
+          accumulated.push(...buffered);
+        }
+        return { accumulated, results };
+      };
+      try {
+        const { accumulated, results } = runInTransaction !== undefined ? await runInTransaction((tx) => runBatch(tx)) : await runBatch(undefined);
+        await applyChangeBatch(accumulated);
+        emitActivity({
+          type: "mutationBatch",
+          at: Date.now(),
+          names: resolved.map((entry) => entry.name),
+          status: "ok"
+        });
+        return results;
+      } catch (error) {
+        emitActivity({
+          type: "mutationBatch",
+          at: Date.now(),
+          names: resolved.map((entry) => entry.name),
+          status: "error"
+        });
+        throw error;
+      }
+    },
     registerSchedule: (schedule) => {
       schedules.set(schedule.name, schedule);
     },
@@ -1934,5 +2003,5 @@ export {
   createTestEngine
 };
 
-//# debugId=CDFC0D23D33F4AF664756E2164756E21
+//# debugId=E33DC349D71B8BBE64756E2164756E21
 //# sourceMappingURL=testing.js.map