@anabranch/eventlog 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Frodi Karlsson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @anabranch/eventlog
+
+Event log with Task/Stream semantics. In-memory adapter for event-sourced
+systems with cursor-based consumption.
+
+## Usage
+
+```ts
+import {} from "@anabranch/eventlog";
+```
+
+## API
+
+### 
+
+```ts
+```

package/esm/adapter.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Event log adapter interface for event-sourced systems.
+ *
+ * Implement this interface to create drivers for specific event stores.
+ * The EventLog class wraps adapters with Task/Stream semantics.
+ *
+ * For connection lifecycle management, use EventLogConnector which produces adapters.
+ * The adapter's close() method releases the connection rather than terminating it.
+ */
+/** A single event in the log. */
+export interface Event<T = unknown> {
+    /** Unique event identifier (globally unique) */
+    id: string;
+    /** Topic/stream this event belongs to */
+    topic: string;
+    /** Event payload */
+    data: T;
+    /** Partition key for ordering guarantees */
+    partitionKey: string;
+    /** Event sequence number within the topic */
+    sequenceNumber: number;
+    /** Timestamp when the event was created */
+    timestamp: number;
+    /** Optional metadata attached to the event */
+    metadata?: Record<string, unknown>;
+}
+/** A batch of events consumed from a topic. */
+export interface EventBatch<T = unknown> {
+    /** Topic these events belong to */
+    topic: string;
+    /** Consumer group that consumed these events */
+    consumerGroup: string;
+    /** Events in this batch */
+    events: Event<T>[];
+    /** Cursor position for this batch (opaque to caller) */
+    cursor: string;
+}
+/**
+ * Event log adapter interface for low-level operations.
+ */
+export interface EventLogAdapter {
+    /** Append an event to a topic. Returns the event ID. */
+    append<T>(topic: string, data: T, options?: AppendOptions): Promise<string>;
+    /** Get a single event by ID. */
+    get<T>(topic: string, sequenceNumber: number): Promise<Event<T> | null>;
+    /** List events in a topic with optional filtering. */
+    list<T>(topic: string, options?: ListOptions): Promise<Event<T>[]>;
+    /** Consume events from a topic as a streaming async iterable. */
+    consume<T>(topic: string, consumerGroup: string, options?: ConsumeOptions): AsyncIterable<EventBatch<T>>;
+    /** Commit a cursor position for a consumer group. */
+    commitCursor(topic: string, consumerGroup: string, cursor: string): Promise<void>;
+    /** Get the committed cursor position for a consumer group. */
+    getCursor(topic: string, consumerGroup: string): Promise<string | null>;
+    /** Close the adapter connection. */
+    close(): Promise<void>;
+}
+/** Options for appending an event. */
+export interface AppendOptions {
+    /** Partition key for ordering guarantees within the topic */
+    partitionKey?: string;
+    /** Optional metadata attached to the event */
+    metadata?: Record<string, unknown>;
+    /** Timestamp for the event (defaults to now) */
+    timestamp?: number;
+}
+/** Options for listing events. */
+export interface ListOptions {
+    /** Starting sequence number (inclusive) */
+    fromSequenceNumber?: number;
+    /** Maximum number of events to return */
+    limit?: number;
+    /** Filter by partition key */
+    partitionKey?: string;
+}
+/** Options for consuming events. */
+export interface ConsumeOptions {
+    /** Signal for cancellation */
+    signal?: AbortSignal;
+    /** Starting cursor (null means from beginning) */
+    cursor?: string | null;
+    /** Batch size for events */
+    batchSize?: number;
+}
+/** Connector that produces connected EventLogAdapter instances. */
+export interface EventLogConnector {
+    /** Acquire a connected adapter. */
+    connect(signal?: AbortSignal): Promise<EventLogAdapter>;
+    /** Close all connections and clean up resources. */
+    end(): Promise<void>;
+}
+/** Event log configuration options. */
+export interface EventLogOptions {
+    /** Default partition key if not specified */
+    defaultPartitionKey?: string;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/esm/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"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"}

