@fraym/streams 0.1.1 → 0.1.3

package/README.md

@@ -1,4 +1,4 @@
-# streams-go
+# streams-nodejs
 
 Client implementation in javascript for the event streaming service [streams](https://github.com/fraym-work/streams).
 
@@ -22,9 +22,10 @@ const client = await newClient({
 ### Publish events
 
 Events are published in a transactional manner:
-* you can publish a set of events in a transaction
-* if one event in your set cannot be published no event will be published
-* as soon as all events are published they appear in their streams
+
+-   you can publish a set of events in a transaction
+-   if one event in your set cannot be published no event will be published
+-   as soon as all events are published they appear in their streams
 
 You can only publish events of one topic per transaction.
 Most of the fields of an event are optional. You do not have to use or specify them, but you can use them if you want to.
@@ -39,7 +40,7 @@ await client.publish("topic", [
         },
         // set `broadcast` to true if you want all subscribers of a group to process the event.
         // set to false (or remove) if you want this event to be handled only once by a group of subscribers.
-        broadcast: false, 
+        broadcast: false,
         type: "event-type",
         stream: "stream-name",
         correlationId: uuid(),
@@ -95,11 +96,11 @@ One client instance is only able to subscribe once. If you try to subscribe twic
 
 ### Get all events for a given topic filter
 
-The `getAllEvents` function uses the same filter logic as described for the [subscribe](#subscribe-to-events) function
+The `getAllEvents` function uses the same topic filter parameters as described for the [subscribe](#subscribe-to-events) function
 
 ```typescript
 await client.getAllEvents(async (event: SubscriptionEvent) => {
-    // @todo: handle the event in this callback 
+    // @todo: handle the event in this callback
 });
 ```
 
@@ -108,7 +109,7 @@ await client.getAllEvents(async (event: SubscriptionEvent) => {
 You will not need to use this if you use our GDPR service.
 
 ```typescript
-await client.invalidateGdprData("tenantId", "topic-1", "grprId")
+await client.invalidateGdprData("tenantId", "topic-1", "grprId");
 ```
 
 ### Create a snapshot of a topic
@@ -134,3 +135,38 @@ You won't lose any data if you don't. Use it for your peace of mind.
 ```typescript
 client.close();
 ```
+
+## Development
+
+You'll need the following apps for a smooth development experience:
+
+-   minikube
+-   lens
+-   okteto
+-   helm
+
+### Running the dev environment
+
+-   Start minikube if not already done:
+
+```shell
+minikube start
+```
+
+-   add mongodb and minio to your lokal kubernetes
+    -   use Makefiles in `./.dev/*`
+-   copy `.env.build` to `.env.build.local`
+    -   add your personal access token (needs read access for private fraym org repositories)
+-   deploy the app to your cluster
+
+```
+make init
+```
+
+-   start okteto
+
+```
+make dev
+```
+
+-   connect your IDE to that okteto instance

package/dist/client/allEvents.d.ts

@@ -0,0 +1,3 @@
+import { ServiceClient } from "@fraym/streams-proto";
+import { HandlerFunc } from "./event";
+export declare const getAllEvents: (includedTopics: string[], excludedTopics: string[], handler: HandlerFunc, serviceClient: ServiceClient) => Promise<void>;

package/dist/client/allEvents.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllEvents = void 0;
+const event_1 = require("./event");
+const getAllEvents = async (includedTopics, excludedTopics, handler, serviceClient) => {
+    const stream = serviceClient.getEventsFromStart({
+        excludedTopics,
+        includedTopics,
+    });
+    return new Promise((resolve, reject) => {
+        stream.on("data", (data) => {
+            const event = (0, event_1.getSubscriptionEvent)(data);
+            if (event) {
+                handler(event);
+            }
+        });
+        stream.on("end", () => {
+            resolve();
+        });
+        stream.on("error", e => {
+            reject(e);
+        });
+    });
+};
+exports.getAllEvents = getAllEvents;

package/dist/client/client.d.ts

@@ -0,0 +1,14 @@
+import { ClientConfig } from "./config";
+import { HandlerFunc, PublishEvent, SubscriptionEvent } from "./event";
+export interface Client {
+    getAllEvents: (handler: HandlerFunc, includedTopics?: string[], excludedTopics?: string[]) => Promise<void>;
+    getStream: (tenantId: string, stream: string) => Promise<SubscriptionEvent[]>;
+    useEventHandler: (type: string, handler: HandlerFunc) => void;
+    useEventHandlerForAllEventTypes: (handler: HandlerFunc) => void;
+    subscribe: (includedTopics?: string[], excludedTopics?: string[]) => Promise<void>;
+    publish: (topic: string, events: PublishEvent[]) => Promise<void>;
+    invalidateGdprData: (tenantId: string, topic: string, gdprId: string) => Promise<void>;
+    createSnapshot: (topic: string, toTime: Date) => Promise<void>;
+    close: () => void;
+}
+export declare const newClient: (config: ClientConfig) => Promise<Client>;

package/dist/client/client.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newClient = void 0;
+const streams_proto_1 = require("@fraym/streams-proto");
+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 publish_1 = require("./publish");
+const snapshot_1 = require("./snapshot");
+const stream_1 = require("./stream");
+const subscribe_1 = require("./subscribe");
+const newClient = async (config) => {
+    config = (0, config_1.useConfigDefaults)(config);
+    const serviceClient = new streams_proto_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;
+    return {
+        getAllEvents: async (handler, includedTopics = [], excludedTopics = []) => {
+            await (0, allEvents_1.getAllEvents)(includedTopics, excludedTopics, handler, serviceClient);
+        },
+        getStream: async (tenantId, stream) => {
+            return await (0, stream_1.getStream)(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, config, stream);
+        },
+        invalidateGdprData: async (tenantId, topic, gdprId) => {
+            return await (0, invalidateGdpr_1.sendInvalidateGdpr)(tenantId, topic, gdprId, config, stream);
+        },
+        createSnapshot: async (topic, toTime) => {
+            return await (0, snapshot_1.sendSnapshot)(topic, toTime, config, stream);
+        },
+        close: () => {
+            stream.end();
+        },
+    };
+};
+exports.newClient = newClient;

package/dist/client/config.d.ts

@@ -0,0 +1,8 @@
+export interface ClientConfig {
+    serverAddress: string;
+    groupId: string;
+    ackTimeout?: number;
+    keepaliveInterval?: number;
+    keepaliveTimeout?: number;
+}
+export declare const useConfigDefaults: (config: ClientConfig) => Required<ClientConfig>;

package/dist/client/config.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useConfigDefaults = void 0;
+const useConfigDefaults = (config) => {
+    var _a, _b, _c;
+    return {
+        serverAddress: config.serverAddress,
+        groupId: config.groupId,
+        ackTimeout: (_a = config.ackTimeout) !== null && _a !== void 0 ? _a : 1000,
+        keepaliveTimeout: (_b = config.keepaliveTimeout) !== null && _b !== void 0 ? _b : 3 * 1000,
+        keepaliveInterval: (_c = config.keepaliveInterval) !== null && _c !== void 0 ? _c : 40 * 1000,
+    };
+};
+exports.useConfigDefaults = useConfigDefaults;

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

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

package/dist/client/errors/alreadySubscribed.js

@@ -0,0 +1,9 @@
+"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/event.d.ts

@@ -0,0 +1,25 @@
+import { PublishEventEnvelope } from "@fraym/streams-proto";
+export interface SubscriptionEvent extends BaseEvent {
+    topic: string;
+    raisedAt: Date;
+}
+export interface PublishEvent extends BaseEvent {
+    broadcast?: boolean;
+}
+export interface BaseEvent {
+    id: string;
+    payload: Record<string, EventData>;
+    tenantId: string;
+    type?: string;
+    stream?: string;
+    correlationId?: string;
+    causationId?: string;
+    reason?: string;
+}
+export declare type EventData = string | GdprEventData;
+export interface GdprEventData {
+    value: string;
+    gdprDefault: string;
+}
+export declare type HandlerFunc = (event: SubscriptionEvent) => Promise<void>;
+export declare const getSubscriptionEvent: (eventEnvelope: PublishEventEnvelope) => SubscriptionEvent | null;

package/dist/client/event.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubscriptionEvent = void 0;
+const getSubscriptionEvent = (eventEnvelope) => {
+    var _a;
+    const event = eventEnvelope.event;
+    if (!event) {
+        return null;
+    }
+    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) {
+                payload[key] = {
+                    value: data.value,
+                    gdprDefault: (_a = data.metadata.gdpr.default) !== null && _a !== void 0 ? _a : "",
+                };
+            }
+            else {
+                payload[key] = data.value;
+            }
+        }
+    }
+    return {
+        id: event.id,
+        topic: eventEnvelope.topic,
+        tenantId: eventEnvelope.tenantId,
+        payload,
+        raisedAt: new Date(event.raisedAt),
+        stream: event.stream || undefined,
+        type: event.type || undefined,
+        causationId: event.causationId || undefined,
+        correlationId: event.correlationId || undefined,
+        reason: event.reason || undefined,
+    };
+};
+exports.getSubscriptionEvent = getSubscriptionEvent;

package/dist/client/handler.d.ts

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,69 @@
+"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) => {
+    handler(event)
+        .then(() => {
+        stream.write(newEventAckRequest(event.tenantId, event.topic, event.id));
+    })
+        .catch(e => {
+        stream.write(newEventNotAckRequest(event.tenantId, event.topic, event.id, e));
+    });
+};
+const newEventAckRequest = (tenantId, topic, eventId) => {
+    return {
+        payload: {
+            $case: "eventAck",
+            eventAck: {
+                eventId,
+                tenantId,
+                topic,
+            },
+        },
+    };
+};
+const newEventNotAckRequest = (tenantId, topic, eventId, reason) => {
+    return {
+        payload: {
+            $case: "eventNotAck",
+            eventNotAck: {
+                eventId,
+                tenantId,
+                topic,
+                reason,
+            },
+        },
+    };
+};

package/dist/client/init.d.ts

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

package/dist/client/init.js

@@ -0,0 +1,34 @@
+"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.connect();
+    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/invalidateGdpr.d.ts

@@ -0,0 +1,3 @@
+import { ClientConfig } from "./config";
+import { Stream } from "./init";
+export declare const sendInvalidateGdpr: (tenantId: string, topic: string, gdprId: string, config: ClientConfig, stream: Stream) => Promise<void>;

package/dist/client/invalidateGdpr.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendInvalidateGdpr = void 0;
+const sendInvalidateGdpr = async (tenantId, topic, gdprId, config, stream) => {
+    stream.write(newInvalidateGdprRequest(tenantId, topic, gdprId));
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            stream.off("data", fn);
+            reject("did not receive invalidate gdpr 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) === "invalidateGdprNotAck") {
+                const notAck = data.data.invalidateGdprNotAck;
+                if (notAck.tenantId === tenantId &&
+                    notAck.topic === topic &&
+                    notAck.gdprId === gdprId) {
+                    clearTimeout(timeout);
+                    stream.off("data", fn);
+                    reject(`did receive invalidate gdpr not ack message, reason: ${notAck.reason}`);
+                    return;
+                }
+            }
+            if (((_b = data.data) === null || _b === void 0 ? void 0 : _b.$case) === "invalidateGdprAck") {
+                const ack = data.data.invalidateGdprAck;
+                if (ack.tenantId === tenantId && ack.topic === topic && ack.gdprId === gdprId) {
+                    clearTimeout(timeout);
+                    stream.off("data", fn);
+                    resolve();
+                    return;
+                }
+            }
+        };
+        stream.on("data", fn);
+    });
+};
+exports.sendInvalidateGdpr = sendInvalidateGdpr;
+const newInvalidateGdprRequest = (tenantId, topic, gdprId) => {
+    return {
+        payload: {
+            $case: "invalidateGdpr",
+            invalidateGdpr: {
+                tenantId,
+                topic,
+                gdprId,
+            },
+        },
+    };
+};

package/dist/client/publish.d.ts

@@ -0,0 +1,4 @@
+import { Stream } from "./init";
+import { ClientConfig } from "./config";
+import { PublishEvent } from "./event";
+export declare const sendPublish: (topic: string, events: PublishEvent[], config: ClientConfig, stream: Stream) => Promise<void>;

package/dist/client/publish.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendPublish = void 0;
+const uuid_1 = require("uuid");
+const sendPublish = async (topic, events, config, stream) => {
+    const publishActionId = (0, uuid_1.v4)();
+    stream.write(newPublishRequest(publishActionId, topic, events));
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            stream.off("data", fn);
+            reject("did not receive publish 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) === "publishAck" &&
+                data.data.publishAck.publishActionId === publishActionId) {
+                clearTimeout(timeout);
+                stream.off("data", fn);
+                resolve();
+                return;
+            }
+            if (((_b = data.data) === null || _b === void 0 ? void 0 : _b.$case) === "publishNotAck" &&
+                data.data.publishNotAck.publishActionId === publishActionId) {
+                clearTimeout(timeout);
+                stream.off("data", fn);
+                reject(`did receive publish not ack message: ${data.data.publishNotAck.reason}`);
+                return;
+            }
+        };
+        stream.on("data", fn);
+    });
+};
+exports.sendPublish = sendPublish;
+const newPublishRequest = (publishActionId, topic, events) => {
+    return {
+        payload: {
+            $case: "publish",
+            publish: {
+                topic,
+                publishActionId,
+                events: events.map(getEventEnvelopeFromPublishedEvent),
+            },
+        },
+    };
+};
+const getEventEnvelopeFromPublishedEvent = (event) => {
+    var _a, _b, _c, _d, _e, _f;
+    const payload = {};
+    for (const key in event.payload) {
+        const currentData = event.payload[key];
+        payload[key] =
+            typeof currentData === "string"
+                ? {
+                    value: currentData,
+                }
+                : {
+                    value: currentData.value,
+                    metadata: {
+                        $case: "gdpr",
+                        gdpr: {
+                            default: currentData.gdprDefault,
+                            id: "",
+                        },
+                    },
+                };
+    }
+    return {
+        broadcast: (_a = event.broadcast) !== null && _a !== void 0 ? _a : false,
+        tenantId: event.tenantId,
+        event: {
+            id: event.id,
+            type: (_b = event.type) !== null && _b !== void 0 ? _b : "",
+            reason: (_c = event.reason) !== null && _c !== void 0 ? _c : "",
+            stream: (_d = event.stream) !== null && _d !== void 0 ? _d : "",
+            correlationId: (_e = event.correlationId) !== null && _e !== void 0 ? _e : "",
+            causationId: (_f = event.causationId) !== null && _f !== void 0 ? _f : "",
+            payload,
+            raisedAt: "",
+        },
+    };
+};

