@ddd-ts/event-sourcing-firestore 0.0.37 → 0.0.39

package/dist/projection/testkit/case-fixture.d.ts

@@ -0,0 +1,610 @@
+import * as fb from "firebase-admin";
+import { Firestore } from "firebase-admin/firestore";
+import { ESProjection, ProjectedStream, CheckpointId, Lock } from "@ddd-ts/core";
+import { FirestoreTransactionPerformer, FirestoreTransaction, FirestoreStore } from "@ddd-ts/store-firestore";
+import { FirestoreProjectedStreamReader } from "../../firestore.projected-stream.reader";
+import { FirestoreProjector, FirestoreQueueStore } from "../firestore.projector";
+import { Cashflow } from "@ddd-ts/core/dist/projections/spec/cashflow/cashflow";
+export declare const locks: {
+    wholeAccount: (e: any) => Lock;
+    accountAndEventId: (e: any) => Lock;
+    rename: (e: any) => Lock;
+};
+export declare const traits: {
+    Transaction: () => {
+        factory: (base: import("@ddd-ts/traits").ApplyTraits<readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }]>, Props: {}) => abstract new (props: {
+            transaction: import("@ddd-ts/core").TransactionPerformer<any>;
+        }) => {
+            description: import("@ddd-ts/core/dist/projections/handlers/description").Description<{
+                name: "withTransaction";
+                process: "transactionally";
+            }>;
+            props: {
+                transaction: import("@ddd-ts/core").TransactionPerformer<any>;
+            };
+            context: {
+                trx: any;
+            };
+            process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            event: import("@ddd-ts/core").IEsEvent<string, any>;
+            handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {
+                trx: any;
+            }): Promise<void>;
+            locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+        };
+        superTraits: readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }];
+        symbol: symbol;
+    };
+    Context: () => {
+        factory: (base: import("@ddd-ts/traits").ApplyTraits<readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }]>) => abstract new (param: {}) => {
+            description: import("@ddd-ts/core/dist/projections/handlers/description").Description<{
+                name: "WithContext";
+                process: "with async context";
+            }>;
+            process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            context: {};
+            event: import("@ddd-ts/core").IEsEvent<string, any>;
+            handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+            locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+        };
+        superTraits: readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }];
+        symbol: symbol;
+    };
+    Suspense: () => {
+        factory: (base: import("@ddd-ts/traits").ApplyTraits<readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }]>) => abstract new (props: {
+            transaction: import("@ddd-ts/core").TransactionPerformer;
+        }) => {
+            description: import("@ddd-ts/core/dist/projections/handlers/description").Description<{
+                name: "withSuspense";
+                before_process: "block if an event is suspended";
+            }>;
+            transaction: import("@ddd-ts/core").TransactionPerformer;
+            context: {
+                transaction: import("@ddd-ts/core").Transaction;
+            };
+            suspended: Map<string, (suspension: {
+                resume: () => void;
+                fail: (err?: any) => void;
+            }) => void>;
+            suspend(event: import("@ddd-ts/core").IEsEvent | import("@ddd-ts/core").EventId): Promise<{
+                resume: () => void;
+                fail: (err?: any) => void;
+            }>;
+            releases: Map<string, {
+                resolve: () => void;
+                reject: (err: any) => void;
+            }>;
+            resume(event: import("@ddd-ts/core").IEsEvent | import("@ddd-ts/core").EventId): void;
+            fail(event: import("@ddd-ts/core").IEsEvent | import("@ddd-ts/core").EventId, error?: any): void;
+            shouldFail: Set<string>;
+            markFailing(event: import("@ddd-ts/core").IEsEvent | import("@ddd-ts/core").EventId): () => void;
+            _intercept(event: import("@ddd-ts/core").IEsEvent): Promise<void>;
+            _memory: [import("@ddd-ts/core").IEsEvent, "before" | "after"][];
+            _remember_before(events: import("@ddd-ts/core").IEsEvent[]): void;
+            _remember_after(events: import("@ddd-ts/core").IEsEvent[]): void;
+            prettyMemory(): string[];
+            process(events: import("@ddd-ts/core").IEsEvent[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            event: import("@ddd-ts/core").IEsEvent<string, any>;
+            handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {
+                transaction: import("@ddd-ts/core").Transaction;
+            }): Promise<void>;
+            locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+        };
+        superTraits: readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }];
+        symbol: symbol;
+    };
+    Parallel: () => {
+        factory: (base: import("@ddd-ts/traits").ApplyTraits<readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }]>) => abstract new (param: {}) => {
+            description: import("@ddd-ts/core/dist/projections/handlers/description").Description<{
+                name: "WithParallel";
+                process: "await parallel for (const event of events)";
+                handle: "call handleOne for the event";
+            }>;
+            handleOne(event: import("@ddd-ts/core").IEsEvent<string, any>, context: {}): Promise<void>;
+            handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+            process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: any): Promise<import("@ddd-ts/core").EventId[]>;
+            context: {};
+            event: import("@ddd-ts/core").IEsEvent<string, any>;
+            locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+        };
+        superTraits: readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }];
+        symbol: symbol;
+    };
+    Sequential: () => {
+        factory: (base: import("@ddd-ts/traits").ApplyTraits<readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }]>) => abstract new (param: {}) => {
+            description: import("@ddd-ts/core/dist/projections/handlers/description").Description<{
+                name: "WithSequential";
+                process: "for await (const event of events)";
+                handle: "call handleOne for the event";
+            }>;
+            handleOne(event: import("@ddd-ts/core").IEsEvent<string, any>, context: {}): Promise<void>;
+            handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+            process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: any): Promise<import("@ddd-ts/core").EventId[]>;
+            context: {};
+            event: import("@ddd-ts/core").IEsEvent<string, any>;
+            locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+        };
+        superTraits: readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }];
+        symbol: symbol;
+    };
+    LocalRetry: (attempts: number, delay: number) => {
+        factory: (base: import("@ddd-ts/traits").ApplyTraits<readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }]>) => abstract new (param: {}) => {
+            description: import("@ddd-ts/core/dist/projections/handlers/description").Description<{
+                name: "WithLocalRetry";
+                process: `try ${number} times with ${number}ms delay`;
+            }>;
+            context: {
+                retryCount: number;
+            };
+            process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            event: import("@ddd-ts/core").IEsEvent<string, any>;
+            handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {
+                retryCount: number;
+            }): Promise<void>;
+            locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+        };
+        superTraits: readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }];
+        symbol: symbol;
+    };
+    LocalTimeout: (ms: number) => {
+        factory: (base: import("@ddd-ts/traits").ApplyTraits<readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }]>) => abstract new (param: {}) => {
+            description: import("@ddd-ts/core/dist/projections/handlers/description").Description<{
+                name: "WithLocalTimeout";
+                process: `timeout after ${number}ms of processing`;
+            }>;
+            timeout: number;
+            process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            context: {};
+            event: import("@ddd-ts/core").IEsEvent<string, any>;
+            handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+            locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+        };
+        superTraits: readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }];
+        symbol: symbol;
+    };
+    ClaimTimeout: (ms: number) => {
+        factory: (base: import("@ddd-ts/traits").ApplyTraits<readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }]>) => abstract new (param: {}) => {
+            description: import("@ddd-ts/core/dist/projections/handlers/description").Description<{
+                name: "WithClaimTimeout";
+                after_process: `queue: unclaims after ${number}ms of claiming`;
+            }>;
+            getClaimTimeout(event: import("@ddd-ts/core").IEsEvent<string, any>): number;
+            context: {};
+            event: import("@ddd-ts/core").IEsEvent<string, any>;
+            handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+            locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+            process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+        };
+        superTraits: readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }];
+        symbol: symbol;
+    };
+    Delay: (ms: number) => {
+        factory: (base: import("@ddd-ts/traits").ApplyTraits<readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }]>) => abstract new (param: {}) => {
+            description: import("@ddd-ts/core/dist/projections/handlers/description").Description<{
+                name: "WithDelay";
+                process: `sleep ${number}ms before handling`;
+            }>;
+            delayMs: number;
+            process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            context: {};
+            event: import("@ddd-ts/core").IEsEvent<string, any>;
+            handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+            locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+        };
+        superTraits: readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }];
+        symbol: symbol;
+    };
+    SkipAfter: (ms: number) => {
+        factory: (base: import("@ddd-ts/traits").ApplyTraits<readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }]>) => abstract new (param: {}) => {
+            description: import("@ddd-ts/core/dist/projections/handlers/description").Description<{
+                name: "WithSkipAfter";
+                before_process: `queue: skipped if ${number} failed attempts`;
+            }>;
+            getSkipAfter(event: import("@ddd-ts/core").IEsEvent<string, any>): number;
+            context: {};
+            event: import("@ddd-ts/core").IEsEvent<string, any>;
+            handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+            locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+            process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+        };
+        superTraits: readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }];
+        symbol: symbol;
+    };
+    IsolateAfter: (ms: number) => {
+        factory: (base: import("@ddd-ts/traits").ApplyTraits<readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }]>) => abstract new (param: {}) => {
+            description: import("@ddd-ts/core/dist/projections/handlers/description").Description<{
+                name: "WithIsolateAfter";
+                before_process: `queue: isolates after ${number} failed attempts`;
+            }>;
+            getIsolateAfter(event: import("@ddd-ts/core").IEsEvent<string, any>): number;
+            context: {};
+            event: import("@ddd-ts/core").IEsEvent<string, any>;
+            handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+            locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+            process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+        };
+        superTraits: readonly [{
+            factory: (base: import("@ddd-ts/traits").AbstractConstructor<{}, {}>) => abstract new (props: {}) => {
+                description: {};
+                context: {};
+                event: import("@ddd-ts/core").IEsEvent<string, any>;
+                handle(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<void>;
+                locks(event: import("@ddd-ts/core").IEsEvent<string, any>): any;
+                process(events: import("@ddd-ts/core").IEsEvent<string, any>[], context: {}): Promise<import("@ddd-ts/core").EventId[]>;
+            };
+            superTraits: import("@ddd-ts/traits").Trait[];
+            symbol: symbol;
+        }];
+        symbol: symbol;
+    };
+};
+export declare const runtimeTrace: {
+    entries: Array<{
+        id: string;
+        phase: "start" | "finish";
+        t: number;
+    }>;
+    reset(): void;
+};
+type TraitCtor = any;
+type HandlerRecipe = {
+    chain: TraitCtor[];
+    lock: (e: any) => Lock;
+};
+export declare function cashflowDefaults(): {
+    override(overrides: Partial<Record<string, HandlerRecipe>>): {
+        overrides: Partial<Record<string, HandlerRecipe>>;
+    };
+    toHandlers(): any;
+};
+declare class CashflowDocStore extends FirestoreStore<Cashflow> {
+    constructor(db: Firestore, collName: string);
+    init(accountId: any, event?: {
+        id: {
+            serialize(): string;
+        };
+    }, context?: Partial<{
+        trx: FirestoreTransaction;
+    }>): Promise<void>;
+    increment(accountId: any, amount: number, event?: {
+        id: {
+            serialize(): string;
+        };
+    }, context?: Partial<{
+        trx: FirestoreTransaction;
+    }>): Promise<void>;
+    rename(accountId: any, newName: string, event?: {
+        id: {
+            serialize(): string;
+        };
+    }, context?: Partial<{
+        trx: FirestoreTransaction;
+    }>): Promise<void>;
+}
+declare const AccountStore_base: {
+    new (firestore: Firestore, serializer: import("@ddd-ts/core").ISerializer<any, {}> & import("@ddd-ts/core").ISerializer<import("@ddd-ts/core").IEsEvent<string, any>, {}>, eventBus?: import("@ddd-ts/core").IEventBus): {
+        loadFirst(event: import("@ddd-ts/core").IEsEvent<string, any> & import("@ddd-ts/core").INamed<string>): any;
+        getStreamId(id: any): import("@ddd-ts/core").StreamId;
+        readonly firestore: Firestore;
+        readonly serializer: import("@ddd-ts/core").ISerializer<import("@ddd-ts/core").IEsEvent<string, any>, {}>;
+        readonly snapshotter: import("../..").FirestoreSnapshotter<any>;
+        readonly eventBus?: import("@ddd-ts/core").IEventBus | undefined;
+        readonly streamStore: import("@ddd-ts/core").EventStreamStore<import("@ddd-ts/core").IEsEvent<string, any>>;
+        readonly transaction: import("@ddd-ts/core").TransactionPerformer;
+        loadFromSnapshot(snapshot: any): Promise<any>;
+        loadFromScratch(id: any): Promise<any>;
+        loadForce(id: any): Promise<any>;
+        load(id: any): Promise<any>;
+        saveAll(aggregates: any[], parentTrx?: import("@ddd-ts/core").Transaction, attempts?: number): Promise<void>;
+        save(aggregate: any, trx?: import("@ddd-ts/core").Transaction, attempts?: number): Promise<void>;
+    };
+};
+declare class AccountStore extends AccountStore_base {
+    constructor(firestore: Firestore);
+}
+declare class CashflowCaseProjection extends ESProjection<any, any> {
+    readonly trx: FirestoreTransactionPerformer;
+    readonly store: CashflowDocStore;
+    source: ProjectedStream;
+    constructor(trx: FirestoreTransactionPerformer, store: CashflowDocStore, recipes: {
+        Deposited: HandlerRecipe;
+        Withdrawn: HandlerRecipe;
+        AccountRenamed: HandlerRecipe;
+        AccountOpened: HandlerRecipe;
+    });
+    getSource(): ProjectedStream;
+    getCheckpointId(e: any): CheckpointId;
+    get testhandlers(): any;
+}
+export declare function caseFixture(caseName: string, opts?: {
+    handlers?: {
+        Deposited?: HandlerRecipe;
+        Withdrawn?: HandlerRecipe;
+        AccountRenamed?: HandlerRecipe;
+        AccountOpened?: HandlerRecipe;
+    };
+    projector?: {
+        unclaimOnFailure?: boolean;
+        retry?: {
+            attempts: number;
+            minDelay: number;
+            maxDelay: number;
+            backoff?: number;
+        };
+        enqueue?: {
+            batchSize: number;
+        };
+    };
+}): {
+    name: string;
+    describe: (fn: () => any) => void;
+    setup(): Promise<{
+        readonly db: fb.firestore.Firestore;
+        readonly accountStore: AccountStore;
+        readonly cashflowStore: CashflowDocStore;
+        readonly projection: CashflowCaseProjection;
+        readonly reader: FirestoreProjectedStreamReader<any>;
+        readonly queueStore: FirestoreQueueStore;
+        readonly projector: FirestoreProjector;
+        readonly trace: {
+            entries: Array<{
+                id: string;
+                phase: "start" | "finish";
+                t: number;
+            }>;
+            reset(): void;
+        };
+        readonly events: {
+            open: (name: string) => any;
+        };
+        readonly act: {
+            save: (account: any) => Promise<void>;
+            handle: (event: any) => Promise<void>;
+        };
+        readonly control: {
+            markFailing: (event: any) => any;
+            suspend: (event: any) => any;
+            wait: (ms: number) => Promise<unknown>;
+        };
+        readonly assert: {
+            cashflow: (id: any) => {
+                toHave(partial: any): Promise<void>;
+                toNotExist(): Promise<void>;
+            };
+            fetch(id: any): Promise<Cashflow | undefined>;
+        };
+    }>;
+};
+export {};
+//# sourceMappingURL=case-fixture.d.ts.map

package/dist/projection/testkit/case-fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"case-fixture.d.ts","sourceRoot":"","sources":["../../../src/projection/testkit/case-fixture.ts"],"names":[],"mappings":"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"}