@absolutejs/sync 1.7.0 → 1.7.2

package/dist/engine/index.js

@@ -1102,22 +1102,57 @@ var wrap = (source) => `
 			);
 		}
 		const actions = {
-			insert: __syncActionInsert,
-			update: __syncActionUpdate,
-			delete: __syncActionDelete,
-			change: __syncActionChange
+			insert: (table, data) => __syncAction('insert', table, data),
+			update: (table, data) => __syncAction('update', table, data),
+			delete: (table, row) => __syncAction('delete', table, row),
+			change: (collection, change) => __syncAction('change', collection, change)
 		};
 		return await userFn(args, ctx, actions);
 	})()
 `;
+var DEFAULT_RECYCLE_CONTEXT_AFTER = 256;
+var installRouter = async (context, currentActions, Reference) => {
+  const router = new Reference((op, ...rest) => {
+    const a = currentActions.value;
+    if (a === undefined) {
+      throw new Error("__syncAction invoked outside an active sandboxed call (shared-slot router)");
+    }
+    switch (op) {
+      case "insert":
+        return a.insert(rest[0], rest[1]);
+      case "update":
+        return a.update(rest[0], rest[1]);
+      case "delete":
+        return a.delete(rest[0], rest[1]);
+      case "change":
+        return a.change(rest[0], rest[1]);
+      default:
+        throw new Error(`unknown sandbox action op: ${String(op)}`);
+    }
+  });
+  await context.setGlobal("__syncAction", router);
+};
 var compile = async (source, config) => {
-  const { createIsolate } = await loadIsolatedJsc();
+  const { createIsolate, Reference } = await loadIsolatedJsc();
   const isolate = await createIsolate({
-    backend: config.backend ?? "worker",
+    backend: config.backend ?? "auto",
     memoryLimit: config.memoryLimit ?? 32
   });
   const script = await isolate.compileScript(wrap(source));
-  return { isolate, script, timeoutMs: config.timeout ?? 5000 };
+  const context = await isolate.createContext();
+  const currentActions = {
+    value: undefined
+  };
+  await installRouter(context, currentActions, Reference);
+  return {
+    context,
+    currentActions,
+    isolate,
+    runQueue: Promise.resolve(undefined),
+    script,
+    servedCalls: 0,
+    timeoutMs: config.timeout ?? 5000
+  };
 };
 var makeSandboxedHandler = (source, config = {}) => {
   let pending;
@@ -1131,23 +1166,37 @@ var makeSandboxedHandler = (source, config = {}) => {
     pending = compile(source, config);
     return pending;
   };
-  return async (args, ctx, actions) => {
+  const recycleContextIfNeeded = async (compiled) => {
+    if (compiled.servedCalls < DEFAULT_RECYCLE_CONTEXT_AFTER)
+      return;
     const { Reference } = await loadIsolatedJsc();
+    await compiled.context.dispose().catch(() => {});
+    compiled.context = await compiled.isolate.createContext();
+    await installRouter(compiled.context, compiled.currentActions, Reference);
+    compiled.servedCalls = 0;
+  };
+  return async (args, ctx, actions) => {
     const compiled = await getCompiled();
-    const context = await compiled.isolate.createContext();
-    try {
-      await context.setGlobal("args", args);
-      await context.setGlobal("ctx", ctx);
-      await context.setGlobal("__syncActionInsert", new Reference((table, data) => actions.insert(table, data)));
-      await context.setGlobal("__syncActionUpdate", new Reference((table, data) => actions.update(table, data)));
-      await context.setGlobal("__syncActionDelete", new Reference((table, row) => actions.delete(table, row)));
-      await context.setGlobal("__syncActionChange", new Reference((collection, change) => actions.change(collection, change)));
-      return await compiled.script.run(context, {
-        timeout: compiled.timeoutMs
-      });
-    } finally {
-      await context.dispose().catch(() => {});
-    }
+    const prev = compiled.runQueue;
+    const turn = prev.then(async () => {
+      await recycleContextIfNeeded(compiled);
+      compiled.currentActions.value = actions;
+      try {
+        await compiled.context.setGlobal("args", args);
+        await compiled.context.setGlobal("ctx", ctx);
+        const result = await compiled.script.run(compiled.context, {
+          timeout: compiled.timeoutMs
+        });
+        return result;
+      } finally {
+        compiled.currentActions.value = undefined;
+        compiled.servedCalls += 1;
+      }
+    });
+    compiled.runQueue = turn.catch(() => {
+      return;
+    });
+    return turn;
   };
 };
 
@@ -2762,5 +2811,5 @@ export {
   CdcConsumerSlowError
 };
 
-//# debugId=EE73D3886B04BDA964756E2164756E21
+//# debugId=43E0F3CB08EACD1264756E2164756E21
 //# sourceMappingURL=index.js.map