@fraym/streams 0.7.0 → 0.7.2

package/README.md

@@ -121,7 +121,7 @@ A snapshot moves events from the "fast access" database to a "long time storage"
 The long time storage will have slower access time.
 Use this if you have topics that have a lot of old events which are not queried regularly.
 
-Creating a snapshot will only affect performance. You will not l lose any of your events.
+Creating a snapshot will only affect performance. You will not lose any of your events.
 
 Snapshots can be used to clean up your "fast access" event database and therefore increase performance on new events.
 

package/dist/client/allEvents.d.ts

@@ -1,4 +1,5 @@
 import { ServiceClient } from "@fraym/proto/freym/streams/management";
 import { HandlerFunc } from "./event";
-export declare const getAllEvents: (tenantId: string, topic: string, types: string[], perPage: number, handler: HandlerFunc, serviceClient: ServiceClient) => Promise<void>;
-export declare const getAllEventsAfterEvent: (tenantId: string, topic: string, types: string[], eventId: string, perPage: number, handler: HandlerFunc, serviceClient: ServiceClient) => Promise<void>;
+import { StopLoadingMoreFunc } from "./util";
+export declare const getAllEvents: (tenantId: string, topic: string, types: string[], perPage: number, handler: HandlerFunc, stopLoadingMore: StopLoadingMoreFunc, serviceClient: ServiceClient) => Promise<void>;
+export declare const getAllEventsAfterEvent: (tenantId: string, topic: string, types: string[], eventId: string, perPage: number, handler: HandlerFunc, stopLoadingMore: StopLoadingMoreFunc, serviceClient: ServiceClient) => Promise<void>;

package/dist/client/allEvents.js

@@ -3,20 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAllEventsAfterEvent = exports.getAllEvents = void 0;
 const event_1 = require("./event");
 const util_1 = require("./util");
-const getAllEvents = async (tenantId, topic, types, perPage, handler, serviceClient) => {
+const getAllEvents = async (tenantId, topic, types, perPage, handler, stopLoadingMore, serviceClient) => {
     let page = 0;
     while (true) {
         const events = await getEventPage(tenantId, topic, types, perPage, page, serviceClient);
-        if (events.length === 0) {
-            return;
-        }
+        page++;
+        let lastEvent = null;
         for (const eventData of events) {
             const event = (0, event_1.getSubscriptionEvent)(eventData);
             if (event) {
                 await handler(event);
+                lastEvent = event;
             }
         }
-        page++;
+        if (stopLoadingMore(lastEvent)) {
+            return;
+        }
     }
 };
 exports.getAllEvents = getAllEvents;
@@ -37,20 +39,22 @@ const getEventPage = async (tenantId, topic, types, perPage, page, serviceClient
         });
     }));
 };
-const getAllEventsAfterEvent = async (tenantId, topic, types, eventId, perPage, handler, serviceClient) => {
+const getAllEventsAfterEvent = async (tenantId, topic, types, eventId, perPage, handler, stopLoadingMore, serviceClient) => {
     let page = 0;
     while (true) {
         const events = await getEventPageAfterEvent(tenantId, topic, types, eventId, perPage, page, serviceClient);
-        if (events.length === 0) {
-            return;
-        }
+        page++;
+        let lastEvent = null;
         for (const eventData of events) {
             const event = (0, event_1.getSubscriptionEvent)(eventData);
             if (event) {
                 await handler(event);
+                lastEvent = event;
             }
         }
-        page++;
+        if (stopLoadingMore(lastEvent)) {
+            return;
+        }
     }
 };
 exports.getAllEventsAfterEvent = getAllEventsAfterEvent;

package/dist/client/client.d.ts

@@ -1,4 +1,3 @@
-import { ServiceClient } from "@fraym/proto/freym/streams/management";
 import { ClientConfig } from "./config";
 import { HandlerFunc, PublishEvent, SubscriptionEvent } from "./event";
 import { Subscription } from "./subscribe";
@@ -13,9 +12,10 @@ export interface Client {
     iterateAllEventsAfterEvent: (tenantId: string, topic: string, includedEventTypes: string[], eventId: string, perPage: number, handler: HandlerFunc) => Promise<void>;
     publish: (topic: string, events: PublishEvent[]) => Promise<void>;
     getStreamItarator: (topic: string, tenantId: string, stream: string, perPage: number) => Promise<StreamIterator>;
+    getStreamIterator: (topic: string, tenantId: string, stream: string, perPage: number) => Promise<StreamIterator>;
     subscribe: (topics?: string[], ignoreUnhandledEvents?: boolean) => Subscription;
     invalidateGdprData: (tenantId: string, topic: string, gdprId: string) => Promise<void>;
-    introduceGdprOnEventField: (tenantId: string, defaultValue: string, topic: string, eventId: string, fieldName: string, serviceClient: ServiceClient) => Promise<void>;
+    introduceGdprOnEventField: (tenantId: string, defaultValue: string, topic: string, eventId: string, fieldName: string) => Promise<void>;
     close: () => void;
 }
 export declare const newClient: (config: ClientConfig) => Promise<Client>;

package/dist/client/client.js

@@ -19,35 +19,53 @@ const newClient = async (config) => {
         "grpc.keepalive_permit_without_calls": 1,
     });
     const closeFunctions = [];