package/dist/client/snapshot.d.ts

@@ -0,0 +1,3 @@
+import { ClientConfig } from "./config";
+import { Stream } from "./init";
+export declare const sendSnapshot: (topic: string, toTime: Date, config: ClientConfig, stream: Stream) => Promise<void>;

package/dist/client/snapshot.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendSnapshot = void 0;
+const sendSnapshot = async (topic, toTime, config, stream) => {
+    stream.write(newSnapshotRequest(topic, toTime));
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            stream.off("data", fn);
+            reject("did not receive snapshot 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) === "snapshotNotAck" && data.data.snapshotNotAck.topic === topic) {
+                clearTimeout(timeout);
+                stream.off("data", fn);
+                reject(`did receive snapshot not ack message, reason: ${data.data.snapshotNotAck.reason}`);
+                return;
+            }
+            if (((_b = data.data) === null || _b === void 0 ? void 0 : _b.$case) === "snapshotAck" && data.data.snapshotAck.topic === topic) {
+                clearTimeout(timeout);
+                stream.off("data", fn);
+                resolve();
+                return;
+            }
+        };
+        stream.on("data", fn);
+    });
+};
+exports.sendSnapshot = sendSnapshot;
+const newSnapshotRequest = (topic, toTime) => {
+    return {
+        payload: {
+            $case: "snapshot",
+            snapshot: {
+                topic,
+                toTime: toTime.toISOString(),
+            },
+        },
+    };
+};