package/esm/adapter.js

@@ -0,0 +1,10 @@
+/**
+ * Event log adapter interface for event-sourced systems.
+ *
+ * Implement this interface to create drivers for specific event stores.
+ * The EventLog class wraps adapters with Task/Stream semantics.
+ *
+ * For connection lifecycle management, use EventLogConnector which produces adapters.
+ * The adapter's close() method releases the connection rather than terminating it.
+ */
+export {};

package/esm/errors.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Error thrown when an event log connection cannot be established.
+ */
+export declare class EventLogConnectionFailed extends Error {
+    name: string;
+    constructor(message: string, cause?: unknown);
+}
+/** Error thrown when an append operation fails. */
+export declare class EventLogAppendFailed extends Error {
+    name: string;
+    constructor(topic: string, message: string, cause?: unknown);
+}
+/** Error thrown when getting an event fails. */
+export declare class EventLogGetFailed extends Error {
+    name: string;
+    constructor(topic: string, sequenceNumber: number, message: string, cause?: unknown);
+}
+/** Error thrown when listing events fails. */
+export declare class EventLogListFailed extends Error {
+    name: string;
+    constructor(topic: string, message: string, cause?: unknown);
+}
+/** Error thrown when committing a cursor fails. */
+export declare class EventLogCommitCursorFailed extends Error {
+    name: string;
+    constructor(topic: string, consumerGroup: string, message: string, cause?: unknown);
+}
+/** Error thrown when getting a cursor fails. */
+export declare class EventLogGetCursorFailed extends Error {
+    name: string;
+    constructor(topic: string, consumerGroup: string, message: string, cause?: unknown);
+}
+/** Error thrown when closing an event log connection fails. */
+export declare class EventLogCloseFailed extends Error {
+    name: string;
+    constructor(message: string, cause?: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map

package/esm/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IACxC,IAAI,SAA8B;gBAC/B,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAG7C;AAED,mDAAmD;AACnD,qBAAa,oBAAqB,SAAQ,KAAK;IACpC,IAAI,SAA0B;gBAC3B,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAG5D;AAED,gDAAgD;AAChD,qBAAa,iBAAkB,SAAQ,KAAK;IACjC,IAAI,SAAuB;gBAElC,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,OAAO;CAOlB;AAED,8CAA8C;AAC9C,qBAAa,kBAAmB,SAAQ,KAAK;IAClC,IAAI,SAAwB;gBACzB,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAG5D;AAED,mDAAmD;AACnD,qBAAa,0BAA2B,SAAQ,KAAK;IAC1C,IAAI,SAAgC;gBAE3C,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,OAAO;CAOlB;AAED,gDAAgD;AAChD,qBAAa,uBAAwB,SAAQ,KAAK;IACvC,IAAI,SAA6B;gBAExC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,OAAO;CAOlB;AAED,+DAA+D;AAC/D,qBAAa,mBAAoB,SAAQ,KAAK;IACnC,IAAI,SAAyB;gBAC1B,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;CAG7C"}

package/esm/errors.js

@@ -0,0 +1,86 @@
+/**
+ * Error thrown when an event log connection cannot be established.
+ */
+export class EventLogConnectionFailed extends Error {
+    constructor(message, cause) {
+        super(`Event log connection failed: ${message}`, { cause });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "EventLogConnectionFailed"
+        });
+    }
+}
+/** Error thrown when an append operation fails. */
+export class EventLogAppendFailed extends Error {
+    constructor(topic, message, cause) {
+        super(`Failed to append to ${topic}: ${message}`, { cause });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "EventLogAppendFailed"
+        });
+    }
+}
+/** Error thrown when getting an event fails. */
+export class EventLogGetFailed extends Error {
+    constructor(topic, sequenceNumber, message, cause) {
+        super(`Failed to get event ${sequenceNumber} from ${topic}: ${message}`, { cause });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "EventLogGetFailed"
+        });
+    }
+}
+/** Error thrown when listing events fails. */
+export class EventLogListFailed extends Error {
+    constructor(topic, message, cause) {
+        super(`Failed to list events from ${topic}: ${message}`, { cause });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "EventLogListFailed"
+        });
+    }
+}
+/** Error thrown when committing a cursor fails. */
+export class EventLogCommitCursorFailed extends Error {
+    constructor(topic, consumerGroup, message, cause) {
+        super(`Failed to commit cursor for ${consumerGroup} on ${topic}: ${message}`, { cause });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "EventLogCommitCursorFailed"
+        });
+    }
+}
+/** Error thrown when getting a cursor fails. */
+export class EventLogGetCursorFailed extends Error {
+    constructor(topic, consumerGroup, message, cause) {
+        super(`Failed to get cursor for ${consumerGroup} on ${topic}: ${message}`, { cause });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "EventLogGetCursorFailed"
+        });
+    }
+}
+/** Error thrown when closing an event log connection fails. */
+export class EventLogCloseFailed extends Error {
+    constructor(message, cause) {
+        super(`Event log close failed: ${message}`, { cause });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "EventLogCloseFailed"
+        });
+    }
+}

