@schemeless/event-store - npm Package Compare versions

Comparing version 2.2.2 to 2.2.3

dist/EventStore.types.d.ts

@@ -6,2 +6,3 @@ import type { Observable } from 'rxjs';
 import { makeReplay } from './makeReplay';
+import { makeSideEffectQueue } from './queue/makeSideEffectQueue';
 export interface EventOutput<Payload = any> {
@@ -14,2 +15,3 @@ state: SideEffectsState | EventOutputState | EventObserverState;
     mainQueue: ReturnType<typeof makeMainQueue>;
+    sideEffectQueue: ReturnType<typeof makeSideEffectQueue>;
     receive: ReturnType<typeof makeReceive>;
@@ -16,0 +18,0 @@ replay: ReturnType<typeof makeReplay>;

dist/index.d.ts

 export * from './EventStore.types';
 export * from './makeEventStore';
+export { sideEffectFinishedPromise } from './util/sideEffectFinishedPromise';

dist/index.js

@@ -13,3 +13,6 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sideEffectFinishedPromise = void 0;
 __exportStar(require("./EventStore.types"), exports);
 __exportStar(require("./makeEventStore"), exports);
+var sideEffectFinishedPromise_1 = require("./util/sideEffectFinishedPromise");
+Object.defineProperty(exports, "sideEffectFinishedPromise", { enumerable: true, get: function () { return sideEffectFinishedPromise_1.sideEffectFinishedPromise; } });

dist/makeEventStore.js

@@ -50,2 +50,3 @@ "use strict";
         mainQueue,
+        sideEffectQueue,
         receive: makeReceive_1.makeReceive(mainQueue, successEventObservers),
@@ -52,0 +53,0 @@ replay: makeReplay_1.makeReplay(eventFlows, successEventObservers, eventStoreRepo),

dist/makeEventStore.test.js

@@ -17,2 +17,3 @@ "use strict";
 const delay_ts_1 = require("delay.ts");
+const sideEffectFinishedPromise_1 = require("./util/sideEffectFinishedPromise");
 describe('make eventStore', () => {
@@ -25,4 +26,4 @@ beforeEach(() => jest.clearAllMocks());
                 key: 'eventStore1',
-                positiveNumber: 1
-            }
+                positiveNumber: 1,
+            },
         })).resolves.toHaveLength(1);
@@ -38,4 +39,4 @@ expect(mockStore_1.storeGet('eventStore1')).toBe(1);
                 key: 'eventStore2',
-                positiveNumber: -1
-            }
+                positiveNumber: -1,
+            },
         })).rejects.toThrowError(/Invalid positive number/);
@@ -50,4 +51,4 @@ expect(mockStore_1.storeGet('eventStore2')).toBeUndefined();
                 key: 'eventStore3',
-                positiveNumber: 4
-            }
+                positiveNumber: 4,
+            },
         });
@@ -64,4 +65,4 @@ yield expect(events).toHaveLength(7); // 1 NestedTwice, 2 NestedOnce, 4 Standard
                 key: 'eventStore4',
-                positiveNumber: 1
-            }
+                positiveNumber: 1,
+            },
         })).rejects.toThrowError(/Invalid positive number/);
@@ -71,2 +72,15 @@ expect(mockStore_1.storeGet('eventStore4')).toBe(0);
     }));
+    it('should have a sign to drain side effect queue', () => __awaiter(void 0, void 0, void 0, function* () {
+        const eventStore = yield testHelpers_1.getTestEventStore(mocks_1.testEventFlows, mocks_1.testObservers);
+        const p1 = mocks_1.NestedTwiceEvent.receive(eventStore)({
+            payload: {
+                key: 'eventStore5',
+                positiveNumber: 4,
+            },
+        });
+        yield delay_ts_1.default(10);
+        yield p1;
+        yield sideEffectFinishedPromise_1.sideEffectFinishedPromise(eventStore);
+        expect(mockStore_1.storeGet('eventStore5')).toBe(18);
+    }));
 });

dist/operators/applyRootEventAndCollectSucceed.d.ts

@@ -1,3 +0,3 @@
-import type { CreatedEvent, EventFlowMap } from '@schemeless/event-store-types';
+import type { EventFlowMap } from '@schemeless/event-store-types';
 import { ApplyQueue } from '../queue/RxQueue';
