@rotorsoft/act 1.2.0 → 1.4.0

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   sleep,
   store,
   validate
-} from "./chunk-J6NDEEXC.js";
+} from "./chunk-XKCTGUW2.js";
 import {
   ActorSchema,
   CausationEventSchema,
@@ -868,6 +868,7 @@ var subscribe = (streams) => store().subscribe(streams);
 
 // src/internal/event-sourcing.ts
 import { patch } from "@rotorsoft/act-patch";
+var DEFAULT_BATCH = 500;
 async function snap(snapshot) {
   try {
     const { id, stream, name, meta, version } = snapshot.event;
@@ -899,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;
@@ -907,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 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
     }
   };
@@ -2629,18 +2652,21 @@ var Act = class {
    *
    * @see {@link Store.restore} for the underlying driver-pattern primitive.
    */
-  async restore(source, opts = {}) {
+  async restore(source, opts = {}, sink) {
     return this._scoped(async () => {
       const started = Date.now();
       if (opts.dry_run) {
         const partial = await scan(source, opts);
         return { ...partial, duration_ms: Date.now() - started };
       }
-      const s = store();
-      if (!s.restore) throw new Error("adapter has no restore capability");
+      const target = sink ?? (() => {
+        const s = store();
+        if (!s.restore) throw new Error("adapter has no restore capability");
+        return s;
+      })();
       let kept = 0;
       let dropped = { closed_streams: 0, snapshots: 0, empty_streams: 0 };
-      await s.restore(async (callback) => {
+      await target.restore(async (callback) => {
         const partial = await scan(source, opts, callback);
         kept = partial.kept;
         dropped = partial.dropped;
@@ -3213,6 +3239,167 @@ function action_builder(state2) {
   };
   return builder;
 }
+
+// src/csv.ts
+import { createReadStream, createWriteStream } from "fs";
+import { createInterface } from "readline";
+var CSV_COLUMNS = [
+  "id",
+  "name",
+  "data",
+  "stream",
+  "version",
+  "created",
+  "meta"
+];
+var CsvFile = class {
+  path;
+  blob;
+  constructor(options) {
+    if ("path" in options) {
+      this.path = options.path;
+      this.blob = null;
+    } else {
+      this.path = null;
+      this.blob = options.blob;
+    }
+  }
+  async query(callback, _filter) {
+    const lines = this.blob !== null ? linesFromBlob(this.blob) : linesFromFile(this.path);
+    let count = 0;
+    let header = null;
+    for await (const line of lines) {
+      if (!line.trim()) continue;
+      const fields = parseCsvLine(line);
+      if (!header) {
+        header = fields;
+        const expected = CSV_COLUMNS.join(",");
+        if (header.join(",") !== expected)
+          throw new Error(`Invalid CSV header. Expected: ${expected}`);
+        continue;
+      }
+      if (fields.length !== CSV_COLUMNS.length)
+        throw new Error(
+          `Row ${count + 1}: expected ${CSV_COLUMNS.length} fields, got ${fields.length}`
+        );
+      const event = {
+        id: Number.parseInt(fields[0], 10),
+        name: fields[1],
+        data: JSON.parse(fields[2]),
+        stream: fields[3],
+        version: Number.parseInt(fields[4], 10),
+        created: new Date(fields[5]),
+        meta: JSON.parse(fields[6])
+      };
+      await Promise.resolve(callback(event));
+      count++;
+    }
+    if (header === null)
+      throw new Error("CSV must have a header and at least one row");
+    return count;
+  }
+  async restore(driver) {
+    if (this.path === null)
+      throw new Error(
+        "CsvFile in blob mode is read-only \u2014 provide `path` to write"
+      );
+    const writer = createWriteStream(this.path, {
+      flags: "w",
+      encoding: "utf8"
+    });
+    let nextId = 1;
+    try {
+      await writeLine(writer, CSV_COLUMNS.join(","));
+      await driver(async (event) => {
+        const id = nextId++;
+        const row = [
+          String(id),
+          csvEscape(event.name),
+          csvEscape(JSON.stringify(event.data)),
+          csvEscape(event.stream),
+          String(event.version),
+          event.created.toISOString(),
+          csvEscape(JSON.stringify(event.meta))
+        ].join(",");
+        await writeLine(writer, row);
+        return id;
+      });
+    } finally {
+      await new Promise((resolve) => writer.end(resolve));
+    }
+  }
+  async dispose() {
+  }
+};
+async function* linesFromFile(path) {
+  const stream = createReadStream(path, { encoding: "utf8" });
+  const rl = createInterface({
+    input: stream,
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  try {
+    for await (const line of rl) yield line;
+  } finally {
+    rl.close();
+    stream.close();
+  }
+}
+async function* linesFromBlob(blob) {
+  let start = 0;
+  while (start < blob.length) {
+    const nl = blob.indexOf("\n", start);
+    const end = nl === -1 ? blob.length : nl;
+    yield blob.slice(start, end);
+    start = nl === -1 ? blob.length : nl + 1;
+    await Promise.resolve();
+  }
+}
+function parseCsvLine(line) {
+  const fields = [];
+  let i = 0;
+  while (i < line.length) {
+    if (line[i] === '"') {
+      let value = "";
+      i++;
+      while (i < line.length) {
+        if (line[i] === '"' && line[i + 1] === '"') {
+          value += '"';
+          i += 2;
+        } else if (line[i] === '"') {
+          i++;
+          break;
+        } else {
+          value += line[i++];
+        }
+      }
+      fields.push(value);
+      if (line[i] === ",") i++;
+    } else {
+      const next = line.indexOf(",", i);
+      if (next === -1) {
+        fields.push(line.slice(i));
+        i = line.length;
+      } else {
+        fields.push(line.slice(i, next));
+        i = next + 1;
+      }
+    }
+  }
+  return fields;
+}
+function csvEscape(value) {
+  if (/[",\n\r]/.test(value)) return `"${value.replace(/"/g, '""')}"`;
+  return value;
+}
+function writeLine(writer, line) {
+  return new Promise((resolve, reject) => {
+    writer.write(`${line}
+`, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+}
 export {
   Act,
   ActorSchema,
@@ -3220,6 +3407,7 @@ export {
   CommittedMetaSchema,
   ConcurrencyError,
   ConsoleLogger,
+  CsvFile,
   DEFAULT_LANE,
   DEFAULT_MAX_SUBSCRIBED_STREAMS,
   DEFAULT_SETTLE_DEBOUNCE_MS,