package/esm/eventlog.d.ts

@@ -0,0 +1,171 @@
+import { Source, Task } from "anabranch";
+import type { AppendOptions, ConsumeOptions, Event, EventBatch, EventLogAdapter, EventLogConnector, ListOptions } from "./adapter.js";
+import { EventLogAppendFailed, EventLogCloseFailed, EventLogCommitCursorFailed, EventLogConnectionFailed, EventLogGetCursorFailed, EventLogGetFailed, EventLogListFailed } from "./errors.js";
+/**
+ * EventLog wrapper with Task/Stream semantics for event-sourced systems.
+ *
+ * @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();
+ *
+ * // Get a specific event
+ * const event = await log.get("users", 0).run();
+ *
+ * // List events
+ * const events = await log.list("users").run();
+ *
+ * await log.close().run();
+ * ```
+ *
+ * @example Consuming events as a stream
+ * ```ts
+ * const { successes, errors } = await log
+ *   .consume("users", "my-consumer-group")
+ *   .withConcurrency(5)
+ *   .map(async (batch) => {
+ *     for (const event of batch.events) {
+ *       await handleEvent(event.data);
+ *     }
+ *     // Explicitly commit after successful processing!
+ *     await log.commit(batch.topic, batch.consumerGroup, batch.cursor).run();
+ *   })
+ *   .partition();
+ * ```
+ */
+export declare class EventLog {
+    private readonly adapter;
+    constructor(adapter: EventLogAdapter);
+    /**
+     * Connect to an event log via a connector.
+     *
+     * @example
+     * ```ts
+     * const log = await EventLog.connect(createInMemory()).run();
+     * ```
+     */
+    static connect(connector: EventLogConnector): Task<EventLog, EventLogConnectionFailed>;
+    /**
+     * Release the connection back to its source.
+     *
+     * @example
+     * ```ts
+     * await log.close().run();
+     * ```
+     */
+    close(): Task<void, EventLogCloseFailed>;
+    /**
+     * Append an event to a topic.
+     *
+     * @example Basic append
+     * ```ts
+     * const eventId = await log.append("users", { action: "created", userId: 123 }).run();
+     * ```
+     *
+     * @example With partition key
+     * ```ts
+     * const eventId = await log.append("orders", orderData, {
+     *   partitionKey: orderData.userId,
+     * }).run();
+     * ```
+     */
+    append<T>(topic: string, data: T, options?: AppendOptions): Task<string, EventLogAppendFailed>;
+    /**
+     * Get a single event by topic and sequence number.
+     *
+     * @example
+     * ```ts
+     * const event = await log.get("users", 0).run();
+     * if (event) {
+     *   console.log(event.data);
+     * }
+     * ```
+     */
+    get<T>(topic: string, sequenceNumber: number): Task<Event<T> | null, EventLogGetFailed>;
+    /**
+     * List events in a topic with optional filtering and pagination.
+     *
+     * @example List all events
+     * ```ts
+     * const events = await log.list("users").run();
+     * ```
+     *
+     * @example With pagination
+     * ```ts
+     * const events = await log.list("users", {
+     *   fromSequenceNumber: 100,
+     *   limit: 50,
+     * }).run();
+     * ```
+     *
+     * @example Filtered by partition key
+     * ```ts
+     * const events = await log.list("orders", {
+     *   partitionKey: "user-123",
+     * }).run();
+     * ```
+     */
+    list<T>(topic: string, options?: ListOptions): Task<Event<T>[], EventLogListFailed>;
+    /**
+     * Consume events from a topic as a Source for streaming.
+     *
+     * Note: You must manually commit the cursor after processing to guarantee
+     * at-least-once delivery. Auto-commit is intentionally omitted to prevent
+     * data loss when using concurrent processing.
+     *
+     * @example Basic consumption
+     * ```ts
+     * const { successes, errors } = await log
+     *   .consume("users", "processor-1")
+     *   .withConcurrency(5)
+     *   .map(async (batch) => {
+     *     for (const event of batch.events) {
+     *       await handleEvent(event.data);
+     *     }
+     *     await log.commit(batch.topic, batch.consumerGroup, batch.cursor).run();
+     *   })
+     *   .partition();
+     * ```
+     *
+     * @example From specific cursor position
+     * ```ts
+     * const lastCursor = await log.getCommittedCursor("users", "processor-1").run();
+     * const { successes } = await log
+     *   .consume("users", "processor-1", { cursor: lastCursor })
+     *   .tap(async (batch) => {
+     *     for (const event of batch.events) {
+     *       console.log(event);
+     *     }
+     *   })
+     *   .partition();
+     * ```
+     */
+    consume<T>(topic: string, consumerGroup: string, options?: ConsumeOptions): Source<EventBatch<T>, EventLogListFailed>;
+    /**
+     * Commit a cursor position for a consumer group.
+     *
+     * @example
+     * ```ts
+     * await log.commit("users", "processor-1", cursor).run();
+     * ```
+     */
+    commit(topic: string, consumerGroup: string, cursor: string): Task<void, EventLogCommitCursorFailed>;
+    /**
+     * Get the committed cursor position for a consumer group.
+     *
+     * @example
+     * ```ts
+     * const cursor = await log.getCommittedCursor("users", "processor-1").run();
+     * if (cursor) {
+     *   console.log(`Resuming from cursor: ${cursor}`);
+     * }
+     * ```
+     */
+    getCommittedCursor(topic: string, consumerGroup: string): Task<string | null, EventLogGetCursorFailed>;
+}
+//# sourceMappingURL=eventlog.d.ts.map

