@schemeless/event-store-types 3.2.2 → 5.0.0

package/dist/Errors.d.ts

@@ -4,3 +4,44 @@ export declare class ConcurrencyError extends Error {
     readonly actualSequence: number;
     constructor(streamKey: string, expectedSequence: number, actualSequence: number);
 }
+export declare class EventStoreError extends Error {
+    constructor(message: string);
+}
+export declare class ValidationError extends EventStoreError {
+    readonly flow: {
+        domain: string;
+        type: string;
+    };
+    readonly eventId: string;
+    readonly cause: Error;
+    constructor(flow: {
+        domain: string;
+        type: string;
+    }, eventId: string, cause: Error);
+}
+export declare class FlowNotFoundError extends EventStoreError {
+    readonly domain: string;
+    readonly type: string;
+    constructor(domain: string, type: string);
+}
+export declare class AggregateError extends EventStoreError {
+    readonly flow: {
+        domain: string;
+        type: string;
+    };
+    readonly reason: 'no_loader' | 'no_identifier' | 'apply_must_return_state' | 'capability_missing';
+    constructor(flow: {
+        domain: string;
+        type: string;
+    }, reason: 'no_loader' | 'no_identifier' | 'apply_must_return_state' | 'capability_missing');
+}
+export declare class ShutdownTimeoutError extends EventStoreError {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+export declare class RevertError extends EventStoreError {
+    readonly eventId: string;
+    readonly reason: 'not_found' | 'not_root' | 'missing_compensate' | 'repo_not_supported';
+    readonly details?: string;
+    constructor(eventId: string, reason: 'not_found' | 'not_root' | 'missing_compensate' | 'repo_not_supported', details?: string);
+}

package/dist/Errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConcurrencyError = void 0;
+exports.RevertError = exports.ShutdownTimeoutError = exports.AggregateError = exports.FlowNotFoundError = exports.ValidationError = exports.EventStoreError = exports.ConcurrencyError = void 0;
 class ConcurrencyError extends Error {
     constructor(streamKey, expectedSequence, actualSequence) {
         super(`Concurrency conflict on stream "${streamKey}": expected sequence ${expectedSequence}, but found ${actualSequence}`);
@@ -11,3 +11,69 @@ class ConcurrencyError extends Error {
     }
 }
 exports.ConcurrencyError = ConcurrencyError;
+class EventStoreError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'EventStoreError';
+    }
+}
+exports.EventStoreError = EventStoreError;
+class ValidationError extends EventStoreError {
+    constructor(flow, eventId, cause) {
+        super(`Validation failed for ${flow.domain}/${flow.type} (event ${eventId}): ${cause.message}`);
+        this.flow = flow;
+        this.eventId = eventId;
+        this.cause = cause;
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+class FlowNotFoundError extends EventStoreError {
+    constructor(domain, type) {
+        super(`No EventFlow registered for "${domain}/${type}". ` +
+            `Make sure the EventFlow is included in the eventFlows array passed to makeEventStore.`);
+        this.domain = domain;
+        this.type = type;
+        this.name = 'FlowNotFoundError';
+    }
+}
+exports.FlowNotFoundError = FlowNotFoundError;
+class AggregateError extends EventStoreError {
+    constructor(flow, reason) {
+        const messages = {
+            no_loader: 'requires getAggregate() support to load state',
+            no_identifier: 'requires an identifier (set event.identifier or aggregate.getIdentifier)',
+            apply_must_return_state: 'apply() must return the new state object',
+            capability_missing: 'requires adapter with getStreamEvents() support',
+        };
+        super(`AggregateEventFlow ${flow.domain}/${flow.type}: ${messages[reason]}`);
+        this.flow = flow;
+        this.reason = reason;
+        this.name = 'AggregateError';
+    }
+}
+exports.AggregateError = AggregateError;
+class ShutdownTimeoutError extends EventStoreError {
+    constructor(timeoutMs) {
+        super(`EventStore shutdown timed out after ${timeoutMs}ms`);
+        this.timeoutMs = timeoutMs;
+        this.name = 'ShutdownTimeoutError';
+    }
+}
+exports.ShutdownTimeoutError = ShutdownTimeoutError;
+class RevertError extends EventStoreError {
+    constructor(eventId, reason, details) {
+        const messages = {
+            not_found: `Event not found: ${eventId}`,
+            not_root: `Event ${eventId} is not a root event. Revert the root event instead.`,
+            missing_compensate: `Some events in the tree lack a 'compensate' hook`,
+            repo_not_supported: 'Repository must implement getEventById and findByCausationId',
+        };
+        super(messages[reason] + (details ? `. ${details}` : ''));
+        this.eventId = eventId;
+        this.reason = reason;
+        this.details = details;
+        this.name = 'RevertError';
+    }
+}
+exports.RevertError = RevertError;

package/dist/EventStore.types.d.ts

@@ -43,14 +43,15 @@ export interface CreatedEvent<Payload, META extends EventMeta = EventMeta> exten
 export interface StoredEvent<Payload, META extends EventMeta = EventMeta> extends CreatedEvent<Payload, META> {
 }
 export type Event<Payload, META extends EventMeta = EventMeta> = StoredEvent<Payload, META>;
-export interface EventFlow<PartialPayload = any, Payload extends PartialPayload = PartialPayload> {
+export interface EventFlow<PartialPayload = any, Payload extends PartialPayload = PartialPayload, META extends EventMeta = EventMeta> {
+    readonly kind?: 'simple';
     readonly domain: string;
     readonly type: string;
     readonly description?: string;
     readonly meta?: {
         readonly sideEffectFailedRetryAllowed?: number;
     };
-    readonly eventType?: CreatedEvent<Payload>;
+    readonly eventType?: CreatedEvent<Payload, META>;
     readonly payloadType?: PartialPayload | Payload;
     readonly samplePayload?: PartialPayload | Payload;
     /**
@@ -67,7 +68,7 @@ export interface EventFlow<PartialPayload = any, Payload extends PartialPayload
      * @param fromVersion - The version stored in event.meta.schemaVersion (defaults to 1)
      * @returns Updated event with migrated payload, or void to use the original
      */
-    readonly upcast?: (event: CreatedEvent<any>, fromVersion: number) => CreatedEvent<Payload> | Promise<CreatedEvent<Payload>> | void;
+    readonly upcast?: (event: CreatedEvent<any, META>, fromVersion: number) => CreatedEvent<Payload, META> | Promise<CreatedEvent<Payload, META>> | void;
     /**
      * Extract the shard key for event routing.
      * Events with the same shard key will be processed sequentially in the same partition.
@@ -78,16 +79,21 @@ export interface EventFlow<PartialPayload = any, Payload extends PartialPayload
      * @example
      * getShardKey: (event) => event.payload.userId
      */
-    readonly getShardKey?: (event: BaseEvent<Payload>) => string | undefined;
+    readonly getShardKey?: (event: BaseEvent<Payload, META>) => string | undefined;
+    /**
+     * @deprecated The `receive` pattern will be replaced in v5.
+     * Instead of `const send = MyEvent.receive(eventStore); await send(input);`
+     * use `await eventStore.submit(MyEvent, input);` directly.
+     */
     readonly receive: (eventStore: {
-        receive: (eventFlow: EventFlow<PartialPayload, Payload>) => (eventInput: BaseEventInput<PartialPayload>) => Promise<[CreatedEvent<Payload>, ...Array<CreatedEvent<any>>]>;
-    }) => (eventInputArgs: BaseEventInput<PartialPayload>) => Promise<[CreatedEvent<Payload>, ...Array<CreatedEvent<any>>]>;
-    readonly validate?: (event: CreatedEvent<Payload>) => Promise<Error | void> | Error | void;
-    readonly preApply?: (event: CreatedEvent<PartialPayload>) => Promise<CreatedEvent<Payload> | void> | CreatedEvent<Payload> | void;
-    readonly apply?: (event: CreatedEvent<Payload>) => Promise<void> | void;
-    readonly sideEffect?: (event: CreatedEvent<Payload>) => Promise<void | BaseEvent<any>[]> | void | BaseEvent<any>[];
-    readonly cancelApply?: (event: CreatedEvent<Payload>) => Promise<void> | void;
-    readonly createConsequentEvents?: (causalEvent: CreatedEvent<Payload>) => Promise<BaseEvent<any>[]> | BaseEvent<any>[];
+        receive: (eventFlow: EventFlow<PartialPayload, Payload, META>) => (eventInput: BaseEventInput<PartialPayload, META>) => Promise<[CreatedEvent<Payload, META>, ...Array<CreatedEvent<any>>]>;
+    }) => (eventInputArgs: BaseEventInput<PartialPayload, META>) => Promise<[CreatedEvent<Payload, META>, ...Array<CreatedEvent<any>>]>;
+    readonly validate?: (event: CreatedEvent<Payload, META>) => Promise<Error | void> | Error | void;
+    readonly preApply?: (event: CreatedEvent<PartialPayload, META>) => Promise<CreatedEvent<Payload, META> | void> | CreatedEvent<Payload, META> | void;
+    readonly apply?: (event: CreatedEvent<Payload, META>) => Promise<void> | void;
+    readonly sideEffect?: (event: CreatedEvent<Payload, META>) => Promise<void | BaseEvent<any>[]> | void | BaseEvent<any>[];
+    readonly cancelApply?: (event: CreatedEvent<Payload, META>) => Promise<void> | void;
+    readonly createConsequentEvents?: (causalEvent: CreatedEvent<Payload, META>) => Promise<BaseEvent<any>[]> | BaseEvent<any>[];
     /**
      * Generates compensating event(s) to reverse this event's effects.
      * Called by the framework during revert operations.
@@ -99,7 +105,22 @@ export interface EventFlow<PartialPayload = any, Payload extends PartialPayload
      * @param originalEvent - The event being reverted
      * @returns Compensating event(s) to persist
      */
-    readonly compensate?: (originalEvent: CreatedEvent<Payload>) => BaseEvent<any> | BaseEvent<any>[];
+    readonly compensate?: (originalEvent: CreatedEvent<Payload, META>) => BaseEvent<any> | BaseEvent<any>[];
+}
+export interface AggregateConfig<State> {
+    readonly reducer: (state: State, event: CreatedEvent<any>) => State;
+    readonly initialState: State;
+    readonly getIdentifier?: (event: BaseEvent<any>) => string | undefined;
+}
+export interface AggregateEventFlow<PartialPayload = any, Payload extends PartialPayload = PartialPayload, State = any, META extends EventMeta = EventMeta> extends Omit<EventFlow<PartialPayload, Payload, META>, 'validate' | 'apply' | 'kind'> {
+    readonly kind?: 'aggregate';
+    readonly aggregate: AggregateConfig<State>;
+    readonly validate?: (event: CreatedEvent<Payload, META>, state: State) => Promise<Error | void> | Error | void;
+    readonly apply?: (event: CreatedEvent<Payload, META>, state: State) => State | Promise<State>;
+}
+export interface AggregateEventObserver<Payload = any, State = any> extends Omit<SuccessEventObserver<Payload>, 'apply'> {
+    readonly aggregate: true;
+    readonly apply?: (event: CreatedEvent<Payload>, state: State) => Promise<void> | void;
 }
 export type EventTaskAndError = {
     task: CreatedEvent<any>;
@@ -139,4 +160,13 @@ export declare enum EventOutputState {
 export declare enum EventObserverState {
     success = "Observer:success"
 }
+/**
+ * Use this type when defining new EventFlows.
+ * The `kind` field enables TypeScript to narrow the type automatically.
+ */
+export type TypedEventFlow<P = any, S = any> = (EventFlow<P, P> & {
+    readonly kind: 'simple';
+}) | (AggregateEventFlow<P, P, S> & {
+    readonly kind: 'aggregate';
+});
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schemeless/event-store-types",
-  "version": "3.2.2",
+  "version": "5.0.0",
   "typescript:main": "src/index.ts",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,5 +34,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "6ac7d0b17a54531dc0e0026e4519cee575bba857"
+  "gitHead": "b391c1569bd4416b1aca13037d1a20a4d5899f25"
 }