@rotorsoft/act 1.3.0 → 1.4.0

package/dist/index.js

@@ -868,51 +868,7 @@ var subscribe = (streams) => store().subscribe(streams);
 
 // src/internal/event-sourcing.ts
 import { patch } from "@rotorsoft/act-patch";
-async function* iterate(source, filter) {
-  const state2 = {
-    slot: null,
-    onProduce: null,
-    onConsume: null,
-    done: false,
-    error: void 0
-  };
-  const wakeProduce = () => {
-    const fn = state2.onProduce;
-    state2.onProduce = null;
-    if (fn) fn();
-  };
-  void source.query((event) => {
-    state2.slot = event;
-    wakeProduce();
-    return new Promise((resolve) => {
-      state2.onConsume = () => resolve();
-    });
-  }, filter).then(
-    () => {
-      state2.done = true;
-      wakeProduce();
-    },
-    (err) => {
-      state2.error = err;
-      state2.done = true;
-      wakeProduce();
-    }
-  );
-  while (true) {
-    if (state2.slot === null && !state2.done)
-      await new Promise((resolve) => {
-        state2.onProduce = resolve;
-      });
-    if (state2.error) throw state2.error;
-    if (state2.slot === null) return;
-    const event = state2.slot;
-    state2.slot = null;
-    const fn = state2.onConsume;
-    state2.onConsume = null;
-    fn();
-    yield event;
-  }
-}
+var DEFAULT_BATCH = 500;
 async function snap(snapshot) {
   try {
     const { id, stream, name, meta, version } = snapshot.event;
@@ -944,7 +900,7 @@ async function tombstone(stream, expectedVersion, correlation) {
     throw error;
   }
 }
-function isValid(event) {
+function is_valid(event) {
   if (event.version < 0) return false;
   if (!(event.created instanceof Date) || Number.isNaN(event.created.getTime()))
     return false;
@@ -952,48 +908,70 @@ function isValid(event) {
 }
 async function scan(source, opts = {}, callback) {
   const { drop_snapshots = false, on_progress } = opts;
-  const idMap = /* @__PURE__ */ new Map();
+  const limit = opts.batch_size ?? DEFAULT_BATCH;
+  const id_map = /* @__PURE__ */ new Map();
   let kept = 0;
-  let droppedSnapshots = 0;
+  let dropped_snaps = 0;
   let processed = 0;
-  for await (const event of iterate(source)) {
-    processed++;
-    if (!isValid(event)) throw new Error(`Invalid event at index ${processed}`);
-    if (on_progress) on_progress({ processed });
-    if (drop_snapshots && event.name === SNAP_EVENT) {
-      droppedSnapshots++;
-      continue;
-    }
-    if (!callback) {
-      kept++;
-      continue;
-    }
-    let remapped = event;
-    const causedBy = event.meta.causation.event?.id;
-    if (causedBy !== void 0) {
-      const newCausedBy = idMap.get(causedBy);
-      if (newCausedBy !== void 0 && newCausedBy !== causedBy) {
-        remapped = {
-          ...event,
-          meta: {
-            ...event.meta,
-            causation: {
-              ...event.meta.causation,
-              event: { ...event.meta.causation.event, id: newCausedBy }
-            }
+  let at;
+  let max_id;
+  const probed = await source.query(
+    (e) => {
+      max_id = e.id;
+    },
+    { backward: true, limit: 1 }
+  );
+  if (probed !== 1) max_id = void 0;
+  while (true) {
+    let got = 0;
+    let id;
+    await source.query(
+      async (event) => {
+        got++;
+        id = event.id;
+        processed++;
+        if (!is_valid(event))
+          throw new Error(`Invalid event at index ${processed}`);
+        if (on_progress) on_progress({ processed, id: event.id, max_id });
+        if (drop_snapshots && event.name === SNAP_EVENT) {
+          dropped_snaps++;
+          return;
+        }
+        if (!callback) {
+          kept++;
+          return;
+        }
+        let remapped = event;
+        const caused_by = event.meta.causation.event?.id;
+        if (caused_by !== void 0) {
+          const new_caused_by = id_map.get(caused_by);
+          if (new_caused_by !== void 0 && new_caused_by !== caused_by) {
+            remapped = {
+              ...event,
+              meta: {
+                ...event.meta,
+                causation: {
+                  ...event.meta.causation,
+                  event: { ...event.meta.causation.event, id: new_caused_by }
+                }
+              }
+            };
           }
-        };
-      }
-    }
-    const newId = await callback(remapped);
-    idMap.set(event.id, newId);
-    kept++;
+        }
+        const new_id = await callback(remapped);
+        id_map.set(event.id, new_id);
+        kept++;
+      },
+      { after: at, limit }
+    );
+    if (got !== limit) break;
+    at = id;
   }
   return {
     kept,
     dropped: {
       closed_streams: 0,
-      snapshots: droppedSnapshots,
+      snapshots: dropped_snaps,
       empty_streams: 0
     }
   };