package/esm/eventlog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventlog.d.ts","sourceRoot":"","sources":["../src/eventlog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,KAAK,EACL,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,WAAW,EACZ,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,0BAA0B,EAC1B,wBAAwB,EACxB,uBAAuB,EACvB,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,QAAQ;IACP,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,eAAe;IAErD;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,CACZ,SAAS,EAAE,iBAAiB,GAC3B,IAAI,CAAC,QAAQ,EAAE,wBAAwB,CAAC;IAa3C;;;;;;;OAOG;IACH,KAAK,IAAI,IAAI,CAAC,IAAI,EAAE,mBAAmB,CAAC;IAaxC;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,CAAC,EACN,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,aAAa,GACtB,IAAI,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAcrC;;;;;;;;;;OAUG;IACH,GAAG,CAAC,CAAC,EACH,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,GACrB,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,iBAAiB,CAAC;IAe3C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,IAAI,CAAC,CAAC,EACJ,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,WAAW,GACpB,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,kBAAkB,CAAC;IAcvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,OAAO,CAAC,CAAC,EACP,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,cAAc,GACvB,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,kBAAkB,CAAC;IAmB5C;;;;;;;OAOG;IACH,MAAM,CACJ,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,GACb,IAAI,CAAC,IAAI,EAAE,0BAA0B,CAAC;IAezC;;;;;;;;;;OAUG;IACH,kBAAkB,CAChB,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,IAAI,CAAC,MAAM,GAAG,IAAI,EAAE,uBAAuB,CAAC;CAchD"}

