@konplit-services/common 1.1.0 → 1.2.1

package/build/events/base-events/base-event-response-publisher.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Publisher Module
+ *
+ * This module defines an abstract `Publisher` class for publishing events to a NATS JetStream.
+ * It ensures that the required stream exists before publishing events.
+ *
+ * @module Publisher
+ */
+import { NatsConnection } from "nats";
+/**
+ * Event Interface
+ *
+ * Represents an event that will be published to a NATS stream.
+ *
+ * @interface
+ */
+interface Event {
+    subject: string;
+    data: any;
+}
+/**
+ * Publisher Abstract Class
+ *
+ * Abstract class for publishing events to a NATS JetStream.
+ * Subclasses should implement the specific subject, streamEvents, and stream properties.
+ *
+ * @abstract
+ * @template T - The type of event to be published
+ */
+export declare abstract class ResponsePublisher<T extends Event> {
+    private nc;
+    protected jc: import("nats").Codec<unknown>;
+    /**
+     * The subject associated with the event.
+     * @abstract
+     */
+    abstract subject: T["subject"];
+    /**
+     * Constructor for the Publisher class.
+     *
+     * @param {JetStreamClient} client - The NATS JetStream client
+     */
+    constructor(nc: NatsConnection);
+    /**
+     * Sends a request to another service and waits for a reply.
+     *
+     * @param {T["data"]} data - The data to be sent in the request
+     * @param {number} timeout - The timeout duration to wait for a response
+     * @returns {Promise<any>} - Resolves with the reply data from the responding service
+     */
+    request(data: T["data"], timeout?: number): Promise<any>;
+}
+export {};

package/build/events/base-events/base-event-response-publisher.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Publisher Module
+ *
+ * This module defines an abstract `Publisher` class for publishing events to a NATS JetStream.
+ * It ensures that the required stream exists before publishing events.
+ *
+ * @module Publisher
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponsePublisher = void 0;
+const nats_1 = require("nats");
+/**
+ * Publisher Abstract Class
+ *
+ * Abstract class for publishing events to a NATS JetStream.
+ * Subclasses should implement the specific subject, streamEvents, and stream properties.
+ *
+ * @abstract
+ * @template T - The type of event to be published
+ */
+class ResponsePublisher {
+    /**
+     * Constructor for the Publisher class.
+     *
+     * @param {JetStreamClient} client - The NATS JetStream client
+     */
+    constructor(nc) {
+        this.jc = (0, nats_1.JSONCodec)();
+        this.nc = nc;
+    }
+    /**
+     * Sends a request to another service and waits for a reply.
+     *
+     * @param {T["data"]} data - The data to be sent in the request
+     * @param {number} timeout - The timeout duration to wait for a response
+     * @returns {Promise<any>} - Resolves with the reply data from the responding service
+     */
+    request(data, timeout = 1000 * 60 * 5) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Send request and wait for the response
+                const response = yield this.nc.request(this.subject, this.jc.encode(data), { timeout } // Timeout for the response
+                );
+                if (!response) {
+                    throw new Error("Failed to get Response");
+                }
+                const replyData = this.jc.decode(response.data);
+                console.log("Received Reply:", replyData);
+                return replyData;
+            }
+            catch (err) {
+                console.error("Error sending request:", err);
+                throw err;
+            }
+        });
+    }
+}
+exports.ResponsePublisher = ResponsePublisher;

