@fraym/streams 0.7.2 → 0.9.0

package/dist/client/client.d.ts

@@ -8,6 +8,7 @@ export interface StreamIterator {
 }
 export interface Client {
     getEvent: (tenantId: string, topic: string, eventId: string) => Promise<SubscriptionEvent>;
+    getLastEvent: (tenantId: string, topic: string) => Promise<SubscriptionEvent | null>;
     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>;
@@ -16,6 +17,7 @@ export interface Client {
     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) => Promise<void>;
+    createStreamSnapshot: (tenantId: string, topic: string, stream: string, lastSnapshottedEventId: string, snapshotEvent: PublishEvent) => Promise<void>;
     close: () => void;
 }
 export declare const newClient: (config: ClientConfig) => Promise<Client>;

package/dist/client/client.js

@@ -11,6 +11,7 @@ const introduceGdpr_1 = require("./introduceGdpr");
 const invalidateGdpr_1 = require("./invalidateGdpr");
 const stream_1 = require("./stream");
 const subscribe_1 = require("./subscribe");
+const getLastEvent_1 = require("./getLastEvent");
 const newClient = async (config) => {
     config = (0, config_1.useConfigDefaults)(config);
     const serviceClient = new management_1.ServiceClient(config.serverAddress, grpc_js_1.credentials.createInsecure(), {
@@ -19,23 +20,43 @@ const newClient = async (config) => {
         "grpc.keepalive_permit_without_calls": 1,
     });
     const closeFunctions = [];
+    const getLastEventCheck = async (tenantId, topic) => {
+        const now = new Date(new Date().getTime() + 3000);
+        const lastEvent = await (0, getLastEvent_1.getLastEvent)(tenantId, topic, serviceClient);
+        if (!lastEvent) {
+            return null;
+        }
+        const lastOrderSerial = lastEvent.orderSerial;
+        return (lastEvent) => {
+            if (!lastEvent) {
+                return true;
+            }
+            if (lastOrderSerial == undefined) {
+                return lastEvent.raisedAt > now;
+            }
+            const orderSerial = lastEvent.orderSerial ? lastEvent.orderSerial : 0;
+            return orderSerial > lastOrderSerial;
+        };
+    };
     const getStreamIterator = async (topic, tenantId, stream, perPage) => {
         return {
             forEach: async (callback) => {
-                const now = new Date(new Date().getTime() + 3000);
+                const lastEventCheck = await getLastEventCheck(tenantId, topic);
+                if (!lastEventCheck) {
+                    return;
+                }
                 return await (0, stream_1.getStream)(topic, tenantId, stream, perPage, async (event) => {
                     callback(event);
-                }, (lastEvent) => {
-                    return !lastEvent || lastEvent.raisedAt > now;
-                }, serviceClient);
+                }, lastEventCheck, serviceClient);
             },
             forEachAfterEvent: async (eventId, callback) => {
-                const now = new Date(new Date().getTime() + 3000);
+                const lastEventCheck = await getLastEventCheck(tenantId, topic);
+                if (!lastEventCheck) {
+                    return;
+                }
                 return await (0, stream_1.getStreamAfterEvent)(topic, tenantId, stream, eventId, perPage, async (event) => {
                     callback(event);
-                }, (lastEvent) => {
-                    return !lastEvent || lastEvent.raisedAt > now;
-                }, serviceClient);
+                }, lastEventCheck, serviceClient);
             },
             isEmpty: async () => {
                 return (0, stream_1.isStreamEmpty)(topic, tenantId, stream, serviceClient);
@@ -46,17 +67,22 @@ const newClient = async (config) => {
         getEvent: async (tenantId, topic, eventId) => {
             return await (0, getEvent_1.getEvent)(tenantId, topic, eventId, serviceClient);
         },
+        getLastEvent: async (tenantId, topic) => {
+            return await (0, getLastEvent_1.getLastEvent)(tenantId, topic, serviceClient);
+        },
         iterateAllEvents: async (tenantId, topic, includedEventTypes, perPage, handler) => {
-            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);
+            const lastEventCheck = await getLastEventCheck(tenantId, topic);
+            if (!lastEventCheck) {
+                return;
+            }
+            await (0, allEvents_1.getAllEvents)(tenantId, topic, includedEventTypes, perPage, handler, lastEventCheck, serviceClient);
         },
         iterateAllEventsAfterEvent: async (tenantId, topic, includedEventTypes, eventId, perPage, handler) => {
-            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);
+            const lastEventCheck = await getLastEventCheck(tenantId, topic);
+            if (!lastEventCheck) {
+                return;
+            }
+            await (0, allEvents_1.getAllEventsAfterEvent)(tenantId, topic, includedEventTypes, eventId, perPage, handler, lastEventCheck, serviceClient);
         },
         publish: async (topic, events) => {
             return await (0, publish_1.sendPublish)(topic, events, serviceClient);
@@ -78,6 +104,10 @@ const newClient = async (config) => {
         invalidateGdprData: async (tenantId, topic, gdprId) => {
             return await (0, invalidateGdpr_1.sendInvalidateGdpr)(tenantId, topic, gdprId, serviceClient);
         },
+        createStreamSnapshot: async (tenantId, topic, stream, idOfLastEventThatGotSnapshotted, snapshotEvent) => {
+            console.log("aaa");
+            return await (0, stream_1.createStreamSnapshot)(tenantId, topic, stream, idOfLastEventThatGotSnapshotted, snapshotEvent, serviceClient);
+        },
         close: () => {
             closeFunctions.forEach(close => close());
         },

package/dist/client/event.d.ts

@@ -2,6 +2,7 @@ import { Event } from "@fraym/proto/freym/streams/management";
 export interface SubscriptionEvent extends BaseEvent {
     topic: string;
     raisedAt: Date;
+    orderSerial?: number;
 }
 export interface PublishEvent extends BaseEvent {
     broadcast?: boolean;

package/dist/client/event.js

@@ -38,6 +38,7 @@ const getSubscriptionEvent = (event) => {
         causationId: event.metadata ? event.metadata.causationId : undefined,
         correlationId: event.metadata ? event.metadata.correlationId : undefined,
         reason: event.reason || undefined,
+        orderSerial: event.metadata ? parseInt(event.metadata.orderSerial) : undefined,
     };
 };
 exports.getSubscriptionEvent = getSubscriptionEvent;

package/dist/client/getLastEvent.d.ts

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

package/dist/client/getLastEvent.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastEvent = void 0;
+const event_1 = require("./event");
+const util_1 = require("./util");
+const getLastEvent = async (tenantId, topic, serviceClient) => {
+    return (0, util_1.retry)(() => new Promise((resolve, reject) => {
+        serviceClient.getLastEvent({
+            tenantId,
+            topic,
+        }, (error, response) => {
+            if (error === null || error === void 0 ? void 0 : error.details.includes("unable to find last event")) {
+                resolve(null);
+                return;
+            }
+            if (error) {
+                reject(error);
+                return;
+            }
+            const event = (0, event_1.getSubscriptionEvent)(response);
+            if (event) {
+                resolve(event);
+                return;
+            }
+            reject("unable to resolve last event from event data");
+        });
+    }));
+};
+exports.getLastEvent = getLastEvent;

package/dist/client/publish.d.ts

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

package/dist/client/publish.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendPublish = void 0;
+exports.getProtobufPublishEventFromPublishedEvent = exports.sendPublish = void 0;
 const event_1 = require("./event");
 const util_1 = require("./util");
 const sendPublish = async (topic, events, serviceClient) => {
     return (0, util_1.retry)(() => new Promise((resolve, reject) => {
         serviceClient.publish({
-            events: events.map(getProtobufPublishEventFromPublishedEvent),
+            events: events.map(exports.getProtobufPublishEventFromPublishedEvent),
             topic,
         }, error => {
             if (error) {
@@ -42,6 +42,7 @@ const getProtobufPublishEventFromPublishedEvent = (event) => {
         metadata: {
             causationId: (_b = event.causationId) !== null && _b !== void 0 ? _b : "",
             correlationId: (_c = event.correlationId) !== null && _c !== void 0 ? _c : "",
+            orderSerial: "0",
         },
         options: {
             broadcast: (_d = event.broadcast) !== null && _d !== void 0 ? _d : false,
@@ -53,3 +54,4 @@ const getProtobufPublishEventFromPublishedEvent = (event) => {
         payload,
     };
 };
+exports.getProtobufPublishEventFromPublishedEvent = getProtobufPublishEventFromPublishedEvent;

package/dist/client/stream.d.ts

@@ -1,6 +1,7 @@
-import { HandlerFunc } from "./event";
+import { HandlerFunc, PublishEvent } from "./event";
 import { ServiceClient } from "@fraym/proto/freym/streams/management";
 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>;
+export declare const createStreamSnapshot: (tenantId: string, topic: string, stream: string, lastSnapshottedEventId: string, snapshotEvent: PublishEvent, serviceClient: ServiceClient) => Promise<void>;

package/dist/client/stream.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStreamEmpty = exports.getStreamAfterEvent = exports.getStream = void 0;
+exports.createStreamSnapshot = exports.isStreamEmpty = exports.getStreamAfterEvent = exports.getStream = void 0;
 const event_1 = require("./event");
 const util_1 = require("./util");
+const publish_1 = require("./publish");
 const getStream = async (topic, tenantId, stream, perPage, handler, stopLoadingMore, serviceClient) => {
     let page = 0;
     while (true) {
@@ -92,3 +93,22 @@ const isStreamEmpty = async (topic, tenantId, stream, serviceClient) => {
     });
 };
 exports.isStreamEmpty = isStreamEmpty;
+const createStreamSnapshot = async (tenantId, topic, stream, lastSnapshottedEventId, snapshotEvent, serviceClient) => {
+    console.log("creating snapshot", tenantId, topic, stream, lastSnapshottedEventId);
+    return new Promise((resolve, reject) => {
+        serviceClient.createStreamSnapshot({
+            topic,
+            stream,
+            tenantId,
+            lastSnapshottedEventId,
+            snapshotEvent: (0, publish_1.getProtobufPublishEventFromPublishedEvent)(snapshotEvent),
+        }, error => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+};
+exports.createStreamSnapshot = createStreamSnapshot;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraym/streams",
-    "version": "0.7.2",
+    "version": "0.9.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.14.0",
-        "@grpc/grpc-js": "^1.10.0",
+        "@fraym/proto": "^0.19.0",
+        "@grpc/grpc-js": "^1.11.1",
         "uuid": "^9.0.1"
     },
     "devDependencies": {