@anabranch/eventlog 0.1.2 → 0.2.0

package/esm/in-memory.js

@@ -1,57 +1,14 @@
-import { EventLogAppendFailed, EventLogCommitCursorFailed, EventLogGetCursorFailed, EventLogGetFailed, EventLogListFailed, } from "./errors.js";
+import { EventLogAppendFailed, EventLogCommitCursorFailed, EventLogConnectionFailed, EventLogConsumeFailed, EventLogGetCursorFailed, } from './errors.js';
 function generateId() {
     return crypto.randomUUID();
 }
-/**
- * Creates an in-memory event log connector using a simple event store.
- *
- * Events are stored in memory only and will be lost on process restart.
- * Useful for testing and development.
- *
- * @example Basic usage
- * ```ts
- * import { EventLog, createInMemory } from "@anabranch/eventlog";
- *
- * const connector = createInMemory();
- * const log = await EventLog.connect(connector).run();
- *
- * // Append an event
- * const eventId = await log.append("users", { action: "created", userId: 123 }).run();
- *
- * // List events
- * const events = await log.list("users").run();
- * ```
- *
- * @example With partition key
- * ```ts
- * await log.append("orders", { orderId: 456, total: 99.99 }, {
- *   partitionKey: "user-123"
- * }).run();
- * ```
- *
- * @example Consuming events
- * ```ts
- * const connector = createInMemory();
- * const log = await EventLog.connect(connector).run();
- *
- * // Append some events first
- * await log.append("notifications", { type: "email" }).run();
- * await log.append("notifications", { type: "sms" }).run();
- *
- * // Consume events
- * for await (const batch of log.consume("notifications", "my-consumer-group")) {
- *   for (const event of batch.events) {
- *     console.log(event.data);
- *   }
- * }
- * ```
- */
 export function createInMemory(options) {
     const topics = new Map();
     const consumerGroups = new Map();
+    const listeners = new Set();
     let ended = false;
     const defaultOptions = {
-        defaultPartitionKey: "default",
+        defaultPartitionKey: 'default',
     };
     const opts = {
         ...defaultOptions,
@@ -68,141 +25,156 @@ export function createInMemory(options) {
         }
         return state;
     };
-    const adapter = {
-        append(topic, data, appendOptions) {
-            if (ended) {
-                return Promise.reject(new EventLogAppendFailed(topic, "Connector ended"));
-            }
-            const state = getOrCreateTopic(topic);
-            const id = generateId();
-            const sequenceNumber = state.nextSequenceNumber++;
-            const partitionKey = appendOptions?.partitionKey ??
-                opts.defaultPartitionKey;
-            const event = {
-                id,
-                topic,
-                data,
-                partitionKey,
-                sequenceNumber,
-                timestamp: appendOptions?.timestamp ?? Date.now(),
-                metadata: appendOptions?.metadata,
-            };
-            state.events.push(event);
-            return Promise.resolve(id);
-        },
-        get(topic, sequenceNumber) {
-            if (ended) {
-                return Promise.reject(new EventLogGetFailed(topic, sequenceNumber, "Connector ended"));
-            }
-            const state = topics.get(topic);
-            if (!state) {
-                return Promise.resolve(null);
-            }
-            const event = state.events[sequenceNumber];
-            return Promise.resolve(event ?? null);
-        },
-        list(topic, listOptions) {
-            if (ended) {
-                return Promise.reject(new EventLogListFailed(topic, "Connector ended"));
-            }
-            const state = topics.get(topic);
-            if (!state) {
-                return Promise.resolve([]);
-            }
-            let events = state.events;
-            if (listOptions?.fromSequenceNumber !== undefined) {
-                events = events.filter((e) => e.sequenceNumber >= listOptions.fromSequenceNumber);
-            }
-            if (listOptions?.partitionKey !== undefined) {
-                events = events.filter((e) => e.partitionKey === listOptions.partitionKey);
-            }
-            if (listOptions?.limit !== undefined) {
-                events = events.slice(0, listOptions.limit);
-            }
-            return Promise.resolve(events);
-        },
-        async *consume(topic, consumerGroup, consumeOptions) {
-            if (ended) {
-                throw new Error("Connector ended");
-            }
-            let state = topics.get(topic);
-            if (!state) {
-                state = {
-                    events: [],
-                    nextSequenceNumber: 0,
-                };
-                topics.set(topic, state);
-            }
-            let consumerState = consumerGroups.get(consumerGroup);
-            if (!consumerState) {
-                consumerState = { cursors: new Map() };
-                consumerGroups.set(consumerGroup, consumerState);
-            }
-            const batchSize = consumeOptions?.batchSize ?? 10;
-            const startSequence = consumeOptions?.cursor
-                ? parseInt(consumeOptions.cursor, 10) + 1
-                : 0;
-            const signal = consumeOptions?.signal;
-            let currentSequence = startSequence;
-            while (!signal?.aborted) {
-                const events = [];
-                for (let i = 0; i < batchSize; i++) {
-                    const event = state.events[currentSequence];
-                    if (!event)
-                        break;
-                    events.push(event);
-                    currentSequence++;
+    const createAdapter = () => {
+        let closed = false;
+        return {
+            append(topic, data, appendOptions) {
+                if (ended) {
+                    return Promise.reject(new EventLogAppendFailed(topic, 'Connector ended'));
                 }
-                if (events.length === 0) {
-                    await new Promise((resolve) => setTimeout(resolve, 100));
-                    continue;
+                if (closed) {
+                    return Promise.reject(new EventLogAppendFailed(topic, 'Adapter closed'));
                 }
-                const cursor = String(currentSequence - 1);
-                yield {
+                const state = getOrCreateTopic(topic);
+                const id = generateId();
+                const sequenceNumber = state.nextSequenceNumber++;
+                const partitionKey = appendOptions?.partitionKey ??
+                    opts.defaultPartitionKey;
+                const event = {
+                    id,
                     topic,
-                    consumerGroup,
-                    events,
-                    cursor,
+                    data,
+                    partitionKey,
+                    sequenceNumber: String(sequenceNumber),
+                    timestamp: appendOptions?.timestamp ?? Date.now(),
+                    metadata: appendOptions?.metadata,
                 };
-            }
-        },
-        commitCursor(topic, consumerGroup, cursor) {
-            if (ended) {
-                return Promise.reject(new EventLogCommitCursorFailed(topic, consumerGroup, "Connector ended"));
-            }
-            let state = consumerGroups.get(consumerGroup);
-            if (!state) {
-                state = { cursors: new Map() };
-                consumerGroups.set(consumerGroup, state);
-            }
-            state.cursors.set(topic, cursor);
-            return Promise.resolve();
-        },
-        getCursor(topic, consumerGroup) {
-            if (ended) {
-                return Promise.reject(new EventLogGetCursorFailed(topic, consumerGroup, "Connector ended"));
-            }
-            const state = consumerGroups.get(consumerGroup);
-            if (!state) {
-                return Promise.resolve(null);
-            }
-            return Promise.resolve(state.cursors.get(topic) ?? null);
-        },
-        close() {
-            return Promise.resolve();
-        },
+                state.events.push(event);
+                for (const listener of listeners) {
+                    if (listener.topic === topic) {
+                        listener.push();
+                    }
+                }
+                return Promise.resolve(id);
+            },
+            consume(topic, consumerGroup, onBatch, onError, consumeOptions) {
+                if (ended) {
+                    throw new EventLogConsumeFailed(topic, 'Connector ended');
+                }
+                if (closed) {
+                    throw new EventLogConsumeFailed(topic, 'Adapter closed');
+                }
+                let consumerState = consumerGroups.get(consumerGroup);
+                if (!consumerState) {
+                    consumerState = { cursors: new Map() };
+                    consumerGroups.set(consumerGroup, consumerState);
+                }
+                const batchSize = consumeOptions?.batchSize ?? 10;
+                const signal = consumeOptions?.signal;
+                let currentSequence = consumeOptions?.cursor
+                    ? parseInt(consumeOptions.cursor, 10) + 1
+                    : 0;
+                let consumerClosed = false;
+                const drive = async () => {
+                    if (consumerClosed || closed || ended)
+                        return;
+                    const state = topics.get(topic);
+                    if (!state)
+                        return;
+                    const events = [];
+                    while (events.length < batchSize && currentSequence < state.events.length) {
+                        events.push(state.events[currentSequence]);
+                        currentSequence++;
+                    }
+                    if (events.length > 0) {
+                        try {
+                            const cursor = String(currentSequence - 1);
+                            await onBatch({
+                                topic,
+                                consumerGroup,
+                                events,
+                                cursor,
+                                commit: () => {
+                                    if (ended || closed) {
+                                        throw new EventLogCommitCursorFailed(topic, consumerGroup, ended ? 'Connector ended' : 'Adapter closed');
+                                    }
+                                    consumerState.cursors.set(topic, cursor);
+                                    return Promise.resolve();
+                                },
+                            });
+                            if (currentSequence < state.events.length &&
+                                !consumerClosed &&
+                                !closed &&
+                                !ended) {
+                                void drive();
+                            }
+                        }
+                        catch (error) {
+                            await onError(new EventLogConsumeFailed(topic, error instanceof Error ? error.message : String(error), error));
+                        }
+                    }
+                };
+                const listener = { topic, push: drive };
+                listeners.add(listener);
+                drive();
+                const closeConsumer = () => {
+                    if (consumerClosed)
+                        return Promise.resolve();
+                    consumerClosed = true;
+                    listeners.delete(listener);
+                    return Promise.resolve();
+                };
+                signal?.addEventListener('abort', closeConsumer, { once: true });
+                return { close: closeConsumer };
+            },
+            getCursor(topic, consumerGroup) {
+                if (ended) {
+                    return Promise.reject(new EventLogGetCursorFailed(topic, consumerGroup, 'Connector ended'));
+                }
+                if (closed) {
+                    return Promise.reject(new EventLogGetCursorFailed(topic, consumerGroup, 'Adapter closed'));
+                }
+                const state = consumerGroups.get(consumerGroup);
+                if (!state) {
+                    return Promise.resolve(null);
+                }
+                return Promise.resolve(state.cursors.get(topic) ?? null);
+            },
+            commitCursor(topic, consumerGroup, cursor) {
+                if (ended) {
+                    return Promise.reject(new EventLogCommitCursorFailed(topic, consumerGroup, 'Connector ended'));
+                }
+                if (closed) {
+                    return Promise.reject(new EventLogCommitCursorFailed(topic, consumerGroup, 'Adapter closed'));
+                }
+                let consumerState = consumerGroups.get(consumerGroup);
+                if (!consumerState) {
+                    consumerState = { cursors: new Map() };
+                    consumerGroups.set(consumerGroup, consumerState);
+                }
+                consumerState.cursors.set(topic, cursor);
+                return Promise.resolve();
+            },
+            close() {
+                if (closed)
+                    return Promise.resolve();
+                closed = true;
+                return Promise.resolve();
+            },
+        };
     };
     return {
         connect() {
             if (ended) {
-                return Promise.reject(new Error("Connector ended"));
+                return Promise.reject(new EventLogConnectionFailed('Connector ended'));
             }
-            return Promise.resolve(adapter);
+            return Promise.resolve(createAdapter());
         },
         end() {
             ended = true;
             topics.clear();
             consumerGroups.clear();
+            listeners.clear();
             return Promise.resolve();
         },
     };

package/esm/index.d.ts

@@ -61,12 +61,12 @@
  *
  * @module
  */
-export { EventLog } from "./eventlog.js";
-export type { Event, EventBatch, EventLogAdapter, EventLogConnector, } from "./adapter.js";
-export type { AppendOptions, ConsumeOptions, EventLogOptions, ListOptions, } from "./adapter.js";
-export * from "./errors.js";
-export { createInMemory } from "./in-memory.js";
-export type { InMemoryConnector, InMemoryOptions } from "./in-memory.js";
-export { Task } from "anabranch";
-export type { Source, Stream } from "anabranch";
+export { EventLog } from './eventlog.js';
+export type { Event, EventBatch, EventLogAdapter, EventLogConnector, } from './adapter.js';
+export type { AppendOptions, ConsumeOptions, EventLogOptions, } from './adapter.js';
+export * from './errors.js';
+export { createInMemory } from './in-memory.js';
+export type { InMemoryConnector, InMemoryOptions } from './in-memory.js';
+export { Task } from 'anabranch';
+export type { Source, Stream } from 'anabranch';
 //# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,YAAY,EACV,KAAK,EACL,UAAU,EACV,eAAe,EACf,iBAAiB,GAClB,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,aAAa,EACb,cAAc,EACd,eAAe,EACf,WAAW,GACZ,MAAM,cAAc,CAAC;AACtB,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,YAAY,EACV,KAAK,EACL,UAAU,EACV,eAAe,EACf,iBAAiB,GAClB,MAAM,cAAc,CAAA;AACrB,YAAY,EACV,aAAa,EACb,cAAc,EACd,eAAe,GAChB,MAAM,cAAc,CAAA;AACrB,cAAc,aAAa,CAAA;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAC/C,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACxE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA"}

package/esm/index.js

@@ -61,7 +61,7 @@
  *
  * @module
  */
-export { EventLog } from "./eventlog.js";
-export * from "./errors.js";
-export { createInMemory } from "./in-memory.js";
-export { Task } from "anabranch";
+export { EventLog } from './eventlog.js';
+export * from './errors.js';
+export { createInMemory } from './in-memory.js';
+export { Task } from 'anabranch';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anabranch/eventlog",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Event log with Task/Stream semantics. In-memory adapter for event-sourced systems with cursor-based consumption.",
   "repository": {
     "type": "git",