+    const getStreamIterator = async (topic, tenantId, stream, perPage) => {
+        return {
+            forEach: async (callback) => {
+                const now = new Date(new Date().getTime() + 3000);
+                return await (0, stream_1.getStream)(topic, tenantId, stream, perPage, async (event) => {
+                    callback(event);
+                }, (lastEvent) => {
+                    return !lastEvent || lastEvent.raisedAt > now;
+                }, serviceClient);
+            },
+            forEachAfterEvent: async (eventId, callback) => {
+                const now = new Date(new Date().getTime() + 3000);
+                return await (0, stream_1.getStreamAfterEvent)(topic, tenantId, stream, eventId, perPage, async (event) => {
+                    callback(event);
+                }, (lastEvent) => {
+                    return !lastEvent || lastEvent.raisedAt > now;
+                }, serviceClient);
+            },
+            isEmpty: async () => {
+                return (0, stream_1.isStreamEmpty)(topic, tenantId, stream, serviceClient);
+            },
+        };
+    };
     return {
         getEvent: async (tenantId, topic, eventId) => {
             return await (0, getEvent_1.getEvent)(tenantId, topic, eventId, serviceClient);
         },
         iterateAllEvents: async (tenantId, topic, includedEventTypes, perPage, handler) => {
-            await (0, allEvents_1.getAllEvents)(tenantId, topic, includedEventTypes, perPage, handler, serviceClient);
+            const now = new Date(new Date().getTime() + 3000);
+            await (0, allEvents_1.getAllEvents)(tenantId, topic, includedEventTypes, perPage, handler, (lastEvent) => {
+                return !lastEvent || lastEvent.raisedAt > now;
+            }, serviceClient);
         },
         iterateAllEventsAfterEvent: async (tenantId, topic, includedEventTypes, eventId, perPage, handler) => {
-            await (0, allEvents_1.getAllEventsAfterEvent)(tenantId, topic, includedEventTypes, eventId, perPage, handler, serviceClient);
+            const now = new Date(new Date().getTime() + 3000);
+            await (0, allEvents_1.getAllEventsAfterEvent)(tenantId, topic, includedEventTypes, eventId, perPage, handler, (lastEvent) => {
+                return !lastEvent || lastEvent.raisedAt > now;
+            }, serviceClient);
         },
         publish: async (topic, events) => {
-            return (0, publish_1.sendPublish)(topic, events, serviceClient);
+            return await (0, publish_1.sendPublish)(topic, events, serviceClient);
         },
         getStreamItarator: async (topic, tenantId, stream, perPage) => {
-            return {
-                forEach: async (callback) => {
-                    return await (0, stream_1.getStream)(topic, tenantId, stream, perPage, async (event) => {
-                        callback(event);
-                    }, serviceClient);
-                },
-                forEachAfterEvent: async (eventId, callback) => {
-                    return await (0, stream_1.getStreamAfterEvent)(topic, tenantId, stream, eventId, perPage, async (event) => {
-                        callback(event);
-                    }, serviceClient);
-                },
-                isEmpty: async () => {
-                    return (0, stream_1.isStreamEmpty)(topic, tenantId, stream, serviceClient);
-                },
-            };
+            return await getStreamIterator(topic, tenantId, stream, perPage);
+        },
+        getStreamIterator: async (topic, tenantId, stream, perPage) => {
+            return await getStreamIterator(topic, tenantId, stream, perPage);
         },
         subscribe: (topics = [], ignoreUnhandledEvents = false) => {
             const subscription = (0, subscribe_1.newSubscription)(topics, ignoreUnhandledEvents, config, serviceClient);
@@ -55,7 +73,7 @@ const newClient = async (config) => {
             return subscription;
         },
         introduceGdprOnEventField: async (tenantId, defaultValue, topic, eventId, fieldName) => {
-            return (0, introduceGdpr_1.introduceGdprOnEventField)(tenantId, defaultValue, topic, eventId, fieldName, serviceClient);
+            return await (0, introduceGdpr_1.introduceGdprOnEventField)(tenantId, defaultValue, topic, eventId, fieldName, serviceClient);
         },
         invalidateGdprData: async (tenantId, topic, gdprId) => {
             return await (0, invalidateGdpr_1.sendInvalidateGdpr)(tenantId, topic, gdprId, serviceClient);

package/dist/client/event.js

@@ -16,6 +16,7 @@ const getSubscriptionEvent = (event) => {
             const data = event.payload[key];
             if (data.gdpr) {
                 payload[key] = {
+                    id: data.gdpr.id,
                     value: JSON.parse(data.value),
                     gdprDefault: data.gdpr.default ? JSON.parse(data.gdpr.default) : "",
                     isInvalidated: data.gdpr.isInvalidated,

package/dist/client/stream.d.ts

@@ -1,5 +1,6 @@
 import { HandlerFunc } from "./event";
 import { ServiceClient } from "@fraym/proto/freym/streams/management";
-export declare const getStream: (topic: string, tenantId: string, stream: string, perPage: number, handler: HandlerFunc, serviceClient: ServiceClient) => Promise<void>;
-export declare const getStreamAfterEvent: (topic: string, tenantId: string, stream: string, eventId: string, perPage: number, handler: HandlerFunc, serviceClient: ServiceClient) => Promise<void>;
+import { StopLoadingMoreFunc } from "./util";
+export declare const getStream: (topic: string, tenantId: string, stream: string, perPage: number, handler: HandlerFunc, stopLoadingMore: StopLoadingMoreFunc, serviceClient: ServiceClient) => Promise<void>;
+export declare const getStreamAfterEvent: (topic: string, tenantId: string, stream: string, eventId: string, perPage: number, handler: HandlerFunc, stopLoadingMore: StopLoadingMoreFunc, serviceClient: ServiceClient) => Promise<void>;
 export declare const isStreamEmpty: (topic: string, tenantId: string, stream: string, serviceClient: ServiceClient) => Promise<boolean>;

package/dist/client/stream.js

@@ -3,20 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isStreamEmpty = exports.getStreamAfterEvent = exports.getStream = void 0;
 const event_1 = require("./event");
 const util_1 = require("./util");
-const getStream = async (topic, tenantId, stream, perPage, handler, serviceClient) => {
+const getStream = async (topic, tenantId, stream, perPage, handler, stopLoadingMore, serviceClient) => {
     let page = 0;
     while (true) {
         const events = await getStreamPage(topic, tenantId, stream, perPage, page, serviceClient);
-        if (events.length === 0) {
-            return;
-        }
+        page++;
+        let lastEvent = null;
         for (const eventData of events) {
             const event = (0, event_1.getSubscriptionEvent)(eventData);
             if (event) {
                 await handler(event);
+                lastEvent = event;
             }
         }
-        page++;
+        if (stopLoadingMore(lastEvent)) {
+            return;
+        }
     }
 };
 exports.getStream = getStream;
@@ -37,20 +39,22 @@ const getStreamPage = async (topic, tenantId, stream, perPage, page, serviceClie
         });
     }));
 };
-const getStreamAfterEvent = async (topic, tenantId, stream, eventId, perPage, handler, serviceClient) => {
+const getStreamAfterEvent = async (topic, tenantId, stream, eventId, perPage, handler, stopLoadingMore, serviceClient) => {
     let page = 0;
     while (true) {
         const events = await getStreamPageAfterEvent(topic, tenantId, stream, eventId, perPage, page, serviceClient);
-        if (events.length === 0) {
-            return;
-        }
+        page++;
+        let lastEvent = null;
         for (const eventData of events) {
             const event = (0, event_1.getSubscriptionEvent)(eventData);
             if (event) {
                 await handler(event);
+                lastEvent = event;
             }
         }
-        page++;
+        if (stopLoadingMore(lastEvent)) {
+            return;
+        }
     }
 };
 exports.getStreamAfterEvent = getStreamAfterEvent;

package/dist/client/util.d.ts

@@ -1,2 +1,4 @@
+import { SubscriptionEvent } from "client/event";
 export declare const sleep: (delay: number) => Promise<void>;
 export declare const retry: <T extends unknown>(fn: () => Promise<T>, pause?: number, retries?: number) => Promise<T>;
+export type StopLoadingMoreFunc = (lastEvent: SubscriptionEvent | null) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraym/streams",
-    "version": "0.7.0",
+    "version": "0.7.2",
     "license": "MIT",
     "homepage": "https://github.com/fraym/streams-nodejs",
     "repository": {