package/dist/client/stream.d.ts

@@ -0,0 +1,3 @@
+import { SubscriptionEvent } from "./event";
+import { ServiceClient } from "@fraym/streams-proto";
+export declare const getStream: (tenantId: string, stream: string, serviceClient: ServiceClient) => Promise<SubscriptionEvent[]>;

package/dist/client/stream.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStream = void 0;
+const event_1 = require("./event");
+const getStream = async (tenantId, stream, serviceClient) => {
+    return new Promise((resolve, reject) => {
+        serviceClient.getStream({
+            stream,
+            tenantId,
+        }, (error, response) => {
+            if (error) {
+                reject(error.message);
+                return;
+            }
+            resolve(response.events
+                .map(event_1.getSubscriptionEvent)
+                .filter(event => event !== null));
+        });
+    });
+};
+exports.getStream = getStream;

package/dist/client/subscribe.d.ts

@@ -0,0 +1,3 @@
+import { ClientConfig } from "./config";
+import { Stream } from "./init";
+export declare const sendSubscribe: (includedTopics: string[], excludedTopics: string[], config: ClientConfig, stream: Stream) => Promise<void>;

package/dist/client/subscribe.js

@@ -0,0 +1,40 @@
+"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}`);
+                return;
+            }
+            if (((_b = data.data) === null || _b === void 0 ? void 0 : _b.$case) === "subscribeAck") {
+                clearTimeout(timeout);
+                stream.off("data", fn);
+                resolve();
+                return;
+            }
+        };
+        stream.on("data", fn);
+    });
+};
+exports.sendSubscribe = sendSubscribe;
+const newSubscribeRequest = (includedTopics, excludedTopics) => {
+    return {
+        payload: {
+            $case: "subscribe",
+            subscribe: {
+                excludedTopics,
+                includedTopics,
+            },
+        },
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./client/client";
+export { HandlerFunc, PublishEvent, SubscriptionEvent } from "./client/event";
+export { ClientConfig } from "./client/config";

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client/client"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraym/streams",
-    "version": "0.1.1",
+    "version": "0.1.3",
     "license": "UNLICENSED",
     "homepage": "https://github.com/fraym-work/streams-nodejs",
     "repository": {
@@ -23,20 +23,16 @@
     ],
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
+    "dependencies": {
+        "@fraym/streams-proto": "^5.3.1",
+        "@grpc/grpc-js": "^1.7.2",
+        "uuid": "^9.0.0"
+    },
     "devDependencies": {
         "@becklyn/prettier": "^1.0.2",
-        "@types/google-protobuf": "^3.15.6",
         "@types/uuid": "^8.3.4",
-        "grpc_tools_node_protoc_ts": "^5.3.2",
-        "grpc-tools": "^1.11.2",
         "prettier": "^2.7.1",
         "typescript": "^4.8.4"
     },
-    "prettier": "@becklyn/prettier",
-    "dependencies": {
-        "@grpc/grpc-js": "^1.7.1",
-        "grpc": "^1.24.11",
-        "np": "^7.6.2",
-        "uuid": "^9.0.0"
-    }
+    "prettier": "@becklyn/prettier"
 }