evtstore/src/types.d.ts

Event Sourcing with Node.JS

export type HandlerHooks = {
    preRun?: () => Promise<void>;
    postRun?: (events: number, handled: number) => Promise<void>;
};
export type Event = {
    type: string;
};
export type Command = {
    type: string;
};
export type Aggregate = {};
export type StoreEvent<E = unknown, A = unknown> = EventMeta & {
    event: E & {
        __persisted?: A;
    };
};
export type ProviderBookmark = {
    readonly name: string;
    getPosition(): Promise<any>;
    setPosition(position: any): Promise<void>;
};
export type DomainOptions<E extends Event, A extends Aggregate> = {
    aggregate: () => A;
    stream: string;
    fold: Fold<E, A>;
    provider: Provider<E> | Promise<Provider<E>>;
    useCache?: boolean;
};
export type StreamsHandler<T extends {
    [key: string]: Event;
}> = <TStream extends keyof T, TType extends T[TStream]['type']>(stream: TStream, type: TType, handler: (id: string, event: Ext<T[TStream], TType>, meta: EventMeta) => any) => void;
export type HandlerBookmark = string | ProviderBookmark;
export type EventMeta = {
    stream: string;
    position: any;
    version: number;
    timestamp: Date;
    aggregateId: string;
};
export type ErrorCallback = (err: any, stream: string, bookmark: string, event?: Event & {
    [key: string]: any;
}) => any;
type ID = {
    aggregateId: string;
};
export type BaseAggregate = {
    version: number;
    aggregateId: string;
    __pv?: string;
};
export type Fold<E extends Event, A extends Aggregate> = (ev: E, agg: A & BaseAggregate, meta: EventMeta) => Partial<A>;
export type Provider<Evt extends Event> = {
    driver: string;
    onError: ErrorCallback;
    getPosition(bookmark: string): Promise<any>;
    setPosition(bookmark: string, position: any): Promise<void>;
    getEventsFrom(stream: string | string[], position: any, limit?: number): Promise<Array<StoreEvent<Evt>>>;
    getEventsFor(stream: string, aggregateId: string, fromPosition?: any): Promise<Array<StoreEvent<Evt>>>;
    getLastEventFor(stream: string | string[], aggregateId?: string): Promise<StoreEvent<Evt & {
        __persisted?: any;
    }> | undefined>;
    createEvents(stream: string, aggregateId: string, version: number, event: Evt[]): Array<StoreEvent<Evt>>;
    append(stream: string, aggregateId: string, version: number, event: StoreEvent<Evt>[]): Promise<Array<StoreEvent<Evt>>>;
    limit?: number;
};
export type Handler<E extends Event> = {
    start(): void;
    stop(): void;
    reset(): void;
    runOnce(): Promise<number>;
    handle: <T extends E['type']>(type: T, cb: (aggregateId: string, event: Ext<E, T>, meta: EventMeta) => Promise<any>) => void;
    handlers: (body: HandlerBody<E>) => void;
    name: string;
};
export type Ext<E extends Event, T extends E['type']> = E extends {
    type: T;
} ? E : never;
export type CommandHandler<E extends Event, A extends Aggregate, C extends Command> = {
    [key in C['type']]: (cmd: OptCmd<C, key> & ID, agg: A & BaseAggregate) => Promise<E | E[] | void>;
};
type OptCmd<C extends Command, T extends C['type']> = Omit<Ext<C, T>, 'type'> & {
    type: T;
};
export type DomainHandlerOpts = {
    hooks?: HandlerHooks;
    /** Start handling events from the end of the stream */
    tailStream?: boolean;
    /** Every time the handler starts, always start from the end of the stream */
    alwaysTailStream?: boolean;
    /** When a handler throws, continue processing events */
    continueOnError?: boolean;
};
export type Domain<E extends Event, A extends Aggregate, C extends Command> = {
    handler(bookmark: string, options?: DomainHandlerOpts): Handler<E>;
    command: CmdBody<C, A>;
    getAggregate(id: string): Promise<ExecutableAggregate<C, A> & {
        aggregate: Readonly<A & BaseAggregate>;
    }>;
    retry?: boolean;
};
export type CmdBody<C extends Command, A extends Aggregate> = {
    [cmd in C['type']]: (aggId: string, body: ExtCmd<C, cmd>) => Promise<A & BaseAggregate>;
};
export type ExecutableAggregate<C extends Command, A extends Aggregate> = {
    [cmd in C['type']]: (body: ExtCmd<C, cmd>) => Promise<ExecutableAggregate<C, A> & {
        aggregate: Readonly<A & BaseAggregate>;
    }>;
};
type ExtCmd<C extends Command, T extends C['type']> = Omit<Ext<C, T>, 'type'>;
export type HandlerBody<E extends Event> = {
    [evt in E['type']]?: (id: string, evt: Ext<E, evt>, meta: EventMeta) => Promise<any>;
};
export type StorableAggregate<E extends Event = any, A extends Aggregate = any, S extends string = string> = {
    stream: S;
    fold: Fold<E, A>;
    aggregate: () => A;
    version?: string;
    persistAggregate?: boolean;
};
export type AggregateStore = {
    [key: string]: StorableAggregate;
};
export type ProvidedAggregate<E extends Event, A extends Aggregate, S extends string = string> = {
    stream: S;
    provider: Provider<E> | Promise<Provider<E>>;
    getAggregate: (id: string) => Promise<A & BaseAggregate>;
    toNextAggregate: (prev: A & BaseAggregate, event: StoreEvent<E>) => A & BaseAggregate;
    version?: string;
    persistAggregate?: boolean;
};
export {};