package/esm/eventlog.js

@@ -0,0 +1,250 @@
+import { Source, Task } from "anabranch";
+import { EventLogAppendFailed, EventLogCloseFailed, EventLogCommitCursorFailed, EventLogConnectionFailed, EventLogGetCursorFailed, EventLogGetFailed, EventLogListFailed, } from "./errors.js";
+/**
+ * EventLog wrapper with Task/Stream semantics for event-sourced systems.
+ *
+ * @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();
+ *
+ * // Get a specific event
+ * const event = await log.get("users", 0).run();
+ *
+ * // List events
+ * const events = await log.list("users").run();
+ *
+ * await log.close().run();
+ * ```
+ *
+ * @example Consuming events as a stream
+ * ```ts
+ * const { successes, errors } = await log
+ *   .consume("users", "my-consumer-group")
+ *   .withConcurrency(5)
+ *   .map(async (batch) => {
+ *     for (const event of batch.events) {
+ *       await handleEvent(event.data);
+ *     }
+ *     // Explicitly commit after successful processing!
+ *     await log.commit(batch.topic, batch.consumerGroup, batch.cursor).run();
+ *   })
+ *   .partition();
+ * ```
+ */
+export class EventLog {
+    constructor(adapter) {
+        Object.defineProperty(this, "adapter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: adapter
+        });
+    }
+    /**
+     * Connect to an event log via a connector.
+     *
+     * @example
+     * ```ts
+     * const log = await EventLog.connect(createInMemory()).run();
+     * ```
+     */
+    static connect(connector) {
+        return Task.of(async () => {
+            try {
+                return new EventLog(await connector.connect());
+            }
+            catch (error) {
+                throw new EventLogConnectionFailed(error instanceof Error ? error.message : String(error), error);
+            }
+        });
+    }
+    /**
+     * Release the connection back to its source.
+     *
+     * @example
+     * ```ts
+     * await log.close().run();
+     * ```
+     */
+    close() {
+        return Task.of(async () => {
+            try {
+                await this.adapter.close();
+            }
+            catch (error) {
+                throw new EventLogCloseFailed(error instanceof Error ? error.message : String(error), error);
+            }
+        });
+    }
+    /**
+     * Append an event to a topic.
+     *
+     * @example Basic append
+     * ```ts
+     * const eventId = await log.append("users", { action: "created", userId: 123 }).run();
+     * ```
+     *
+     * @example With partition key
+     * ```ts
+     * const eventId = await log.append("orders", orderData, {
+     *   partitionKey: orderData.userId,
+     * }).run();
+     * ```
+     */
+    append(topic, data, options) {
+        return Task.of(async () => {
+            try {
+                return await this.adapter.append(topic, data, options);
+            }
+            catch (error) {
+                throw new EventLogAppendFailed(topic, error instanceof Error ? error.message : String(error), error);
+            }
+        });
+    }
+    /**
+     * Get a single event by topic and sequence number.
+     *
+     * @example
+     * ```ts
+     * const event = await log.get("users", 0).run();
+     * if (event) {
+     *   console.log(event.data);
+     * }
+     * ```
+     */
+    get(topic, sequenceNumber) {
+        return Task.of(async () => {
+            try {
+                return await this.adapter.get(topic, sequenceNumber);
+            }
+            catch (error) {
+                throw new EventLogGetFailed(topic, sequenceNumber, error instanceof Error ? error.message : String(error), error);
+            }
+        });
+    }
+    /**
+     * List events in a topic with optional filtering and pagination.
+     *
+     * @example List all events
+     * ```ts
+     * const events = await log.list("users").run();
+     * ```
+     *
+     * @example With pagination
+     * ```ts
+     * const events = await log.list("users", {
+     *   fromSequenceNumber: 100,
+     *   limit: 50,
+     * }).run();
+     * ```
+     *
+     * @example Filtered by partition key
+     * ```ts
+     * const events = await log.list("orders", {
+     *   partitionKey: "user-123",
+     * }).run();
+     * ```
+     */
+    list(topic, options) {
+        return Task.of(async () => {
+            try {
+                return await this.adapter.list(topic, options);
+            }
+            catch (error) {
+                throw new EventLogListFailed(topic, error instanceof Error ? error.message : String(error), error);
+            }
+        });
+    }
+    /**
+     * Consume events from a topic as a Source for streaming.
+     *
+     * Note: You must manually commit the cursor after processing to guarantee
+     * at-least-once delivery. Auto-commit is intentionally omitted to prevent
+     * data loss when using concurrent processing.
+     *
+     * @example Basic consumption
+     * ```ts
+     * const { successes, errors } = await log
+     *   .consume("users", "processor-1")
+     *   .withConcurrency(5)
+     *   .map(async (batch) => {
+     *     for (const event of batch.events) {
+     *       await handleEvent(event.data);
+     *     }
+     *     await log.commit(batch.topic, batch.consumerGroup, batch.cursor).run();
+     *   })
+     *   .partition();
+     * ```
+     *
+     * @example From specific cursor position
+     * ```ts
+     * const lastCursor = await log.getCommittedCursor("users", "processor-1").run();
+     * const { successes } = await log
+     *   .consume("users", "processor-1", { cursor: lastCursor })
+     *   .tap(async (batch) => {
+     *     for (const event of batch.events) {
+     *       console.log(event);
+     *     }
+     *   })
+     *   .partition();
+     * ```
+     */
+    consume(topic, consumerGroup, options) {
+        const adapter = this.adapter;
+        return Source.from(async function* () {
+            try {
+                for await (const batch of adapter.consume(topic, consumerGroup, options)) {
+                    yield batch;
+                }
+            }
+            catch (error) {
+                throw new EventLogListFailed(topic, error instanceof Error ? error.message : String(error), error);
+            }
+        });
+    }
+    /**
+     * Commit a cursor position for a consumer group.
+     *
+     * @example
+     * ```ts
+     * await log.commit("users", "processor-1", cursor).run();
+     * ```
+     */
+    commit(topic, consumerGroup, cursor) {
+        return Task.of(async () => {
+            try {
+                await this.adapter.commitCursor(topic, consumerGroup, cursor);
+            }
+            catch (error) {
+                throw new EventLogCommitCursorFailed(topic, consumerGroup, error instanceof Error ? error.message : String(error), error);
+            }
+        });
+    }
+    /**
+     * Get the committed cursor position for a consumer group.
+     *
+     * @example
+     * ```ts
+     * const cursor = await log.getCommittedCursor("users", "processor-1").run();
+     * if (cursor) {
+     *   console.log(`Resuming from cursor: ${cursor}`);
+     * }
+     * ```
+     */
+    getCommittedCursor(topic, consumerGroup) {
+        return Task.of(async () => {
+            try {
+                return await this.adapter.getCursor(topic, consumerGroup);
+            }
+            catch (error) {
+                throw new EventLogGetCursorFailed(topic, consumerGroup, error instanceof Error ? error.message : String(error), error);
+            }
+        });
+    }
+}

