@arts-n-crafts/ts 3.13.1

package/dist/index.d.ts

@@ -0,0 +1,420 @@
+type WithIdentifier<T = object> = {
+    id: string;
+} & T;
+
+interface CommandMetadata {
+    correlationId?: string;
+    causationId?: string;
+    [key: string]: unknown;
+}
+interface Command<TType = string, TPayload = unknown> extends WithIdentifier {
+    type: TType;
+    aggregateId: string;
+    payload: TPayload;
+    kind: 'command';
+    timestamp: string;
+    metadata: Partial<CommandMetadata>;
+}
+
+interface CommandHandler<CommandType extends Command, TReturnType = Promise<void>> {
+    execute(aCommand: CommandType): TReturnType;
+}
+
+interface IntegrationEventMetadata {
+    correlationId?: string;
+    causationId?: string;
+    [key: string]: unknown;
+}
+interface IntegrationEvent<TPayload = unknown> {
+    id: string;
+    type: string;
+    source: 'external';
+    payload: TPayload;
+    timestamp: string;
+    metadata: {} & Partial<IntegrationEventMetadata>;
+}
+
+interface DomainEventMetadata {
+    correlationId?: string;
+    causationId?: string;
+    [key: string]: unknown;
+}
+interface DomainEvent<TPayload = unknown> {
+    id: string;
+    type: string;
+    aggregateId: string;
+    source: 'internal';
+    payload: TPayload;
+    timestamp: string;
+    metadata: Partial<DomainEventMetadata>;
+}
+
+type BaseEvent<TPayload = unknown> = DomainEvent<TPayload> | IntegrationEvent<TPayload>;
+
+interface Handling<TEvent extends BaseEvent, TReturnType> {
+    handle(anEvent: TEvent): TReturnType;
+}
+interface EventHandler<TEvent extends BaseEvent, TReturnType = Promise<void>> extends Handling<TEvent, TReturnType> {
+}
+
+type Module = Record<symbol, unknown>;
+
+interface QueryMetadata {
+    [key: string]: unknown;
+}
+interface Query<TType = string, TPayload = unknown> extends WithIdentifier {
+    type: TType;
+    payload: TPayload;
+    kind: 'query';
+    timestamp: string;
+    metadata: Partial<QueryMetadata>;
+}
+
+interface QueryHandler<TQuery extends Query, TProjection = Promise<unknown>> {
+    execute(aQuery: TQuery): TProjection;
+}
+
+type FilledArray = [Record<string, unknown>, ...Record<string, unknown>[]];
+
+type Maybe<T> = T | null | undefined;
+
+type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};
+
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+
+declare function createCommand<TType extends string, TPayload>(type: TType, aggregateId: string, payload: TPayload, metadata?: Partial<CommandMetadata>): Command<TType, TPayload>;
+
+declare function createQuery<TType extends string, TPayload>(type: TType, payload: TPayload, metadata?: QueryMetadata): Query<TType, TPayload>;
+
+declare function isCommand(candidate: unknown): candidate is Command<string, unknown>;
+
+declare function isQuery(candidate: unknown): candidate is Query<unknown>;
+
+interface Identifiable<TId> {
+    id: TId;
+}
+interface HasProperties<TProps extends object> {
+    props: TProps;
+}
+interface hasOutbox<TEvent extends DomainEvent> {
+    uncommittedEvents: TEvent[];
+}
+interface EventBased<TEvent extends DomainEvent> {
+    fromEvents(events: TEvent[]): void;
+}
+interface AggregateRoot<TId, TProps extends object, TEvent extends DomainEvent> extends Identifiable<TId>, HasProperties<TProps>, hasOutbox<TEvent> {
+    get id(): TId;
+    get props(): TProps;
+    get uncommittedEvents(): TEvent[];
+}
+interface EventBasedAggregateRoot<TId, TProps extends object, TEvent extends DomainEvent> extends AggregateRoot<TId, TProps, TEvent>, EventBased<TEvent> {
+}
+
+interface Decider<TState, TCommand, TEvent extends DomainEvent> {
+    decide(this: void, command: TCommand, currentState: TState): TEvent[];
+    evolve(this: void, currentState: TState, event: TEvent): TState;
+    initialState(this: void, id: string): TState;
+}
+
+interface Loadable$1<TReturnType> {
+    load(aggregateId: string): TReturnType;
+}
+interface Storable<TEvent, TReturnType = Promise<void>> {
+    store(events: TEvent[]): TReturnType;
+}
+interface Repository<TEvent, TLoadReturnType, TStoreReturnType = Promise<void>> extends Loadable$1<TLoadReturnType>, Storable<TEvent, TStoreReturnType> {
+    readonly streamName: string;
+}
+
+type QueryNode = {
+    type: 'eq' | 'gt' | 'lt';
+    field: string | number | symbol;
+    value: Primitive;
+} | {
+    type: 'and' | 'or';
+    nodes: QueryNode[];
+} | {
+    type: 'not';
+    node: QueryNode;
+};
+
+declare abstract class Specification<T> {
+    abstract isSatisfiedBy(entity: T): boolean;
+    abstract toQuery(): QueryNode;
+    and(other: Specification<T>): Specification<T>;
+    or(other: Specification<T>): Specification<T>;
+    not(): Specification<T>;
+}
+declare class AndSpecification<T> extends Specification<T> {
+    private left;
+    private right;
+    constructor(left: Specification<T>, right: Specification<T>);
+    isSatisfiedBy(entity: T): boolean;
+    toQuery(): QueryNode;
+}
+declare class OrSpecification<T> extends Specification<T> {
+    private left;
+    private right;
+    constructor(left: Specification<T>, right: Specification<T>);
+    isSatisfiedBy(entity: T): boolean;
+    toQuery(): QueryNode;
+}
+declare class NotSpecification<T> extends Specification<T> {
+    private spec;
+    constructor(spec: Specification<T>);
+    isSatisfiedBy(entity: T): boolean;
+    toQuery(): QueryNode;
+}
+
+declare class FieldEquals<T> extends Specification<T> {
+    private field;
+    private value;
+    constructor(field: keyof T, value: Primitive);
+    isSatisfiedBy(entity: T): boolean;
+    toQuery(): QueryNode;
+}
+
+declare class FieldGreaterThan<T> extends Specification<T> {
+    private field;
+    private value;
+    constructor(field: keyof T, value: number);
+    private isNumber;
+    isSatisfiedBy(entity: T): boolean;
+    toQuery(): QueryNode;
+}
+
+declare function createQueryNode(type: 'eq' | 'gt' | 'lt', field: string | number | symbol, value: Primitive): QueryNode;
+declare function createQueryNode(type: 'and' | 'or', field: undefined, value: QueryNode[]): QueryNode;
+declare function createQueryNode(type: 'not', field: undefined, value: QueryNode): QueryNode;
+
+declare function createDomainEvent<TPayload = unknown>(type: string, aggregateId: string, payload: TPayload, metadata?: Partial<DomainEventMetadata>): DomainEvent<TPayload>;
+
+declare function isDomainEvent(event: unknown): event is DomainEvent;
+
+declare function isEvent(event: unknown): event is BaseEvent;
+
+interface Registerable$1<TCommand extends Command, TResult = void> {
+    register(aTypeOfCommand: TCommand['type'], anHandler: CommandHandler<TCommand>): TResult;
+}
+interface Executable$2<TCommand extends Command, TResult = Promise<void>> {
+    execute(aCommand: TCommand): TResult;
+}
+interface CommandBus<TCommand extends Command, TExecutionResult = Promise<void>, TRegisterResult = void> extends Executable$2<TCommand, TExecutionResult>, Registerable$1<TCommand, TRegisterResult> {
+}
+
+declare class SimpleCommandBus<TCommand extends Command> implements CommandBus<TCommand> {
+    private handlers;
+    register(aTypeOfCommand: TCommand['type'], anHandler: CommandHandler<TCommand>): void;
+    execute(aCommand: TCommand): Promise<void>;
+}
+
+declare enum Operation {
+    CREATE = "CREATE",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
+}
+interface Statement<TModel> {
+    operation: Operation;
+    payload: TModel;
+}
+interface CreateStatement<TModel> extends Statement<TModel> {
+    operation: Operation.CREATE;
+    payload: TModel;
+}
+interface PutStatement<TModel> extends Statement<TModel> {
+    operation: Operation.PUT;
+    payload: TModel;
+}
+interface PatchStatement<TModel> extends Statement<Partial<TModel>> {
+    operation: Operation.PATCH;
+    payload: WithIdentifier<Partial<TModel>>;
+}
+interface DeleteStatement extends Statement<WithIdentifier> {
+    operation: Operation.DELETE;
+    payload: WithIdentifier;
+}
+interface Executable$1<TModel, TReturnType = Promise<void>> {
+    execute(tableName: string, statement: CreateStatement<TModel>): TReturnType;
+    execute(tableName: string, statement: PutStatement<TModel>): TReturnType;
+    execute(tableName: string, statement: PatchStatement<TModel>): TReturnType;
+    execute(tableName: string, statement: DeleteStatement): TReturnType;
+}
+interface QueryAble<TModel, TReturnType = Promise<TModel[]>> {
+    query(collectionName: string, specification: Specification<TModel>): TReturnType;
+}
+interface Database<TModel, TExecuteReturnType = void, TQueryReturnType = Promise<TModel[]>> extends QueryAble<TModel, TQueryReturnType>, Executable$1<TModel, TExecuteReturnType> {
+}
+
+declare class SimpleDatabase<TModel extends WithIdentifier> implements Database<TModel, Promise<void>, Promise<TModel[]>> {
+    private readonly datasource;
+    private simulateOffline;
+    query(tableName: string, specification: Specification<TModel>): Promise<TModel[]>;
+    execute(tableName: string, statement: CreateStatement<TModel> | PutStatement<TModel> | PatchStatement<TModel> | DeleteStatement): Promise<void>;
+    goOffline(): void;
+}
+
+interface EventProducer<TEvent extends BaseEvent, TReturnType = Promise<void>> {
+    publish(stream: string, anEvent: TEvent): TReturnType;
+}
+interface EventConsumer<TEvent extends BaseEvent, TEventHandler = EventHandler<TEvent>, TConsumeReturnType = Promise<void>, TSubscribeReturnType = void> {
+    subscribe(stream: string, handler: TEventHandler): TSubscribeReturnType;
+    consume(stream: string, anEvent: TEvent): TConsumeReturnType;
+}
+
+declare class SimpleEventBus<TEvent extends BaseEvent> implements EventConsumer<TEvent>, EventProducer<TEvent> {
+    private handlers;
+    subscribe(stream: string, aHandler: EventHandler<TEvent>): void;
+    consume(stream: string, anEvent: TEvent): Promise<void>;
+    publish(stream: string, anEvent: TEvent): Promise<void>;
+}
+
+declare function createIntegrationEvent<TPayload = unknown>(type: string, payload: TPayload, metadata?: Partial<IntegrationEventMetadata>): IntegrationEvent<TPayload>;
+
+declare function isIntegrationEvent<TPayload>(event: unknown): event is IntegrationEvent<TPayload>;
+
+declare function fail(anExpression: Error): () => never;
+
+declare function invariant(condition: boolean, onInvalid: () => never): asserts condition;
+
+declare function isEqual<T>(a: T, b: T): boolean;
+
+declare function parseAsError(value: unknown): Error;
+
+type StreamKey = `${string}#${string}`;
+
+declare function makeStreamKey(streamName: string, aggregateId: string): StreamKey;
+
+interface StoredEvent<TEvent> {
+    id: string;
+    streamKey: StreamKey;
+    version: number;
+    createdAt: string;
+    event: TEvent;
+}
+
+interface Loadable<TEvent, TReturnType = Promise<StoredEvent<TEvent>>> {
+    load(streamName: string, aggregateId: string): TReturnType;
+}
+interface Appendable<TEvent, TReturnType = Promise<void>> {
+    append(streamName: string, events: TEvent[]): TReturnType;
+}
+interface EventStore<TEvent, TAppendReturnType = Promise<void>, TLoadReturnType = Promise<TEvent[]>> extends Loadable<TEvent, TLoadReturnType>, Appendable<TEvent, TAppendReturnType> {
+}
+
+interface OutboxEntry {
+    id: string;
+    event: DomainEvent;
+    published: boolean;
+    retryCount: number;
+    lastAttemptAt?: string;
+}
+
+interface Queueable<TReturnType = Promise<void>> {
+    enqueue(event: OutboxEntry['event']): TReturnType;
+}
+interface Outbox<TEnqueueReturnType = Promise<void>, TGetPendingReturnType = Promise<OutboxEntry[]>, TMarkAsPublishedReturnType = Promise<void>, TMarkAsFailedReturnType = Promise<void>> extends Queueable<TEnqueueReturnType> {
+    getPending(limit?: number): TGetPendingReturnType;
+    markAsPublished(id: string): TMarkAsPublishedReturnType;
+    markAsFailed(id: string): TMarkAsFailedReturnType;
+}
+
+declare class SimpleEventStore<TEvent extends DomainEvent> implements EventStore<TEvent, Promise<void>, Promise<TEvent[]>> {
+    private readonly database;
+    private readonly outbox?;
+    private readonly tableName;
+    constructor(database: Database<StoredEvent<TEvent>, Promise<void>, Promise<StoredEvent<TEvent>[]>>, outbox?: Outbox | undefined);
+    load(streamName: string, aggregateId: string): Promise<TEvent[]>;
+    append(streamName: string, events: TEvent[]): Promise<void>;
+}
+
+declare function createStoredEvent<TEvent extends DomainEvent>(streamName: string, version: number, event: TEvent): StoredEvent<TEvent>;
+
+interface Runnable<TReturnType = Promise<void>> {
+    runOnce(): TReturnType;
+}
+interface Tickable<TReturnType = Promise<void>> {
+    tick(): TReturnType;
+}
+interface Startable<TReturnType = void> {
+    start(intervalMs: number): TReturnType;
+}
+interface OutboxWorker extends Runnable, Tickable, Startable {
+}
+
+declare class GenericOutboxWorker implements OutboxWorker {
+    protected outbox: Outbox;
+    protected eventBus: EventProducer<BaseEvent>;
+    protected stream: string;
+    constructor(outbox: Outbox, eventBus: EventProducer<BaseEvent>, stream: string);
+    runOnce(): Promise<void>;
+    tick(): Promise<void>;
+    start(intervalMs: number): void;
+}
+
+declare class InMemoryOutbox implements Outbox {
+    protected entries: OutboxEntry[];
+    protected idCounter: number;
+    enqueue(event: DomainEvent<unknown>): Promise<void>;
+    getPending(limit?: number): Promise<OutboxEntry[]>;
+    markAsPublished(id: string): Promise<void>;
+    markAsFailed(id: string): Promise<void>;
+}
+
+declare function createOutboxEntry(event: DomainEvent<unknown>): OutboxEntry;
+
+interface Registerable<TQuery extends Query, TResult = void> {
+    register(aTypeOfQuery: TQuery['type'], anHandler: QueryHandler<TQuery>): TResult;
+}
+interface Executable<TQuery extends Query, TResult = Promise<unknown>> {
+    execute(aQuery: TQuery): TResult;
+}
+interface QueryBus<TQuery extends Query, TExecutionResult, TRegisterResult = void> extends Executable<TQuery, TExecutionResult>, Registerable<TQuery, TRegisterResult> {
+}
+
+declare class SimpleQueryBus<TQuery extends Query, TProjection> implements QueryBus<TQuery, Promise<TProjection>> {
+    private handlers;
+    register(aTypeOfQuery: TQuery['type'], anHandler: QueryHandler<TQuery, Promise<TProjection>>): void;
+    execute(aQuery: TQuery): Promise<TProjection>;
+}
+
+declare class SimpleRepository<TState, TCommand, TEvent extends DomainEvent> implements Repository<TEvent, Promise<TState>, Promise<void>> {
+    private readonly eventStore;
+    readonly streamName: string;
+    private readonly evolveFn;
+    private readonly initialState;
+    constructor(eventStore: EventStore<TEvent, Promise<void>, Promise<TEvent[]>>, streamName: string, evolveFn: Decider<TState, TCommand, TEvent>['evolve'], initialState: Decider<TState, TCommand, TEvent>['initialState']);
+    load(aggregateId: string): Promise<TState>;
+    store(events: TEvent[]): Promise<void>;
+}
+
+type GivenInput = (DomainEvent | IntegrationEvent)[];
+type WhenInput = Command | Query | DomainEvent | IntegrationEvent;
+type ThenInput = DomainEvent | Array<Record<string, unknown>>;
+declare class ScenarioTest<TState, TEvent extends DomainEvent> {
+    private readonly streamName;
+    private readonly eventBus;
+    private readonly eventStore;
+    private readonly commandBus;
+    private readonly queryBus;
+    private readonly repository;
+    private readonly outboxWorker;
+    private givenInput;
+    private whenInput;
+    constructor(streamName: string, eventBus: EventProducer<BaseEvent> & EventConsumer<BaseEvent>, eventStore: EventStore<TEvent, Promise<void>, Promise<TEvent[]>>, commandBus: CommandBus<Command>, queryBus: QueryBus<Query, Promise<Record<string, unknown>[]>>, repository: Repository<DomainEvent, Promise<TState>>, outboxWorker: OutboxWorker);
+    given(...events: GivenInput): {
+        when(action: WhenInput): ReturnType<ScenarioTest<TState, TEvent>['when']>;
+        then(outcome: ThenInput): Promise<void>;
+    };
+    when(action: WhenInput): {
+        then(outcome: ThenInput): Promise<void>;
+    };
+    then(thenInput: ThenInput): Promise<void>;
+    private handleCommand;
+    private handleQuery;
+    private handleEvent;
+}
+
+export { type AggregateRoot, AndSpecification, type BaseEvent, type Command, type CommandBus, type CommandHandler, type CommandMetadata, type CreateStatement, type Database, type Decider, type DeleteStatement, type DomainEvent, type DomainEventMetadata, type EventBasedAggregateRoot, type EventConsumer, type EventHandler, type EventProducer, type EventStore, FieldEquals, FieldGreaterThan, type FilledArray, GenericOutboxWorker, InMemoryOutbox, type IntegrationEvent, type IntegrationEventMetadata, type Maybe, type Module, NotSpecification, type Nullable, Operation, OrSpecification, type Outbox, type OutboxEntry, type OutboxWorker, type PatchStatement, type Primitive, type PutStatement, type Query, type QueryBus, type QueryHandler, type QueryMetadata, type QueryNode, type Repository, ScenarioTest, SimpleCommandBus, SimpleDatabase, SimpleEventBus, SimpleEventStore, SimpleQueryBus, SimpleRepository, Specification, type StoredEvent, type StreamKey, type WithIdentifier, createCommand, createDomainEvent, createIntegrationEvent, createOutboxEntry, createQuery, createQueryNode, createStoredEvent, fail, invariant, isCommand, isDomainEvent, isEqual, isEvent, isIntegrationEvent, isQuery, makeStreamKey, parseAsError };