@fraym/streams 0.6.0 → 0.7.0

package/dist/client/allEvents.d.ts

@@ -1,3 +1,4 @@
 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>;

package/dist/client/allEvents.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllEvents = void 0;
+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) => {
@@ -37,3 +37,38 @@ const getEventPage = async (tenantId, topic, types, perPage, page, serviceClient
         });
     }));
 };
+const getAllEventsAfterEvent = async (tenantId, topic, types, eventId, perPage, handler, serviceClient) => {
+    let page = 0;
+    while (true) {
+        const events = await getEventPageAfterEvent(tenantId, topic, types, eventId, perPage, page, serviceClient);
+        if (events.length === 0) {
+            return;
+        }
+        for (const eventData of events) {
+            const event = (0, event_1.getSubscriptionEvent)(eventData);
+            if (event) {
+                await handler(event);
+            }
+        }
+        page++;
+    }
+};
+exports.getAllEventsAfterEvent = getAllEventsAfterEvent;
+const getEventPageAfterEvent = async (tenantId, topic, types, eventId, perPage, page, serviceClient) => {
+    return (0, util_1.retry)(() => new Promise((resolve, reject) => {
+        serviceClient.paginateEventsAfterEventId({
+            tenantId,
+            topic,
+            types,
+            eventId,
+            page: page.toString(),
+            perPage: perPage.toString(),
+        }, async (error, data) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(data.events);
+        });
+    }));
+};

package/dist/client/client.d.ts

@@ -4,11 +4,13 @@ import { HandlerFunc, PublishEvent, SubscriptionEvent } from "./event";
 import { Subscription } from "./subscribe";
 export interface StreamIterator {
     forEach: (callback: (event: SubscriptionEvent) => void) => Promise<void>;
+    forEachAfterEvent: (eventId: string, callback: (event: SubscriptionEvent) => void) => Promise<void>;
     isEmpty: () => Promise<boolean>;
 }
 export interface Client {
     getEvent: (tenantId: string, topic: string, eventId: string) => Promise<SubscriptionEvent>;
     iterateAllEvents: (tenantId: string, topic: string, includedEventTypes: string[], perPage: number, handler: HandlerFunc) => Promise<void>;
+    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>;
     subscribe: (topics?: string[], ignoreUnhandledEvents?: boolean) => Subscription;

package/dist/client/client.js

@@ -26,6 +26,9 @@ const newClient = async (config) => {
         iterateAllEvents: async (tenantId, topic, includedEventTypes, perPage, handler) => {
             await (0, allEvents_1.getAllEvents)(tenantId, topic, includedEventTypes, perPage, handler, serviceClient);
         },
+        iterateAllEventsAfterEvent: async (tenantId, topic, includedEventTypes, eventId, perPage, handler) => {
+            await (0, allEvents_1.getAllEventsAfterEvent)(tenantId, topic, includedEventTypes, eventId, perPage, handler, serviceClient);
+        },
         publish: async (topic, events) => {
             return (0, publish_1.sendPublish)(topic, events, serviceClient);
         },
@@ -36,6 +39,11 @@ const newClient = async (config) => {
                         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);
                 },

package/dist/client/stream.d.ts

@@ -1,4 +1,5 @@
 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>;
 export declare const isStreamEmpty: (topic: string, tenantId: string, stream: string, serviceClient: ServiceClient) => Promise<boolean>;

package/dist/client/stream.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStreamEmpty = exports.getStream = void 0;
+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) => {
@@ -37,6 +37,41 @@ const getStreamPage = async (topic, tenantId, stream, perPage, page, serviceClie
         });
     }));
 };
