woltage/dist/src/adapters/EventStore.d.ts

A CQRS and Event-Sourcing Framework

import type { Readable } from 'stream';
import type Event from '../Event.ts';
export interface ReadableStream<T> extends Readable {
    addListener(event: 'data', listener: (data: T) => void): this;
    addListener(event: 'error', listener: (err: Error) => void): this;
    addListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
    on(event: 'data', listener: (data: T) => void): this;
    on(event: 'error', listener: (err: Error) => void): this;
    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
    once(event: 'data', listener: (data: T) => void): this;
    once(event: 'error', listener: (err: Error) => void): this;
    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
    prependListener(event: 'data', listener: (data: T) => void): this;
    prependListener(event: 'error', listener: (err: Error) => void): this;
    prependListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
    prependOnceListener(event: 'data', listener: (data: T) => void): this;
    prependOnceListener(event: 'error', listener: (err: Error) => void): this;
    prependOnceListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
    removeListener(event: 'data', listener: (data: T) => void): this;
    removeListener(event: 'error', listener: (err: Error) => void): this;
    removeListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
}
export declare const START = "start";
export declare const END = "end";
export type ReadRevision = bigint | typeof START | typeof END;
export declare const STATE_NEW = "state_new";
export declare const STATE_EXISTS = "state_exists";
export type AppendRevision = bigint | typeof STATE_NEW | typeof STATE_EXISTS;
export declare const FORWARDS = "forwards";
export declare const BACKWARDS = "backwards";
export type Direction = typeof FORWARDS | typeof BACKWARDS;
export type ReadOptions = {
    fromRevision?: ReadRevision;
    direction?: Direction;
};
export type Filter = {
    types?: string[];
};
export type SubscribeOptions = {
    fromRevision?: ReadRevision;
    filter?: Filter;
};
export type SubscriptionStream = ReadableStream<Event>;
export interface IEventStore {
    connect(): Promise<void>;
    close(force?: boolean): Promise<void>;
    read(aggregateName: string, aggregateId: string, options?: ReadOptions): AsyncIterableIterator<Event>;
    append(aggregateName: string, aggregateId: string, events: Event[], revision?: AppendRevision): Promise<void>;
    subscribe(options?: SubscribeOptions): SubscriptionStream;
    getLatestPosition(filter?: Filter): Promise<bigint | null>;
}