-export declare const applyRootEventAndCollectSucceed: (eventFlowMap: EventFlowMap, applyQueue: ApplyQueue) => import("rxjs").Observable<CreatedEvent<any, undefined>[]>;
+export declare const applyRootEventAndCollectSucceed: (eventFlowMap: EventFlowMap, applyQueue: ApplyQueue) => any;

dist/operators/cleanupAndCancelFailedEvent.d.ts

 import type { BaseEvent, EventFlowMap } from '@schemeless/event-store-types';
 import * as Queue from 'better-queue';
-export declare const cleanupAndCancelFailedEvent: (eventFlowMap: EventFlowMap, done: Queue.ProcessFunctionCb<any>, event: BaseEvent<any>) => import("rxjs").UnaryFunction<import("rxjs").Observable<unknown>, import("rxjs").Observable<any[]>>;
+export declare const cleanupAndCancelFailedEvent: (eventFlowMap: EventFlowMap, done: Queue.ProcessFunctionCb<any>, event: BaseEvent<any>) => any;

dist/operators/racedQueueFailedOrDrained.d.ts

@@ -1,4 +0,2 @@
-import type { EventTaskAndError } from '@schemeless/event-store-types';
 import { ApplyQueue } from '../queue/RxQueue';
-import { Observable } from 'rxjs';
-export declare const racedQueueFailedOrDrained: (applyQueue: ApplyQueue) => Observable<EventTaskAndError | null>;
+export declare const racedQueueFailedOrDrained: (applyQueue: ApplyQueue) => any;

dist/operators/racedQueueFailedOrDrained.js

@@ -7,3 +7,3 @@ "use strict";
 const isEventTaskError_1 = require("./isEventTaskError");
-const racedQueueFailedOrDrained = (applyQueue) => rxjs_1.race([applyQueue.drained$, applyQueue.taskFailed$.pipe(Rx.catchError((err) => rxjs_1.of(err)))]).pipe(Rx.map((_) => (isEventTaskError_1.isEventTaskError(_) ? _ : null)));
+const racedQueueFailedOrDrained = (applyQueue) => rxjs_1.race([applyQueue.drained$, applyQueue.taskFailed$.pipe(Rx.catchError((err) => rxjs_1.of(err)))]).pipe(Rx.map((_) => isEventTaskError_1.isEventTaskError(_) ? _ : null));
 exports.racedQueueFailedOrDrained = racedQueueFailedOrDrained;

dist/queue/makeApplyQueue.d.ts

@@ -13,26 +13,9 @@ /// <reference types="better-queue" />
     }, cb?: (err: any, result: CreatedEvent<any, undefined>) => void) => import("better-queue").Ticket;
-    process$: import("rxjs").Subject<{
-        task: {
-            causalEvent?: CreatedEvent<any>;
-            currentEvent: BaseEvent<any>;
-        };
-        done: import("better-queue").ProcessFunctionCb<CreatedEvent<any, undefined>>;
-    }>;
-    task$: import("rxjs").Observable<{
-        causalEvent?: CreatedEvent<any>;
-        currentEvent: BaseEvent<any>;
-    }>;
-    done$: import("rxjs").Observable<import("better-queue").ProcessFunctionCb<CreatedEvent<any, undefined>>>;
-    drained$: import("rxjs").Observable<[import("better-queue")<{
-        causalEvent?: CreatedEvent<any>;
-        currentEvent: BaseEvent<any>;
-    }, CreatedEvent<any, undefined>>]>;
-    empty$: import("rxjs").Observable<[import("better-queue")<{
-        causalEvent?: CreatedEvent<any>;
-        currentEvent: BaseEvent<any>;
-    }, CreatedEvent<any, undefined>>]>;
-    taskFailed$: import("rxjs").Observable<[import("better-queue")<{
-        causalEvent?: CreatedEvent<any>;
-        currentEvent: BaseEvent<any>;
-    }, CreatedEvent<any, undefined>>]>;
+    process$: any;
+    task$: any;
+    done$: any;
+    drained$: any;
+    empty$: any;
+    taskFailed$: any;
+    queueSize$: any;
 };

dist/queue/makeMainQueue.d.ts

 /// <reference types="better-queue" />