package/esm/in-memory.d.ts

@@ -0,0 +1,55 @@
+import type { EventLogAdapter, EventLogConnector, EventLogOptions } from "./adapter.js";
+/**
+ * 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 declare function createInMemory(options?: InMemoryOptions): InMemoryConnector;
+/** In-memory event log connector options. */
+export interface InMemoryOptions extends EventLogOptions {
+}
+/** In-memory event log connector. */
+export interface InMemoryConnector extends EventLogConnector {
+    connect(): Promise<EventLogAdapter>;
+    end(): Promise<void>;
+}
+//# sourceMappingURL=in-memory.d.ts.map

package/esm/in-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory.d.ts","sourceRoot":"","sources":["../src/in-memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,eAAe,EACf,iBAAiB,EACjB,eAAe,EAEhB,MAAM,cAAc,CAAC;AAsBtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,iBAAiB,CA0O3E;AAED,6CAA6C;AAC7C,MAAM,WAAW,eAAgB,SAAQ,eAAe;CAAG;AAE3D,qCAAqC;AACrC,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC1D,OAAO,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;IACpC,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB"}

package/esm/in-memory.js

@@ -0,0 +1,209 @@
+import { EventLogAppendFailed, EventLogCommitCursorFailed, EventLogGetCursorFailed, EventLogGetFailed, EventLogListFailed, } 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();
+    let ended = false;
+    const defaultOptions = {
+        defaultPartitionKey: "default",
+    };
+    const opts = {
+        ...defaultOptions,
+        ...options,
+    };
+    const getOrCreateTopic = (topic) => {
+        let state = topics.get(topic);
+        if (!state) {
+            state = {
+                events: [],
+                nextSequenceNumber: 0,
+            };
+            topics.set(topic, state);
+        }
+        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++;
+                }
+                if (events.length === 0) {
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                    continue;
+                }
+                const cursor = String(currentSequence - 1);
+                yield {
+                    topic,
+                    consumerGroup,
+                    events,
+                    cursor,
+                };
+            }
+        },
+        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();
+        },
+    };
+    return {
+        connect() {
+            if (ended) {
+                return Promise.reject(new Error("Connector ended"));
+            }
+            return Promise.resolve(adapter);
+        },
+        end() {
+            ended = true;
+            topics.clear();
+            consumerGroups.clear();
+            return Promise.resolve();
+        },
+    };
+}

