@schemeless/event-store-types 3.3.0 → 4.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

@@ -44,6 +44,7 @@ export interface StoredEvent<Payload, META extends EventMeta = EventMeta> extend
 }
 export type Event<Payload, META extends EventMeta = EventMeta> = StoredEvent<Payload, META>;
 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;
@@ -79,6 +80,11 @@ export interface EventFlow<PartialPayload = any, Payload extends PartialPayload
      * getShardKey: (event) => event.payload.userId
      */
     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, META>) => (eventInput: BaseEventInput<PartialPayload, META>) => Promise<[CreatedEvent<Payload, META>, ...Array<CreatedEvent<any>>]>;
     }) => (eventInputArgs: BaseEventInput<PartialPayload, META>) => Promise<[CreatedEvent<Payload, META>, ...Array<CreatedEvent<any>>]>;
@@ -106,7 +112,8 @@ export interface AggregateConfig<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'> {
+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>;
@@ -153,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.3.0",
+  "version": "4.0.0",
   "typescript:main": "src/index.ts",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,5 +34,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "92568fe932ab2dc550ba5795789b3fa602d3ce37"
+  "gitHead": "067b860ae72ec74b66ea4cdc179b6a0975a3f2d4"
 }