package/build/events/base-events/base-events.listener.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Listener Module
+ *
+ * This module defines an abstract `Listener` class for listening to events from a NATS JetStream.
+ * It ensures that the required stream and consumer exist before consuming events.
+ *
+ * @module Listener
+ */
+import { JetStreamClient, JsMsg, NatsConnection, Msg } from "nats";
+import { StreamEvent, StreamName } from "../subjects";
+/**
+ * Event Interface
+ *
+ * Represents an event that will be consumed from a NATS stream.
+ *
+ * @interface
+ */
+interface Event {
+    subject: string;
+    streamEvents: StreamEvent;
+    streamName: StreamName;
+    data: any;
+}
+/**
+ * Listener Abstract Class
+ *
+ * Abstract class for consuming events from a NATS JetStream.
+ * Subclasses should implement the specific subject, streamEvents, stream, and durableName properties.
+ *
+ * @abstract
+ * @template T - The type of event to be consumed
+ */
+export declare abstract class Listener<T extends Event> {
+    private client;
+    private nc?;
+    private jc;
+    /**
+     * The subject associated with the event.
+     * @abstract
+     */
+    abstract subject: T["subject"];
+    /**
+     * The stream events associated with the event.
+     * @abstract
+     */
+    abstract streamEvents: T["streamEvents"];
+    /**
+     * The stream name associated with the event.
+     * @abstract
+     */
+    abstract stream: T["streamName"];
+    /**
+     * The durable name for the consumer.
+     * @abstract
+     */
+    abstract durableName: string;
+    /**
+     * Acknowledgment wait time of 5 seconds before retrying.
+     * @protected
+     */
+    protected ackWait: number;
+    /**
+     * Handles the incoming message.
+     * @abstract
+     * @param {T["data"]} data - The decoded data from the message
+     * @param {JsMsg} msg - The raw NATS message
+     */
+    abstract onMessage(data: T["data"], msg: JsMsg): void;
+    /**
+     * Handles the incoming message.
+     * @abstract
+     * @param {T["data"]} data - The decoded data from the message
+     * @param {JsMsg} msg - The raw NATS message
+     */
+    abstract onMessageResponse(data: T["data"], msg: Msg): any;
+    /**
+     * Constructor for the Listener class.
+     *
+     * @param {JetStreamClient} client - The NATS JetStream client
+     */
+    constructor(client: JetStreamClient, nc?: NatsConnection);
+    /**
+     * Sets up the listener by ensuring the stream and consumer exist,
+     * then starts consuming messages.
+     *
+     * @returns {Promise<void>} - Resolves when the listener is set up and consuming messages
+     */
+    listen(): Promise<void>;
+    listenForRequests(): Promise<void>;
+    /**
+     * Ensures the stream exists in the NATS JetStream.
+     * Creates the stream if it does not exist.
+     *
+     * @private
+     * @param {StreamName} streamName - The name of the stream
+     * @param {string[]} subjects - The subjects associated with the stream
+     * @returns {Promise<void>} - Resolves when the stream is ensured to exist
+     */
+    private ensureStream;
+    /**
+     * Ensures the consumer exists in the NATS JetStream.
+     * Creates the consumer if it does not exist.
+     *
+     * @private
+     * @param {StreamName} streamName - The name of the stream
+     * @param {string} durableName - The durable name of the consumer
+     * @param {string} subject - The subject to filter for the consumer
+     * @returns {Promise<void>} - Resolves when the consumer is ensured to exist
+     */
+    private ensureConsumer;
+}
+export {};

package/build/events/base-events/base-events.listener.js