package/esm/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @anabranch/eventlog
+ *
+ * Event log primitives with Task/Stream semantics for event-sourced systems.
+ * Integrates with anabranch's {@linkcode Task}, {@linkcode Stream}, {@linkcode Source}, and
+ * {@linkcode Channel} types for composable error handling and concurrent processing.
+ *
+ * ## Adapters vs Connectors
+ *
+ * An **EventLogConnector** produces connected **EventLogAdapter** instances. Use connectors for
+ * production code to properly manage connection lifecycles:
+ *
+ * - **Connector**: Manages connection pool/lifecycle, produces adapters
+ * - **Adapter**: Low-level append/get/list/consume interface
+ * - **EventLog**: Wrapper providing Task/Stream methods over an adapter
+ *
+ * ## Core Types
+ *
+ * - {@link EventLogConnector} - Interface for connection factories
+ * - {@link EventLogAdapter} - Low-level event log operations interface
+ * - {@link EventLog} - High-level wrapper with Task/Stream methods
+ * - {@link Event} - Single event envelope with id, data, sequence number
+ * - {@link EventBatch} - Batch of events consumed from a topic
+ *
+ * ## Error Types
+ *
+ * All errors are typed for catchable handling:
+ * - {@link EventLogConnectionFailed} - Connection establishment failed
+ * - {@link EventLogAppendFailed} - Append operation failed
+ * - {@link EventLogGetFailed} - Get event operation failed
+ * - {@link EventLogListFailed} - List events operation failed
+ * - {@link EventLogCommitCursorFailed} - Cursor commit failed
+ * - {@link EventLogGetCursorFailed} - Get cursor operation failed
+ *
+ * @example Basic usage with Task semantics
+ * ```ts
+ * import { EventLog, createInMemory } from "@anabranch/eventlog";
+ *
+ * const connector = createInMemory();
+ * const log = await EventLog.connect(connector).run();
+ *
+ * const eventId = await log.append("users", { action: "created", userId: 123 }).run();
+ * const events = await log.list("users").run();
+ * ```
+ *
+ * @example Consuming events as a stream with auto-commit
+ * ```ts
+ * const connector = createInMemory();
+ * const log = await EventLog.connect(connector).run();
+ *
+ * const { successes, errors } = await log
+ *   .consume("users", "my-processor")
+ *   .withConcurrency(5)
+ *   .map(async (batch) => {
+ *     for (const event of batch.events) {
+ *       await processEvent(event.data);
+ *     }
+ *   })
+ *   .partition();
+ * ```
+ *
+ * @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";
+//# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -0,0 +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"}

