@fraym/streams 0.5.2 → 0.7.0

package/dist/client/allEvents.d.ts

@@ -1,3 +1,4 @@
-import { ServiceClient } from "@fraym/proto/freym/streams/clientchannel";
+import { ServiceClient } from "@fraym/proto/freym/streams/management";
 import { HandlerFunc } from "./event";
-export declare const getAllEvents: (tenantId: string, topic: string, includedEventTypes: string[], perPage: number, handler: HandlerFunc, serviceClient: ServiceClient) => Promise<void>;
+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,33 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllEvents = void 0;
+exports.getAllEventsAfterEvent = exports.getAllEvents = void 0;
 const event_1 = require("./event");
-const getAllEvents = async (tenantId, topic, includedEventTypes, perPage, handler, serviceClient) => {
+const util_1 = require("./util");
+const getAllEvents = async (tenantId, topic, types, perPage, handler, serviceClient) => {
     let page = 0;
-    let finished = false;
-    while (!finished) {
-        await serviceClient.paginateEvents({
+    while (true) {
+        const events = await getEventPage(tenantId, topic, types, 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.getAllEvents = getAllEvents;
+const getEventPage = async (tenantId, topic, types, perPage, page, serviceClient) => {
+    return (0, util_1.retry)(() => new Promise((resolve, reject) => {
+        serviceClient.paginateEvents({
             tenantId,
             topic,
-            includedEventTypes,
+            types,
             page: page.toString(),
             perPage: perPage.toString(),
         }, async (error, data) => {
             if (error) {
-                throw error;
-            }
-            if (data.events.length === 0) {
-                finished = true;
+                reject(error);
                 return;
             }
-            for (const eventData of data.events) {
-                const event = (0, event_1.getSubscriptionEvent)(eventData);
-                if (event) {
-                    await handler(event);
-                }
-            }
+            resolve(data.events);
         });
+    }));
+};
+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.getAllEvents = getAllEvents;
+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

@@ -1,22 +1,21 @@
-import { ServiceClient } from "@fraym/proto/freym/streams/clientchannel";
+import { ServiceClient } from "@fraym/proto/freym/streams/management";
 import { ClientConfig } from "./config";
 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 {
-    getAllEvents: (tenantId: string, topic: string, includedEventTypes: string[], perPage: number, handler: HandlerFunc) => Promise<void>;
     getEvent: (tenantId: string, topic: string, eventId: string) => Promise<SubscriptionEvent>;
-    getStreamItarator: (tenantId: string, stream: string, perPage: number) => Promise<StreamIterator>;
-    useEventHandler: (type: string, handler: HandlerFunc) => void;
-    useEventHandlerForAllEventTypes: (handler: HandlerFunc) => void;
-    subscribe: (includedTopics?: string[], excludedTopics?: string[]) => Promise<void>;
+    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;
     invalidateGdprData: (tenantId: string, topic: string, gdprId: string) => Promise<void>;
-    introduceGdprOnField: (defaultValue: string, topic: string, eventType: string, fieldName: string, serviceClient: ServiceClient) => Promise<void>;
     introduceGdprOnEventField: (tenantId: string, defaultValue: string, topic: string, eventId: string, fieldName: string, serviceClient: ServiceClient) => Promise<void>;
-    createSnapshot: (topic: string, toTime: Date) => Promise<void>;
     close: () => void;
 }
 export declare const newClient: (config: ClientConfig) => Promise<Client>;

package/dist/client/client.js

@@ -1,66 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.newClient = void 0;
-const clientchannel_1 = require("@fraym/proto/freym/streams/clientchannel");
+const management_1 = require("@fraym/proto/freym/streams/management");
 const grpc_js_1 = require("@grpc/grpc-js");
-const allEvents_1 = require("./allEvents");
 const config_1 = require("./config");
-const alreadySubscribed_1 = require("./errors/alreadySubscribed");
-const handler_1 = require("./handler");
-const init_1 = require("./init");
-const invalidateGdpr_1 = require("./invalidateGdpr");
+const getEvent_1 = require("./getEvent");
+const allEvents_1 = require("./allEvents");
 const publish_1 = require("./publish");
-const snapshot_1 = require("./snapshot");
+const introduceGdpr_1 = require("./introduceGdpr");
+const invalidateGdpr_1 = require("./invalidateGdpr");
 const stream_1 = require("./stream");
 const subscribe_1 = require("./subscribe");
-const getEvent_1 = require("./getEvent");
-const introduceGdpr_1 = require("./introduceGdpr");
 const newClient = async (config) => {
     config = (0, config_1.useConfigDefaults)(config);
-    const serviceClient = new clientchannel_1.ServiceClient(config.serverAddress, grpc_js_1.credentials.createInsecure(), {
+    const serviceClient = new management_1.ServiceClient(config.serverAddress, grpc_js_1.credentials.createInsecure(), {
         "grpc.keepalive_time_ms": config.keepaliveInterval,
         "grpc.keepalive_timeout_ms": config.keepaliveTimeout,
         "grpc.keepalive_permit_without_calls": 1,
     });
-    const stream = await (0, init_1.initStream)(config, serviceClient);
-    const eventHandler = (0, handler_1.initEventHandler)(stream);
-    let hasSubscribed = false;
+    const closeFunctions = [];
     return {
-        getAllEvents: async (tenantId, topic, includedEventTypes, perPage, handler) => {
-            await (0, allEvents_1.getAllEvents)(tenantId, topic, includedEventTypes, perPage, handler, serviceClient);
-        },
         getEvent: async (tenantId, topic, eventId) => {
             return await (0, getEvent_1.getEvent)(tenantId, topic, eventId, serviceClient);
         },
-        getStreamItarator: async (tenantId, stream, perPage) => {
+        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);
+        },
+        getStreamItarator: async (topic, tenantId, stream, perPage) => {
             return {
                 forEach: async (callback) => {
-                    return await (0, stream_1.getStream)(tenantId, stream, perPage, async (event) => {
+                    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)(tenantId, stream, serviceClient);
+                    return (0, stream_1.isStreamEmpty)(topic, tenantId, stream, serviceClient);
                 },
             };
         },
-        useEventHandler: (type, handler) => {
-            eventHandler.addHandler(type, handler);
-        },
-        useEventHandlerForAllEventTypes: handler => {
-            eventHandler.addHandlerForAllTypes(handler);
-        },
-        subscribe: async (includedTopics = [], excludedTopics = []) => {
-            if (hasSubscribed) {
-                throw new alreadySubscribed_1.AlreadySubscribedError();
-            }
-            return await (0, subscribe_1.sendSubscribe)(includedTopics, excludedTopics, config, stream);
-        },
-        publish: async (topic, events) => {
-            return (0, publish_1.sendPublish)(topic, events, serviceClient);
-        },
-        introduceGdprOnField: async (defaultValue, topic, eventType, fieldName) => {
-            return await (0, introduceGdpr_1.introduceGdprOnField)(defaultValue, topic, eventType, fieldName, serviceClient);
+        subscribe: (topics = [], ignoreUnhandledEvents = false) => {
+            const subscription = (0, subscribe_1.newSubscription)(topics, ignoreUnhandledEvents, config, serviceClient);
+            closeFunctions.push(subscription.stop);
+            return subscription;
         },
         introduceGdprOnEventField: async (tenantId, defaultValue, topic, eventId, fieldName) => {
             return (0, introduceGdpr_1.introduceGdprOnEventField)(tenantId, defaultValue, topic, eventId, fieldName, serviceClient);
@@ -68,11 +60,8 @@ const newClient = async (config) => {
         invalidateGdprData: async (tenantId, topic, gdprId) => {
             return await (0, invalidateGdpr_1.sendInvalidateGdpr)(tenantId, topic, gdprId, serviceClient);
         },
-        createSnapshot: async (topic, toTime) => {
-            return await (0, snapshot_1.sendSnapshot)(topic, toTime, serviceClient);
-        },
         close: () => {
-            stream.end();
+            closeFunctions.forEach(close => close());
         },
     };
 };

package/dist/client/event.d.ts

@@ -1,4 +1,4 @@
-import { PublishEventEnvelope } from "@fraym/proto/freym/streams/clientchannel";
+import { Event } from "@fraym/proto/freym/streams/management";
 export interface SubscriptionEvent extends BaseEvent {
     topic: string;
     raisedAt: Date;
@@ -25,4 +25,4 @@ export interface GdprEventData {
 }
 export declare const isGdprEventData: (value: EventData) => value is GdprEventData;
 export type HandlerFunc = (event: SubscriptionEvent) => Promise<void>;
-export declare const getSubscriptionEvent: (eventEnvelope: PublishEventEnvelope) => SubscriptionEvent | null;
+export declare const getSubscriptionEvent: (event: Event) => SubscriptionEvent | null;

package/dist/client/event.js

@@ -9,22 +9,16 @@ const isGdprEventData = (value) => {
         value.hasOwnProperty("gdprDefault"));
 };
 exports.isGdprEventData = isGdprEventData;
-const getSubscriptionEvent = (eventEnvelope) => {
-    const event = eventEnvelope.event;
-    if (!event) {
-        return null;
-    }
+const getSubscriptionEvent = (event) => {
     const payload = {};
     for (const key in event.payload) {
         if (Object.prototype.hasOwnProperty.call(event.payload, key)) {
             const data = event.payload[key];
-            if (data.metadata && data.metadata.gdpr) {
+            if (data.gdpr) {
                 payload[key] = {
                     value: JSON.parse(data.value),
-                    gdprDefault: data.metadata.gdpr.default
-                        ? JSON.parse(data.metadata.gdpr.default)
-                        : "",
-                    isInvalidated: data.metadata.gdpr.invalidated,
+                    gdprDefault: data.gdpr.default ? JSON.parse(data.gdpr.default) : "",
+                    isInvalidated: data.gdpr.isInvalidated,
                 };
             }
             else {
@@ -34,14 +28,14 @@ const getSubscriptionEvent = (eventEnvelope) => {
     }
     return {
         id: event.id,
-        topic: eventEnvelope.topic,
-        tenantId: eventEnvelope.tenantId,
+        topic: event.topic,
+        tenantId: event.tenantId,
         payload,
         raisedAt: new Date(parseInt(event.raisedAt.slice(0, -6))),
         stream: event.stream || undefined,
         type: event.type || undefined,
-        causationId: event.causationId || undefined,
-        correlationId: event.correlationId || undefined,
+        causationId: event.metadata ? event.metadata.causationId : undefined,
+        correlationId: event.metadata ? event.metadata.correlationId : undefined,
         reason: event.reason || undefined,
     };
 };

package/dist/client/getEvent.d.ts

@@ -1,3 +1,3 @@
-import { ServiceClient } from "@fraym/proto/freym/streams/clientchannel";
+import { ServiceClient } from "@fraym/proto/freym/streams/management";
 import { SubscriptionEvent } from "./event";
 export declare const getEvent: (tenantId: string, topic: string, eventId: string, serviceClient: ServiceClient) => Promise<SubscriptionEvent>;

package/dist/client/getEvent.js

@@ -2,23 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEvent = void 0;
 const event_1 = require("./event");
+const util_1 = require("./util");
 const getEvent = async (tenantId, topic, eventId, serviceClient) => {
-    return new Promise((resolve, reject) => {
+    return (0, util_1.retry)(() => new Promise((resolve, reject) => {
         serviceClient.getEvent({
             tenantId,
             topic,
-            eventId,
+            id: eventId,
         }, (error, response) => {
             if (error) {
-                reject(error.message);
+                reject(error);
                 return;
             }
             const event = (0, event_1.getSubscriptionEvent)(response);
             if (event) {
                 resolve(event);
+                return;
             }
             reject("unable to resolve event from event data");
         });
-    });
+    }));
 };
 exports.getEvent = getEvent;

package/dist/client/introduceGdpr.d.ts

@@ -1,3 +1,2 @@
-import { ServiceClient } from "@fraym/proto/freym/streams/clientchannel";
-export declare const introduceGdprOnField: (defaultValue: string, topic: string, eventType: string, fieldName: string, serviceClient: ServiceClient) => Promise<void>;
+import { ServiceClient } from "@fraym/proto/freym/streams/management";
 export declare const introduceGdprOnEventField: (tenantId: string, defaultValue: string, topic: string, eventId: string, fieldName: string, serviceClient: ServiceClient) => Promise<void>;

package/dist/client/introduceGdpr.js

@@ -1,38 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.introduceGdprOnEventField = exports.introduceGdprOnField = void 0;
-const introduceGdprOnField = async (defaultValue, topic, eventType, fieldName, serviceClient) => {
-    return new Promise((resolve, reject) => {
-        serviceClient.introduceGdprOnField({
-            defaultValue,
-            topic,
-            eventType,
-            fieldName,
-        }, error => {
-            if (error) {
-                reject(error.message);
-                return;
-            }
-            resolve();
-        });
-    });
-};
-exports.introduceGdprOnField = introduceGdprOnField;
+exports.introduceGdprOnEventField = void 0;
+const util_1 = require("./util");
 const introduceGdprOnEventField = async (tenantId, defaultValue, topic, eventId, fieldName, serviceClient) => {
-    return new Promise((resolve, reject) => {
+    return (0, util_1.retry)(() => new Promise((resolve, reject) => {
         serviceClient.introduceGdprOnEventField({
-            tenant: tenantId,
+            tenantId,
             defaultValue,
             topic,
             eventId,
             fieldName,
         }, error => {
             if (error) {
-                reject(error.message);
+                reject(error);
                 return;
             }
             resolve();
         });
-    });
+    }));
 };
 exports.introduceGdprOnEventField = introduceGdprOnEventField;

package/dist/client/invalidateGdpr.d.ts

@@ -1,2 +1,2 @@
-import { ServiceClient } from "@fraym/proto/freym/streams/clientchannel";
+import { ServiceClient } from "@fraym/proto/freym/streams/management";
 export declare const sendInvalidateGdpr: (tenantId: string, topic: string, gdprId: string, serviceClient: ServiceClient) => Promise<void>;

package/dist/client/invalidateGdpr.js

@@ -1,19 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendInvalidateGdpr = void 0;
+const util_1 = require("./util");
 const sendInvalidateGdpr = async (tenantId, topic, gdprId, serviceClient) => {
-    return new Promise((resolve, reject) => {
+    return (0, util_1.retry)(() => new Promise((resolve, reject) => {
         serviceClient.invalidateGdpr({
             tenantId,
             topic,
             gdprId,
         }, error => {
             if (error) {
-                reject(error.message);
+                reject(error);
                 return;
             }
             resolve();
         });
-    });
+    }));
 };
 exports.sendInvalidateGdpr = sendInvalidateGdpr;

package/dist/client/publish.d.ts

@@ -1,3 +1,3 @@
 import { PublishEvent } from "./event";
-import { ServiceClient } from "@fraym/proto/freym/streams/clientchannel";
+import { ServiceClient } from "@fraym/proto/freym/streams/management";
 export declare const sendPublish: (topic: string, events: PublishEvent[], serviceClient: ServiceClient) => Promise<void>;

package/dist/client/publish.js

@@ -2,22 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendPublish = void 0;
 const event_1 = require("./event");
+const util_1 = require("./util");
 const sendPublish = async (topic, events, serviceClient) => {
-    return new Promise((resolve, reject) => {
+    return (0, util_1.retry)(() => new Promise((resolve, reject) => {
         serviceClient.publish({
-            events: events.map(getEventEnvelopeFromPublishedEvent),
+            events: events.map(getProtobufPublishEventFromPublishedEvent),
             topic,
         }, error => {
             if (error) {
-                reject(error.message);
+                reject(error);
                 return;
             }
             resolve();
         });
-    });
+    }));
 };
 exports.sendPublish = sendPublish;
-const getEventEnvelopeFromPublishedEvent = (event) => {
+const getProtobufPublishEventFromPublishedEvent = (event) => {
     var _a, _b, _c, _d, _e, _f, _g;
     const payload = {};
     for (const key in event.payload) {
@@ -25,31 +26,30 @@ const getEventEnvelopeFromPublishedEvent = (event) => {
         payload[key] = (0, event_1.isGdprEventData)(currentData)
             ? {
                 value: JSON.stringify(currentData.value),
-                metadata: {
-                    $case: "gdpr",
-                    gdpr: {
-                        default: JSON.stringify(currentData.gdprDefault),
-                        id: (_a = currentData.id) !== null && _a !== void 0 ? _a : "",
-                        invalidated: false,
-                    },
+                gdpr: {
+                    default: JSON.stringify(currentData.gdprDefault),
+                    id: (_a = currentData.id) !== null && _a !== void 0 ? _a : "",
+                    isInvalidated: false,
                 },
             }
             : {
                 value: JSON.stringify(currentData),
+                gdpr: undefined,
             };
     }
     return {
-        broadcast: (_b = event.broadcast) !== null && _b !== void 0 ? _b : false,
-        tenantId: event.tenantId,
-        event: {
-            id: event.id,
-            type: (_c = event.type) !== null && _c !== void 0 ? _c : "",
-            reason: (_d = event.reason) !== null && _d !== void 0 ? _d : "",
-            stream: (_e = event.stream) !== null && _e !== void 0 ? _e : "",
-            correlationId: (_f = event.correlationId) !== null && _f !== void 0 ? _f : "",
-            causationId: (_g = event.causationId) !== null && _g !== void 0 ? _g : "",
-            payload,
-            raisedAt: "0",
+        id: event.id,
+        metadata: {
+            causationId: (_b = event.causationId) !== null && _b !== void 0 ? _b : "",
+            correlationId: (_c = event.correlationId) !== null && _c !== void 0 ? _c : "",
+        },
+        options: {
+            broadcast: (_d = event.broadcast) !== null && _d !== void 0 ? _d : false,
         },
+        reason: (_e = event.reason) !== null && _e !== void 0 ? _e : "",
+        stream: (_f = event.stream) !== null && _f !== void 0 ? _f : "",
+        tenantId: event.tenantId,
+        type: (_g = event.type) !== null && _g !== void 0 ? _g : "",
+        payload,
     };
 };

package/dist/client/stream.d.ts

@@ -1,5 +1,5 @@
 import { HandlerFunc } from "./event";
-import { ServiceClient, PublishEventEnvelope } from "@fraym/proto/freym/streams/clientchannel";
-export declare const getStream: (tenantId: string, stream: string, perPage: number, handler: HandlerFunc, serviceClient: ServiceClient) => Promise<void>;
-export declare const getStreamPage: (tenantId: string, stream: string, perPage: number, page: number, serviceClient: ServiceClient) => Promise<PublishEventEnvelope[]>;
-export declare const isStreamEmpty: (tenantId: string, stream: string, serviceClient: ServiceClient) => Promise<boolean>;
+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,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStreamEmpty = exports.getStreamPage = exports.getStream = void 0;
+exports.isStreamEmpty = exports.getStreamAfterEvent = exports.getStream = void 0;
 const event_1 = require("./event");
-const getStream = async (tenantId, stream, perPage, handler, serviceClient) => {
+const util_1 = require("./util");
+const getStream = async (topic, tenantId, stream, perPage, handler, serviceClient) => {
     let page = 0;
     while (true) {
-        const events = await (0, exports.getStreamPage)(tenantId, stream, perPage, page, serviceClient);
+        const events = await getStreamPage(topic, tenantId, stream, perPage, page, serviceClient);
         if (events.length === 0) {
             return;
         }
@@ -19,31 +20,67 @@ const getStream = async (tenantId, stream, perPage, handler, serviceClient) => {
     }
 };
 exports.getStream = getStream;
-const getStreamPage = async (tenantId, stream, perPage, page, serviceClient) => {
-    return new Promise((resolve, reject) => {
+const getStreamPage = async (topic, tenantId, stream, perPage, page, serviceClient) => {
+    return (0, util_1.retry)(() => new Promise((resolve, reject) => {
         serviceClient.paginateStream({
+            stream,
             tenantId,
+            topic,
+            page: page.toString(),
+            perPage: perPage.toString(),
+        }, async (error, data) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(data.events);
+        });
+    }));
+};
+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.message);
+                reject(error);
                 return;
             }
             resolve(data.events);
         });
-    });
+    }));
 };
-exports.getStreamPage = getStreamPage;
-const isStreamEmpty = async (tenantId, stream, serviceClient) => {
+const isStreamEmpty = async (topic, tenantId, stream, serviceClient) => {
     return new Promise((resolve, reject) => {
         serviceClient.isStreamEmpty({
+            topic,
             stream,
             tenantId,
         }, (error, data) => {
             if (error) {
-                reject(error.message);
+                reject(error);
                 return;
             }
             resolve(data.isEmpty);

package/dist/client/subscribe.d.ts

@@ -1,3 +1,13 @@
+import { ServiceClient, SubscribeRequest, SubscribeResponse } from "@fraym/proto/freym/streams/management";
+import { ClientDuplexStream } from "@grpc/grpc-js";
 import { ClientConfig } from "./config";
-import { Stream } from "./init";
-export declare const sendSubscribe: (includedTopics: string[], excludedTopics: string[], config: ClientConfig, stream: Stream) => Promise<void>;
+import { HandlerFunc } from "./event";
+export interface Subscription {
+    useHandler: (type: string, handler: HandlerFunc) => void;
+    useHandlerForAllTypes: (handler: HandlerFunc) => void;
+    start: () => void;
+    stop: () => void;
+}
+export type Stream = ClientDuplexStream<SubscribeRequest, SubscribeResponse>;
+export declare const newSubscription: (topics: string[], ignoreUnhandledEvents: boolean, config: ClientConfig, serviceClient: ServiceClient) => Subscription;
+export declare const initStream: (topics: string[], config: ClientConfig, stream: Stream) => Promise<Stream>;

package/dist/client/subscribe.js

@@ -1,39 +1,141 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendSubscribe = void 0;
-const sendSubscribe = async (includedTopics, excludedTopics, config, stream) => {
-    stream.write(newSubscribeRequest(includedTopics, excludedTopics));
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            stream.off("data", fn);
-            reject("did not receive subscribe ack in configured timeout range");
-        }, config.ackTimeout);
-        const fn = (data) => {
-            var _a, _b;
-            if (((_a = data.data) === null || _a === void 0 ? void 0 : _a.$case) === "subscribeNotAck") {
-                clearTimeout(timeout);
-                stream.off("data", fn);
-                reject(`did receive subscribe not ack message: ${data.data.subscribeNotAck.reason}`);
+exports.initStream = exports.newSubscription = void 0;
+const constants_1 = require("@grpc/grpc-js/build/src/constants");
+const uuid_1 = require("uuid");
+const event_1 = require("./event");
+const newSubscription = (topics, ignoreUnhandledEvents, config, serviceClient) => {
+    let stream = null;
+    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.cancel();
+                return;
+            }
+            rebuildConnection(newStream, retries - 1);
+        });
+        newStream.on("error", (err) => {
+            if (closed) {
+                return;
+            }
+            if (retries === 0 || (err && err.code && err.code === constants_1.Status.UNKNOWN)) {
+                closed = true;
+                throw err;
+            }
+            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.cancel();
                 return;
             }
-            if (((_b = data.data) === null || _b === void 0 ? void 0 : _b.$case) === "subscribeAck") {
-                clearTimeout(timeout);
-                stream.off("data", fn);
-                resolve();
+            const event = (0, event_1.getSubscriptionEvent)(data.payload.event);
+            if (!event) {
                 return;
             }
+            const currentHandlers = (_d = typeHandlerMap[(_c = event.type) !== null && _c !== void 0 ? _c : ""]) !== null && _d !== void 0 ? _d : [];
+            currentHandlers.push(...globalHandlers);
+            if (currentHandlers.length === 0) {
+                if (ignoreUnhandledEvents) {
+                    newStream.write(newHandledRequest(event.tenantId, event.topic));
+                    return;
+                }
+                newStream.write(newHandledRequest(event.tenantId, event.topic, "no handlers for this event, maybe you forgot to register an event handler"));
+                return;
+            }
+            try {
+                for (const handler of currentHandlers) {
+                    await handler(event);
+                }
+                newStream.write(newHandledRequest(event.tenantId, event.topic));
+            }
+            catch (err) {
+                newStream.write(newHandledRequest(event.tenantId, event.topic, err));
+                throw err;
+            }
         };
-        stream.on("data", fn);
+        stream = newStream;
+        await (0, exports.initStream)(topics, config, newStream);
+        retries = 50;
+        newStream.on("data", dataFn);
+    };
+    return {
+        useHandler: (type, handler) => {
+            if (!typeHandlerMap[type]) {
+                typeHandlerMap[type] = [handler];
+            }
+            else {
+                typeHandlerMap[type].push(handler);
+            }
+        },
+        useHandlerForAllTypes: (handler) => {
+            globalHandlers.push(handler);
+        },
+        start: () => {
+            reconnect(50);
+        },
+        stop: () => {
+            if (stream) {
+                stream.cancel();
+                stream = null;
+            }
+            closed = true;
+        },
+    };
+};
+exports.newSubscription = newSubscription;
+const initStream = async (topics, config, stream) => {
+    return new Promise((resolve, reject) => {
+        stream.write({
+            payload: {
+                $case: "subscribe",
+                subscribe: {
+                    metadata: {
+                        group: config.groupId,
+                        subscriberId: (0, uuid_1.v4)(),
+                    },
+                    topics,
+                },
+            },
+        });
+        stream.once("data", (data) => {
+            var _a;
+            if (((_a = data.payload) === null || _a === void 0 ? void 0 : _a.$case) !== "subscribed") {
+                reject("connection to streams service was not initialized correctly");
+                return;
+            }
+            if (data.payload.subscribed.error) {
+                reject(`unable to subscribe to streams service: ${data.payload.subscribed.error}`);
+                return;
+            }
+            resolve(stream);
+        });
     });
 };
-exports.sendSubscribe = sendSubscribe;
-const newSubscribeRequest = (includedTopics, excludedTopics) => {
+exports.initStream = initStream;
+const newHandledRequest = (tenantId, topic, error) => {
     return {
         payload: {
-            $case: "subscribe",
-            subscribe: {
-                excludedTopics,
-                includedTopics,
+            $case: "handled",
+            handled: {
+                tenantId,
+                topic,
+                error: error !== null && error !== void 0 ? error : "",
             },
         },
     };

package/dist/client/util.d.ts

@@ -0,0 +1,2 @@
+export declare const sleep: (delay: number) => Promise<void>;
+export declare const retry: <T extends unknown>(fn: () => Promise<T>, pause?: number, retries?: number) => Promise<T>;

package/dist/client/util.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retry = exports.sleep = void 0;
+const constants_1 = require("@grpc/grpc-js/build/src/constants");
+const sleep = (delay) => new Promise(resolve => {
+    setTimeout(() => resolve(), delay);
+});
+exports.sleep = sleep;
+const retry = async (fn, pause = 100, retries = 50) => {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (retries === 0 || (err && err.code && err.code === constants_1.Status.UNKNOWN)) {
+            throw err;
+        }
+        await (0, exports.sleep)(pause);
+        return await (0, exports.retry)(fn, pause, retries - 1);
+    }
+};
+exports.retry = retry;

package/package.json

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

package/dist/client/errors/alreadySubscribed.d.ts

@@ -1,3 +0,0 @@
-export declare class AlreadySubscribedError extends Error {
-    constructor();
-}

package/dist/client/errors/alreadySubscribed.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AlreadySubscribedError = void 0;
-class AlreadySubscribedError extends Error {
-    constructor() {
-        super("streams client is already subscribed to a set of topics");
-    }
-}
-exports.AlreadySubscribedError = AlreadySubscribedError;

package/dist/client/handler.d.ts

@@ -1,8 +0,0 @@
-import { Stream } from "./init";
-import { HandlerFunc } from "./event";
-interface EventHandler {
-    addHandler: (type: string, handler: HandlerFunc) => void;
-    addHandlerForAllTypes: (handler: HandlerFunc) => void;
-}
-export declare const initEventHandler: (stream: Stream) => EventHandler;
-export {};

package/dist/client/handler.js

@@ -1,82 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initEventHandler = void 0;
-const event_1 = require("./event");
-const initEventHandler = (stream) => {
-    const typeHandlerMap = {};
-    const globalHandlers = [];
-    stream.on("data", (data) => {
-        var _a, _b, _c;
-        if (((_a = data.data) === null || _a === void 0 ? void 0 : _a.$case) !== "event") {
-            return;
-        }
-        const event = (0, event_1.getSubscriptionEvent)(data.data.event);
-        if (!event) {
-            return;
-        }
-        const typeHandlers = (_c = typeHandlerMap[(_b = event.type) !== null && _b !== void 0 ? _b : ""]) !== null && _c !== void 0 ? _c : [];
-        typeHandlers.forEach(handler => handleEvent(event, handler, stream));
-        globalHandlers.forEach(handler => handleEvent(event, handler, stream));
-    });
-    return {
-        addHandler: (type, handler) => {
-            if (!typeHandlerMap[type]) {
-                typeHandlerMap[type] = [handler];
-            }
-            else {
-                typeHandlerMap[type].push(handler);
-            }
-        },
-        addHandlerForAllTypes: handler => {
-            globalHandlers.push(handler);
-        },
-    };
-};
-exports.initEventHandler = initEventHandler;
-const handleEvent = (event, handler, stream) => {
-    stream.write(newEventReceivedRequest(event.tenantId, event.topic, event.id));
-    handler(event)
-        .then(() => {
-        stream.write(newEventHandledRequest(event.tenantId, event.topic, event.id));
-    })
-        .catch(e => {
-        stream.write(newEventNotHandledRequest(event.tenantId, event.topic, event.id, e));
-    });
-};
-const newEventReceivedRequest = (tenantId, topic, eventId) => {
-    return {
-        payload: {
-            $case: "eventReceived",
-            eventReceived: {
-                eventId,
-                tenantId,
-                topic,
-            },
-        },
-    };
-};
-const newEventHandledRequest = (tenantId, topic, eventId) => {
-    return {
-        payload: {
-            $case: "eventHandled",
-            eventHandled: {
-                eventId,
-                tenantId,
-                topic,
-            },
-        },
-    };
-};
-const newEventNotHandledRequest = (tenantId, topic, eventId, reason) => {
-    return {
-        payload: {
-            $case: "eventNotHandled",
-            eventNotHandled: {
-                eventId,
-                tenantId,
-                topic,
-                reason,
-            },
-        },
-    };
-};

package/dist/client/init.d.ts

@@ -1,5 +0,0 @@
-import { ClientConfig } from "./config";
-import { ClientDuplexStream } from "@grpc/grpc-js";
-import { SubscribeRequest, ServiceClient, SubscribeResponse } from "@fraym/proto/freym/streams/clientchannel";
-export type Stream = ClientDuplexStream<SubscribeRequest, SubscribeResponse>;
-export declare const initStream: (config: ClientConfig, serviceClient: ServiceClient) => Promise<Stream>;

package/dist/client/init.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initStream = void 0;
-const uuid_1 = require("uuid");
-const initStream = async (config, serviceClient) => {
-    const stream = serviceClient.subscribe();
-    stream.on("end", stream.end);
-    return new Promise((resolve, reject) => {
-        stream.once("data", (data) => {
-            var _a;
-            if (((_a = data.data) === null || _a === void 0 ? void 0 : _a.$case) !== "initAck") {
-                reject("connection to streams service was not initialized correctly");
-                return;
-            }
-            resolve(stream);
-        });
-        stream.write(newInitRequest(config));
-    });
-};
-exports.initStream = initStream;
-const newInitAction = (config) => {
-    return {
-        groupId: config.groupId,
-        subscriberId: (0, uuid_1.v4)(),
-    };
-};
-const newInitRequest = (config) => {
-    return {
-        payload: {
-            $case: "init",
-            init: newInitAction(config),
-        },
-    };
-};

package/dist/client/snapshot.d.ts

@@ -1,2 +0,0 @@
-import { ServiceClient } from "@fraym/proto/freym/streams/clientchannel";
-export declare const sendSnapshot: (topic: string, toTime: Date, serviceClient: ServiceClient) => Promise<void>;

package/dist/client/snapshot.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendSnapshot = void 0;
-const sendSnapshot = async (topic, toTime, serviceClient) => {
-    return new Promise((resolve, reject) => {
-        serviceClient.snapshot({
-            topic,
-            toTime: toTime.toISOString(),
-        }, error => {
-            if (error) {
-                reject(error.message);
-                return;
-            }
-            resolve();
-        });
-    });
-};
-exports.sendSnapshot = sendSnapshot;