+const getStreamAfterEvent = async (topic, tenantId, stream, eventId, perPage, handler, serviceClient) => {
+    let page = 0;
+    while (true) {
+        const events = await getStreamPageAfterEvent(topic, tenantId, stream, eventId, perPage, page, serviceClient);
+        if (events.length === 0) {
+            return;
+        }
+        for (const eventData of events) {
+            const event = (0, event_1.getSubscriptionEvent)(eventData);
+            if (event) {
+                await handler(event);
+            }
+        }
+        page++;
+    }
+};
+exports.getStreamAfterEvent = getStreamAfterEvent;
+const getStreamPageAfterEvent = async (topic, tenantId, stream, eventId, perPage, page, serviceClient) => {
+    return (0, util_1.retry)(() => new Promise((resolve, reject) => {
+        serviceClient.paginateStreamAfterEventId({
+            stream,
+            tenantId,
+            topic,
+            eventId,
+            page: page.toString(),
+            perPage: perPage.toString(),
+        }, async (error, data) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(data.events);
+        });
+    }));
+};
 const isStreamEmpty = async (topic, tenantId, stream, serviceClient) => {
     return new Promise((resolve, reject) => {
         serviceClient.isStreamEmpty({

package/dist/client/subscribe.js

@@ -9,14 +9,22 @@ const newSubscription = (topics, ignoreUnhandledEvents, config, serviceClient) =
     let closed = false;
     const typeHandlerMap = {};
     const globalHandlers = [];
+    const rebuildConnection = (currentStream, retries) => {
+        currentStream.cancel();
+        currentStream.removeAllListeners();
+        setTimeout(() => {
+            stream = null;
+            reconnect(retries);
+        }, 100);
+    };
     const reconnect = async (retries) => {
         const newStream = serviceClient.subscribe();
         newStream.on("end", () => {
             if (closed) {
-                newStream.end();
+                newStream.cancel();
                 return;
             }
-            reconnect(50);
+            rebuildConnection(newStream, retries - 1);
         });
         newStream.on("error", (err) => {
             if (closed) {
@@ -26,25 +34,20 @@ const newSubscription = (topics, ignoreUnhandledEvents, config, serviceClient) =
                 closed = true;
                 throw err;
             }
-            newStream.end();
-            setTimeout(() => {
-                stream = null;
-                reconnect(retries - 1);
-            }, 100);
+            rebuildConnection(newStream, retries - 1);
         });
         const dataFn = async (data) => {
             var _a, _b, _c, _d;
             if (!data.payload ||
                 ((_a = data.payload) === null || _a === void 0 ? void 0 : _a.$case) === "panic" ||
                 ((_b = data.payload) === null || _b === void 0 ? void 0 : _b.$case) === "subscribed") {
-                newStream.end();
+                newStream.cancel();
                 return;
             }
             const event = (0, event_1.getSubscriptionEvent)(data.payload.event);
             if (!event) {
                 return;
             }
-            console.log("event", event.id);
             const currentHandlers = (_d = typeHandlerMap[(_c = event.type) !== null && _c !== void 0 ? _c : ""]) !== null && _d !== void 0 ? _d : [];
             currentHandlers.push(...globalHandlers);
             if (currentHandlers.length === 0) {
@@ -68,6 +71,7 @@ const newSubscription = (topics, ignoreUnhandledEvents, config, serviceClient) =
         };
         stream = newStream;
         await (0, exports.initStream)(topics, config, newStream);
+        retries = 50;
         newStream.on("data", dataFn);
     };
     return {
@@ -87,7 +91,7 @@ const newSubscription = (topics, ignoreUnhandledEvents, config, serviceClient) =
         },
         stop: () => {
             if (stream) {
-                stream.end();
+                stream.cancel();
                 stream = null;
             }
             closed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraym/streams",
-    "version": "0.6.0",
+    "version": "0.7.0",
     "license": "MIT",
     "homepage": "https://github.com/fraym/streams-nodejs",
     "repository": {
@@ -26,7 +26,7 @@
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "dependencies": {
-        "@fraym/proto": "^0.11.4",
+        "@fraym/proto": "^0.14.0",
         "@grpc/grpc-js": "^1.10.0",
         "uuid": "^9.0.1"
     },