-import type { BaseEvent, CreatedEvent, EventFlow, EventTaskAndError } from '@schemeless/event-store-types';
-import { Observable } from 'rxjs';
+import type { BaseEvent, EventFlow } from '@schemeless/event-store-types';
 export declare const makeMainQueue: (eventFlows: EventFlow<any>[]) => {
-    processed$: Observable<[CreatedEvent<any, undefined>[], EventTaskAndError]>;
+    processed$: any;
     queueInstance: {
@@ -10,11 +9,9 @@ id: string;
         push: (task: BaseEvent<any, undefined>, cb?: (err: any, result: any) => void) => import("better-queue").Ticket;
-        process$: import("rxjs").Subject<{
-            task: BaseEvent<any, undefined>;
-            done: import("better-queue").ProcessFunctionCb<any>;
-        }>;
-        task$: Observable<BaseEvent<any, undefined>>;
-        done$: Observable<import("better-queue").ProcessFunctionCb<any>>;
-        drained$: Observable<[import("better-queue")<BaseEvent<any, undefined>, any>]>;
-        empty$: Observable<[import("better-queue")<BaseEvent<any, undefined>, any>]>;
-        taskFailed$: Observable<[import("better-queue")<BaseEvent<any, undefined>, any>]>;
+        process$: any;
+        task$: any;
+        done$: any;
+        drained$: any;
+        empty$: any;
+        taskFailed$: any;
+        queueSize$: any;
     };
@@ -21,0 +18,0 @@ push: (task: BaseEvent<any, undefined>, cb?: (err: any, result: any) => void) => import("better-queue").Ticket;

dist/queue/makeObserverQueue.d.ts

 /// <reference types="better-queue" />
 import { CreatedEvent, SuccessEventObserver } from '@schemeless/event-store-types';
-import { Observable } from 'rxjs';
-import { EventOutput } from '../EventStore.types';
 export declare const makeObserverQueue: (successEventObservers: SuccessEventObserver<any>[]) => {
-    processed$: Observable<EventOutput<any>>;
+    processed$: any;
     queueInstance: {
@@ -11,13 +9,11 @@ id: string;
         push: (task: CreatedEvent<any, undefined>, cb?: (err: any, result: any) => void) => import("better-queue").Ticket;
-        process$: import("rxjs").Subject<{
-            task: CreatedEvent<any, undefined>;
-            done: import("better-queue").ProcessFunctionCb<any>;
-        }>;
-        task$: Observable<CreatedEvent<any, undefined>>;
-        done$: Observable<import("better-queue").ProcessFunctionCb<any>>;
-        drained$: Observable<[import("better-queue")<CreatedEvent<any, undefined>, any>]>;
-        empty$: Observable<[import("better-queue")<CreatedEvent<any, undefined>, any>]>;
-        taskFailed$: Observable<[import("better-queue")<CreatedEvent<any, undefined>, any>]>;
+        process$: any;
+        task$: any;
+        done$: any;
+        drained$: any;
+        empty$: any;
+        taskFailed$: any;
+        queueSize$: any;
     };
     push: (task: CreatedEvent<any, undefined>, cb?: (err: any, result: any) => void) => import("better-queue").Ticket;
 };

dist/queue/makeObserverQueue.js

@@ -18,6 +18,3 @@ "use strict";
 const logEvent_1 = require("../util/logEvent");
-const makeObserverQueue = (successEventObservers) => {
-    const observerQueue = RxQueue_1.createRxQueue('applySuccessEventObservers', {
-        concurrent: 1,
-    });
+const makeObserverMap = (successEventObservers) => {
     const observerMap = successEventObservers.reduce((acc, observer) => {
@@ -31,2 +28,9 @@ observer.filters.forEach((filter) => {
     }, {});
+    return observerMap;
+};
+const makeObserverQueue = (successEventObservers) => {
+    const observerQueue = RxQueue_1.createRxQueue('applySuccessEventObservers', {
+        concurrent: 1,
+    });
+    const observerMap = makeObserverMap(successEventObservers);
     const processed$ = observerQueue.process$.pipe(Rx.mergeMap(({ done, task: createdEvent }) => __awaiter(void 0, void 0, void 0, function* () {
@@ -36,3 +40,3 @@ const thisDomainType = createdEvent.domain + '__' + createdEvent.type;
         if (!observersToApply || observersToApply.length === 0) {
-            logEvent_1.logEvent(createdEvent, '👀', 'OB:NA');
+            logEvent_1.logEvent(createdEvent, '👀', 'No observers to apply');
             done();
@@ -47,3 +51,3 @@ return null;
             }
-            logEvent_1.logEvent(createdEvent, '👀', 'OB:OK');
+            logEvent_1.logEvent(createdEvent, '👀', 'Applied observers');
             done();
@@ -50,0 +54,0 @@ return { state: event_store_types_1.EventObserverState.success, event: createdEvent };

dist/queue/makeSideEffectQueue.d.ts

 /// <reference types="better-queue" />
-import { CreatedEvent, EventFlow, SideEffectsState } from '@schemeless/event-store-types';
+import { CreatedEvent, EventFlow } from '@schemeless/event-store-types';
 import { mainQueueType } from './makeMainQueue';
 export declare const makeSideEffectQueue: (eventFlows: EventFlow[], mainQueue: mainQueueType) => {
-    processed$: import("rxjs").Observable<{
-        state: SideEffectsState;
-        event: CreatedEvent<any>;
-    }>;
+    processed$: any;
     queueInstance: {
@@ -19,26 +16,9 @@ id: string;
         }, cb?: (err: any, result: any) => void) => import("better-queue").Ticket;
-        process$: import("rxjs").Subject<{
-            task: {
-                retryCount: number;
-                event: CreatedEvent<any>;
-            };
-            done: import("better-queue").ProcessFunctionCb<any>;
-        }>;
-        task$: import("rxjs").Observable<{
-            retryCount: number;
-            event: CreatedEvent<any>;
-        }>;
-        done$: import("rxjs").Observable<import("better-queue").ProcessFunctionCb<any>>;
-        drained$: import("rxjs").Observable<[import("better-queue")<{
-            retryCount: number;
-            event: CreatedEvent<any>;
-        }, any>]>;
-        empty$: import("rxjs").Observable<[import("better-queue")<{
-            retryCount: number;
-            event: CreatedEvent<any>;
-        }, any>]>;
-        taskFailed$: import("rxjs").Observable<[import("better-queue")<{
-            retryCount: number;
-            event: CreatedEvent<any>;
-        }, any>]>;
+        process$: any;
+        task$: any;
+        done$: any;
+        drained$: any;
+        empty$: any;
+        taskFailed$: any;
+        queueSize$: any;
     };
@@ -45,0 +25,0 @@ push: (task: {

dist/queue/RxQueue.d.ts

 import * as Queue from 'better-queue';
-import { Observable, Subject } from 'rxjs';
 export declare type ApplyQueue = ReturnType<typeof createRxQueue>;
@@ -8,11 +7,9 @@ export declare const createRxQueue: <TASK = any, RESULT = TASK>(id: string, queueOptions?: Pick<Queue.QueueOptions<TASK, RESULT>, "filter" | "merge" | "priority" | "precondition" | "id" | "cancelIfRunning" | "autoResume" | "failTaskOnProcessException" | "filo" | "batchSize" | "batchDelay" | "batchDelayTimeout" | "concurrent" | "maxTimeout" | "afterProcessDelay" | "maxRetries" | "retryDelay" | "storeMaxRetries" | "storeRetryTimeout" | "preconditionRetryTimeout" | "store">) => {
     push: (task: TASK, cb?: (err: any, result: RESULT) => void) => Queue.Ticket;
-    process$: Subject<{
-        task: TASK;
-        done: Queue.ProcessFunctionCb<RESULT>;
-    }>;
-    task$: Observable<TASK>;
-    done$: Observable<Queue.ProcessFunctionCb<RESULT>>;
-    drained$: Observable<[Queue<TASK, RESULT>]>;
-    empty$: Observable<[Queue<TASK, RESULT>]>;
-    taskFailed$: Observable<[Queue<TASK, RESULT>]>;
+    process$: any;
+    task$: any;
+    done$: any;
+    drained$: any;
+    empty$: any;
+    taskFailed$: any;
+    queueSize$: any;
 };

dist/queue/RxQueue.js

@@ -10,3 +10,3 @@ "use strict";
 const makeEventQueueObservable = (queue, queueEventType, queueId = 'unnamed') => {
-    return new rxjs_1.Observable(observer => {
+    return new rxjs_1.Observable((observer) => {
         queue.on(queueEventType, (...args) => {
@@ -19,3 +19,3 @@ logger_1.logger.debug(`Queue Event: ${queueId} - ${queueEventType}`);
 const makeFailedEventQueueObservable = (queue) => {
-    return new rxjs_1.Observable(observer => {
+    return new rxjs_1.Observable((observer) => {
         queue.on('task_failed', (id, error) => {
@@ -34,2 +34,16 @@ logger_1.logger.warn('EventQueueObservable error');
     };
+    const queueSizeInput$ = new rxjs_1.Subject();
+    const queueSizeOutput$ = new rxjs_1.BehaviorSubject(null);
+    queueSizeInput$.pipe(Rx.scan((acc, curr) => (acc || 0) + curr, null)).subscribe(queueSizeOutput$);
+    const customPush = (task, cb) => {
+        queueSizeInput$.next(+1);
+        queue
+            .push(task, cb)
+            .on('finish', () => {
+            queueSizeInput$.next(-1);
+        })
+            .on('failed', () => {
+            queueSizeInput$.next(-1);
+        });
+    };
     const queue = makeQueue(callback, Object.assign(queueOptions || {}, { id: id }));
@@ -39,3 +53,3 @@ return {
         queueInstance: queue,
-        push: queue.push.bind(queue),
+        push: customPush,
         process$,
@@ -46,5 +60,6 @@ task$: process$.pipe(Rx.map(R.prop('task'))),
         empty$: makeEventQueueObservable(queue, 'empty', id),
-        taskFailed$: makeFailedEventQueueObservable(queue)
+        taskFailed$: makeFailedEventQueueObservable(queue),
+        queueSize$: queueSizeOutput$,
     };
 };
 exports.createRxQueue = createRxQueue;

dist/queue/RxQueue.test.js

 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -7,3 +16,3 @@ const RxQueue_1 = require("./RxQueue");
 describe('Rx Queue', () => {
-    it('should run work on done and task', cb => {
+    it('should run work on done and task', (cb) => {
         const rxQueue = RxQueue_1.createRxQueue('test');
@@ -17,3 +26,3 @@ rxjs_1.zip(rxQueue.task$, rxQueue.done$).subscribe(([task, done]) => {
     });
-    it('should allow push and down', cb => {
+    it('should allow push and down', (cb) => {
         const rxQueue = RxQueue_1.createRxQueue('pushTest');
@@ -32,3 +41,3 @@ const taskVal = 'taskVal';
     });
-    it('should receive drain ', cb => {
+    it('should receive drain ', (cb) => {
         const rxQueue = RxQueue_1.createRxQueue('drainTest');
@@ -46,3 +55,3 @@ rxQueue.process$.subscribe(({ task, done }) => {
     });
-    it('should receive empty ', cb => {
+    it('should receive empty ', (cb) => {
         const rxQueue = RxQueue_1.createRxQueue('emptyTest');
@@ -60,3 +69,3 @@ rxQueue.process$.subscribe(({ task, done }) => {
     });
-    it('should receive failed ', cb => {
+    it('should receive failed ', (cb) => {
         const rxQueue = RxQueue_1.createRxQueue('failedTest');
@@ -74,3 +83,3 @@ rxQueue.process$.subscribe(({ task, done }) => {
         }))
-            .subscribe(end => {
+            .subscribe((end) => {
             expect(end).toBe('done');
@@ -80,2 +89,18 @@ cb();
     });
+    it('should be able to get queue size', () => __awaiter(void 0, void 0, void 0, function* () {
+        const rxQueue = RxQueue_1.createRxQueue('basicTest');
+        rxQueue.process$.subscribe(({ task, done }) => {
+            done();
+        });
+        let arr = [];
+        rxQueue.queueSize$.subscribe((size) => {
+            arr.push(size);
+        });
+        rxQueue.push('1');
+        rxQueue.push('2');
+        rxQueue.push('3');
+        const delay = (ms) => new Promise((res) => setTimeout(res, ms));
+        yield delay(10);
+        expect(arr).toEqual([null, 1, 2, 3, 2, 1, 0]);
+    }));
 });

package.json

 {
   "name": "@schemeless/event-store",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "typescript:main": "src/index.ts",
@@ -28,3 +28,3 @@ "main": "dist/index.js",
     "ramda": "^0.27.1",
-    "rxjs": "^6.6.3",
+    "rxjs": "^7.5.5",
     "ulid": "^2.3.0",
@@ -53,3 +53,3 @@ "uuid": "^8.3.1"
   },
-  "gitHead": "d0b7b8a47d383a64ee7184dca4f4c51bae4c87f1"
+  "gitHead": "ee437cc25c7c2e778827c44a67cc0e2cf429f891"
 }

No alert changes

Improved metrics

Total package byte prevSize

76675

increased by2.17%

Number of package files

83

increased by5.06%

Lines of code

1567

increased by3.91%

Dependency changes

• + Addedrxjs@7.8.1(transitive)

• + Addedtslib@2.8.1(transitive)

• - Removedrxjs@6.6.7(transitive)

• - Removedtslib@1.14.1(transitive)

• Updatedrxjs@^7.5.5