package/esm/index.js

@@ -0,0 +1,67 @@
+/**
+ * @anabranch/eventlog
+ *
+ * Event log primitives with Task/Stream semantics for event-sourced systems.
+ * Integrates with anabranch's {@linkcode Task}, {@linkcode Stream}, {@linkcode Source}, and
+ * {@linkcode Channel} types for composable error handling and concurrent processing.
+ *
+ * ## Adapters vs Connectors
+ *
+ * An **EventLogConnector** produces connected **EventLogAdapter** instances. Use connectors for
+ * production code to properly manage connection lifecycles:
+ *
+ * - **Connector**: Manages connection pool/lifecycle, produces adapters
+ * - **Adapter**: Low-level append/get/list/consume interface
+ * - **EventLog**: Wrapper providing Task/Stream methods over an adapter
+ *
+ * ## Core Types
+ *
+ * - {@link EventLogConnector} - Interface for connection factories
+ * - {@link EventLogAdapter} - Low-level event log operations interface
+ * - {@link EventLog} - High-level wrapper with Task/Stream methods
+ * - {@link Event} - Single event envelope with id, data, sequence number
+ * - {@link EventBatch} - Batch of events consumed from a topic
+ *
+ * ## Error Types
+ *
+ * All errors are typed for catchable handling:
+ * - {@link EventLogConnectionFailed} - Connection establishment failed
+ * - {@link EventLogAppendFailed} - Append operation failed
+ * - {@link EventLogGetFailed} - Get event operation failed
+ * - {@link EventLogListFailed} - List events operation failed
+ * - {@link EventLogCommitCursorFailed} - Cursor commit failed
+ * - {@link EventLogGetCursorFailed} - Get cursor operation failed
+ *
+ * @example Basic usage with Task semantics
+ * ```ts
+ * import { EventLog, createInMemory } from "@anabranch/eventlog";
+ *
+ * const connector = createInMemory();
+ * const log = await EventLog.connect(connector).run();
+ *
+ * const eventId = await log.append("users", { action: "created", userId: 123 }).run();
+ * const events = await log.list("users").run();
+ * ```
+ *
+ * @example Consuming events as a stream with auto-commit
+ * ```ts
+ * const connector = createInMemory();
+ * const log = await EventLog.connect(connector).run();
+ *
+ * const { successes, errors } = await log
+ *   .consume("users", "my-processor")
+ *   .withConcurrency(5)
+ *   .map(async (batch) => {
+ *     for (const event of batch.events) {
+ *       await processEvent(event.data);
+ *     }
+ *   })
+ *   .partition();
+ * ```
+ *
+ * @module
+ */
+export { EventLog } from "./eventlog.js";
+export * from "./errors.js";
+export { createInMemory } from "./in-memory.js";
+export { Task } from "anabranch";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@anabranch/eventlog",
+  "version": "0.1.0",
+  "description": "Event log with Task/Stream semantics. In-memory adapter for event-sourced systems with cursor-based consumption.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frodi-karlsson/anabranch.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/frodi-karlsson/anabranch.git"
+  },
+  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js"
+    }
+  },
+  "scripts": {},
+  "dependencies": {
+    "anabranch": "^0"
+  },
+  "_generatedBy": "dnt@dev"
+}