@absolutejs/sync 1.9.2 → 1.11.0

package/dist/engine/syncEngine.d.ts

@@ -178,6 +178,28 @@ export type SyncEngine = {
      * mutation / a handler throw. Drive this from the transport's mutate frame.
      */
     runMutation: (name: string, args: unknown, ctx: unknown) => Promise<unknown>;
+    /**
+     * Atomically run N mutations in a single transaction (sync 1.11+).
+     * Each `{ name, args }` spec is authorized, then handlers fire in
+     * order against shared buffered changes. If any handler throws, the
+     * entire transaction rolls back — no partial commits, no fanned-out
+     * diffs. On success the accumulated changes apply as ONE live batch
+     * and the per-mutation results return in order.
+     *
+     * No retry policy applies to batches in v0.2; configure per-mutation
+     * retries on individual `runMutation` calls when atomicity isn't
+     * needed. A failed batch passes the original error through with no
+     * wrapping.
+     *
+     * Requires `transaction` to be set in {@link SyncEngineOptions} for
+     * actual DB-level atomicity; without it the batch still buffers
+     * changes into one fan-out but the underlying adapter writes
+     * piecemeal.
+     */
+    runMutations: (specs: Array<{
+        name: string;
+        args: unknown;
+    }>, ctx: unknown) => Promise<unknown[]>;
     /**
      * A point-in-time snapshot of the engine for devtools: registered collections
      * (+ kind, tables, live subscription counts), mutations, schedules, readers,

package/dist/index.js

@@ -2065,6 +2065,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);
     },
@@ -2626,5 +2675,5 @@ export {
   createPresenceHub
 };
 
-//# debugId=2C8AB0508E99C22364756E2164756E21
+//# debugId=FFB4969DBBAB620C64756E2164756E21
 //# sourceMappingURL=index.js.map