@@ -0,0 +1,207 @@
+"use strict";
+/**
+ * Listener Module
+ *
+ * This module defines an abstract `Listener` class for listening to events from a NATS JetStream.
+ * It ensures that the required stream and consumer exist before consuming events.
+ *
+ * @module Listener
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Listener = void 0;
+const nats_1 = require("nats");
+const nat_error_codes_1 = require("../../util/lib/nats/nat-error-codes");
+/**
+ * Listener Abstract Class
+ *
+ * Abstract class for consuming events from a NATS JetStream.
+ * Subclasses should implement the specific subject, streamEvents, stream, and durableName properties.
+ *
+ * @abstract
+ * @template T - The type of event to be consumed
+ */
+class Listener {
+    /**
+     * Constructor for the Listener class.
+     *
+     * @param {JetStreamClient} client - The NATS JetStream client
+     */
+    constructor(client, nc) {
+        this.jc = (0, nats_1.JSONCodec)();
+        /**
+         * Acknowledgment wait time of 5 seconds before retrying.
+         * @protected
+         */
+        this.ackWait = (0, nats_1.nanos)(5 * 60 * 1000); // acknowledge time of  5 minutes before retry
+        this.client = client;
+        this.nc = nc;
+    }
+    /**
+     * Sets up the listener by ensuring the stream and consumer exist,
+     * then starts consuming messages.
+     *
+     * @returns {Promise<void>} - Resolves when the listener is set up and consuming messages
+     */
+    listen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Ensure the stream exists
+                yield this.ensureStream(this.stream, [this.streamEvents]);
+                // Ensure the consumer exists
+                yield this.ensureConsumer(this.stream, this.durableName, this.subject);
+                const consumer = yield this.client.consumers.get(this.stream, this.durableName);
+                yield consumer.consume({
+                    max_messages: 1,
+                    callback: (message) => {
+                        console.log("sequence number", message.seq);
+                        const data = this.jc.decode(message.data);
+                        this.onMessage(data, message);
+                    },
+                });
+            }
+            catch (err) {
+                console.error("Error setting up listener:", err);
+            }
+        });
+    }
+    listenForRequests() {
+        var _a, e_1, _b, _c;
+        var _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const subscription = (_d = this.nc) === null || _d === void 0 ? void 0 : _d.subscribe(this.subject);
+            try {
+                for (var _e = true, subscription_1 = __asyncValues(subscription), subscription_1_1; subscription_1_1 = yield subscription_1.next(), _a = subscription_1_1.done, !_a;) {
+                    _c = subscription_1_1.value;
+                    _e = false;
+                    try {
+                        const msg = _c;
+                        // Decode the request data
+                        const decodedRequest = this.jc.decode(msg.data);
+                        console.log("Received Request:", decodedRequest);
+                        const response = yield this.onMessageResponse(decodedRequest, msg);
+                        // Send a reply back
+                        msg.respond(this.jc.encode({ data: response }));
+                    }
+                    finally {
+                        _e = true;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_e && !_a && (_b = subscription_1.return)) yield _b.call(subscription_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    /**
+     * Ensures the stream exists in the NATS JetStream.
+     * Creates the stream if it does not exist.
+     *
+     * @private
+     * @param {StreamName} streamName - The name of the stream
+     * @param {string[]} subjects - The subjects associated with the stream
+     * @returns {Promise<void>} - Resolves when the stream is ensured to exist
+     */
+    ensureStream(streamName, subjects) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const jsm = yield this.client.jetstreamManager();
+                yield jsm.streams.info(streamName);
+                console.log(`Stream '${streamName}' already exists`);
+            }
+            catch (err) {
+                console.log("Stream info retrieval error:", err.api_error);
+                if (((_a = err === null || err === void 0 ? void 0 : err.api_error) === null || _a === void 0 ? void 0 : _a.code) === 404 &&
+                    ((_b = err === null || err === void 0 ? void 0 : err.api_error) === null || _b === void 0 ? void 0 : _b.err_code) === nat_error_codes_1.NATS_ERROR.STREAM_NOT_FOUND) {
+                    try {
+                        const jsm = yield this.client.jetstreamManager();
+                        const streamConfig = {
+                            name: streamName,
+                            subjects,
+                            storage: nats_1.StorageType.File,
+                            max_consumers: -1,
+                            retention: nats_1.RetentionPolicy.Limits,
+                            max_msgs: 10000,
+                            max_bytes: 1 * 1024 * 1024 * 1024,
+                            max_age: (0, nats_1.nanos)(14 * 24 * 3600 * 1000), //2 weeks in milliseconds
+                        };
+                        yield jsm.streams.add(streamConfig);
+                        console.log(`Stream '${streamName}' created`);
+                    }
+                    catch (addErr) {
+                        console.error("Error creating stream:");
+                        throw addErr;
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+    /**
+     * Ensures the consumer exists in the NATS JetStream.
+     * Creates the consumer if it does not exist.
+     *
+     * @private
+     * @param {StreamName} streamName - The name of the stream
+     * @param {string} durableName - The durable name of the consumer
+     * @param {string} subject - The subject to filter for the consumer
+     * @returns {Promise<void>} - Resolves when the consumer is ensured to exist
+     */
+    ensureConsumer(streamName, durableName, subject) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const jsm = yield this.client.jetstreamManager();
+            try {
+                yield jsm.consumers.info(streamName, durableName);
+                console.log(`Consumer '${durableName}' already exists`);
+            }
+            catch (err) {
+                if (((_a = err === null || err === void 0 ? void 0 : err.api_error) === null || _a === void 0 ? void 0 : _a.code) === 404 &&
+                    ((_b = err === null || err === void 0 ? void 0 : err.api_error) === null || _b === void 0 ? void 0 : _b.err_code) === nat_error_codes_1.NATS_ERROR.CONSUMER_NOT_FOUND) {
+                    try {
+                        const consumerConfig = {
+                            durable_name: durableName,
+                            ack_policy: nats_1.AckPolicy.Explicit,
+                            filter_subject: subject,
+                            deliver_policy: nats_1.DeliverPolicy.All,
+                            ack_wait: this.ackWait,
+                            max_deliver: 576, //5 minutes * 576 equals two days assuming the systme
+                        };
+                        yield jsm.consumers.add(streamName, consumerConfig);
+                        console.log(`Consumer '${durableName}' created`);
+                    }
+                    catch (addConsumerError) {
+                        console.error("Error creating stream:", addConsumerError);
+                        throw addConsumerError;
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+}
+exports.Listener = Listener;

package/build/events/base-events/base-events.publisher.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Publisher Module
+ *
+ * This module defines an abstract `Publisher` class for publishing events to a NATS JetStream.
+ * It ensures that the required stream exists before publishing events.
+ *
+ * @module Publisher
+ */
+import { JetStreamClient, NatsConnection } from "nats";
+import { StreamEvent, StreamName } from "../subjects";
+/**
+ * Event Interface
+ *
+ * Represents an event that will be published to a NATS stream.
+ *
+ * @interface
+ */
+interface Event {
+    subject: string;
+    streamEvents: StreamEvent;
+    streamName: StreamName;
+    data: any;
+}
+/**
+ * Publisher Abstract Class
+ *
+ * Abstract class for publishing events to a NATS JetStream.
+ * Subclasses should implement the specific subject, streamEvents, and stream properties.
+ *
+ * @abstract
+ * @template T - The type of event to be published
+ */
+export declare abstract class Publisher<T extends Event> {
+    private client;
+    private nc?;
+    private jc;
+    /**
+     * The subject associated with the event.
+     * @abstract
+     */
+    abstract subject: T["subject"];
+    /**
+     * The stream events associated with the event.
+     * @abstract
+     */
+    abstract streamEvents: T["streamEvents"];
+    /**
+     * The stream name associated with the event.
+     * @abstract
+     */
+    abstract stream: T["streamName"];
+    /**
+     * Constructor for the Publisher class.
+     *
+     * @param {JetStreamClient} client - The NATS JetStream client
+     */
+    constructor(client: JetStreamClient, nc?: NatsConnection);
+    /**
+     * Publishes data to the NATS JetStream.
+     *
+     * @param {T["data"]} data - The data to be published
+     * @returns {Promise<void>} - Resolves when the data is published successfully
+     */
+    publish(data: T["data"]): Promise<void>;
+    /**
+     * Sends a request to another service and waits for a reply.
+     *
+     * @param {T["data"]} data - The data to be sent in the request
+     * @param {number} timeout - The timeout duration to wait for a response
+     * @returns {Promise<any>} - Resolves with the reply data from the responding service
+     */
+    request(data: T["data"], timeout?: number): Promise<any>;
+    /**
+     * Ensures the stream exists in the NATS JetStream.
+     * Creates the stream if it does not exist.
+     *
+     * @private
+     * @param {StreamName} streamName - The name of the stream
+     * @param {string[]} subjects - The subjects associated with the stream
+     * @returns {Promise<void>} - Resolves when the stream is ensured to exist
+     */
+    private ensureStream;
+}
+export {};

package/build/events/base-events/base-events.publisher.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * Publisher Module
+ *
+ * This module defines an abstract `Publisher` class for publishing events to a NATS JetStream.
+ * It ensures that the required stream exists before publishing events.
+ *
+ * @module Publisher
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Publisher = void 0;
+const nats_1 = require("nats");
+const nat_error_codes_1 = require("../../util/lib/nats/nat-error-codes");
+/**
+ * Publisher Abstract Class
+ *
+ * Abstract class for publishing events to a NATS JetStream.
+ * Subclasses should implement the specific subject, streamEvents, and stream properties.
+ *
+ * @abstract
+ * @template T - The type of event to be published
+ */
+class Publisher {
+    /**
+     * Constructor for the Publisher class.
+     *
+     * @param {JetStreamClient} client - The NATS JetStream client
+     */
+    constructor(client, nc) {
+        this.jc = (0, nats_1.JSONCodec)();
+        this.client = client;
+        this.nc = nc;
+    }
+    /**
+     * Publishes data to the NATS JetStream.
+     *
+     * @param {T["data"]} data - The data to be published
+     * @returns {Promise<void>} - Resolves when the data is published successfully
+     */
+    publish(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    // Ensure the stream exists
+                    yield this.ensureStream(this.stream, [this.streamEvents]);
+                    yield this.client.publish(this.subject, this.jc.encode(data));
+                    console.log("Event Published");
+                    resolve();
+                }
+                catch (err) {
+                    console.error("Error publishing event:", err);
+                    reject(err);
+                }
+            }));
+        });
+    }
+    /**
+     * Sends a request to another service and waits for a reply.
+     *
+     * @param {T["data"]} data - The data to be sent in the request
+     * @param {number} timeout - The timeout duration to wait for a response
+     * @returns {Promise<any>} - Resolves with the reply data from the responding service
+     */
+    request(data, timeout = 5000) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Send request and wait for the response
+                const response = yield ((_a = this.nc) === null || _a === void 0 ? void 0 : _a.request(this.subject, this.jc.encode(data), { timeout } // Timeout for the response
+                ));
+                if (!response) {
+                    throw new Error("Failed to get Response");
+                }
+                const replyData = this.jc.decode(response.data);
+                console.log("Received Reply:", replyData);
+                return replyData;
+            }
+            catch (err) {
+                console.error("Error sending request:", err);
+                throw err;
+            }
+        });
+    }
+    /**
+     * Ensures the stream exists in the NATS JetStream.
+     * Creates the stream if it does not exist.
+     *
+     * @private
+     * @param {StreamName} streamName - The name of the stream
+     * @param {string[]} subjects - The subjects associated with the stream
+     * @returns {Promise<void>} - Resolves when the stream is ensured to exist
+     */
+    ensureStream(streamName, subjects) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const jsm = yield this.client.jetstreamManager();
+                yield jsm.streams.info(streamName);
+                console.log(`Stream '${streamName}' already exists`);
+            }
+            catch (err) {
+                console.log("Stream info retrieval error:", err.api_error);
+                if (((_a = err === null || err === void 0 ? void 0 : err.api_error) === null || _a === void 0 ? void 0 : _a.code) === 404 &&
+                    ((_b = err === null || err === void 0 ? void 0 : err.api_error) === null || _b === void 0 ? void 0 : _b.err_code) === nat_error_codes_1.NATS_ERROR.STREAM_NOT_FOUND) {
+                    try {
+                        const jsm = yield this.client.jetstreamManager();
+                        const streamConfig = {
+                            name: streamName,
+                            subjects,
+                            storage: nats_1.StorageType.File,
+                            retention: nats_1.RetentionPolicy.Limits,
+                            max_consumers: -1,
+                            max_msgs: 10000,
+                            max_bytes: 5 * 1024 * 1024 * 1024,
+                            max_age: (0, nats_1.nanos)(14 * 24 * 3600 * 1000), //2 weeks in milliseconds
+                        };
+                        yield jsm.streams.add(streamConfig);
+                        console.log(`Stream '${streamName}' created`);
+                    }
+                    catch (addErr) {
+                        console.error("Error creating stream:");
+                        throw addErr;
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+        });
+    }
+}
+exports.Publisher = Publisher;

package/build/events/base-events/event.d.ts

@@ -0,0 +1,8 @@
+export declare enum EventResponseStatus {
+    Failed = "Failed",
+    Success = "Success"
+}
+export interface EventResponseData {
+    status: EventResponseStatus;
+    data: any;
+}

package/build/events/base-events/event.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventResponseStatus = void 0;
+var EventResponseStatus;
+(function (EventResponseStatus) {
+    EventResponseStatus["Failed"] = "Failed";
+    EventResponseStatus["Success"] = "Success";
+})(EventResponseStatus = exports.EventResponseStatus || (exports.EventResponseStatus = {}));