@flowcore/data-pump 0.1.2

package/script/deps/jsr.io/@flowcore/sdk/1.11.4/src/common/command.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQlCommand = exports.Command = void 0;
+/**
+ * Abstract command for executing requests
+ */
+class Command {
+    constructor(input) {
+        /**
+         * Whether the command should retry on failure
+         */
+        Object.defineProperty(this, "retryOnFailure", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        /**
+         * The allowed modes for the command
+         */
+        Object.defineProperty(this, "allowedModes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["apiKey", "bearer"]
+        });
+        /**
+         * The input for the command
+         */
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * The input for the command
+         */
+        this.input = input;
+    }
+    /**
+     * Get the method for the request
+     */
+    getMethod() {
+        return "POST";
+    }
+    /**
+     * Get the path for the request
+     */
+    getPath() {
+        return "/";
+    }
+    /**
+     * Get the body for the request
+     */
+    getBody() {
+        if (this.getMethod() === "GET") {
+            return undefined;
+        }
+        return this.input ?? undefined;
+    }
+    /**
+     * Get the headers for the request
+     */
+    getHeaders() {
+        return typeof this.getBody() === "object"
+            ? {
+                "Content-Type": "application/json",
+            }
+            : {};
+    }
+    /**
+     * Handle the client error
+     */
+    handleClientError(error) {
+        throw error;
+    }
+    /**
+     * Get the request object
+     */
+    // deno-lint-ignore require-await
+    async getRequest(_client) {
+        return {
+            allowedModes: this.allowedModes,
+            body: this.getBody(),
+            headers: this.getHeaders(),
+            baseUrl: this.getBaseUrl(),
+            path: this.getPath(),
+            method: this.getMethod(),
+            parseResponse: this.parseResponse.bind(this),
+            processResponse: this.processResponse.bind(this),
+            handleClientError: this.handleClientError.bind(this),
+            retryOnFailure: this.retryOnFailure,
+        };
+    }
+    /**
+     * Wait for the response
+     */
+    // deno-lint-ignore require-await
+    async processResponse(_client, response) {
+        return response;
+    }
+}
+exports.Command = Command;
+/**
+ * Abstract command for executing GraphQL requests
+ */
+class GraphQlCommand extends Command {
+    constructor() {
+        super(...arguments);
+        /**
+         * The allowed modes for the command
+         */
+        Object.defineProperty(this, "allowedModes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["bearer"]
+        });
+    }
+    /**
+     * Get the base URL for the request
+     */
+    getBaseUrl() {
+        return "https://graph.api.flowcore.io";
+    }
+    /**
+     * Get the path for the request
+     */
+    getPath() {
+        return "/graphql";
+    }
+}
+exports.GraphQlCommand = GraphQlCommand;

package/script/deps/jsr.io/@flowcore/sdk/1.11.4/src/common/flowcore-client.d.ts

@@ -0,0 +1,56 @@
+import type { Command } from "./command.js";
+/**
+ * The options for the bearer token
+ */
+interface ClientOptionsBearer {
+    getBearerToken: () => Promise<string | null> | string | null;
+    apiKeyId?: never;
+    apiKey?: never;
+    retry?: {
+        delay: number;
+        maxRetries: number;
+    } | null;
+}
+/**
+ * The options for the api key
+ */
+interface ClientOptionsApiKey {
+    apiKeyId: string;
+    apiKey: string;
+    getBearerToken?: never;
+    retry?: {
+        delay: number;
+        maxRetries: number;
+    } | null;
+}
+/**
+ * The options for the client
+ */
+export type ClientOptions = ClientOptionsBearer | ClientOptionsApiKey;
+/**
+ * A base client for executing commands
+ */
+export declare class FlowcoreClient {
+    private readonly options;
+    private mode;
+    private baseUrl;
+    constructor(options: ClientOptions);
+    /**
+     * Get the auth header
+     */
+    private getAuthHeader;
+    /**
+     * Execute a command (inner method)
+     */
+    private innerExecute;
+    /**
+     * Override the base URL for all commands
+     */
+    setBaseUrl(baseUrl: string): void;
+    /**
+     * Execute a command
+     */
+    execute<Input, Output>(command: Command<Input, Output>): Promise<Output>;
+}
+export {};
+//# sourceMappingURL=flowcore-client.d.ts.map

package/script/deps/jsr.io/@flowcore/sdk/1.11.4/src/common/flowcore-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowcore-client.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@flowcore/sdk/1.11.4/src/common/flowcore-client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAI3C;;GAEG;AACH,UAAU,mBAAmB;IAC3B,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI,CAAA;IAC5D,QAAQ,CAAC,EAAE,KAAK,CAAA;IAChB,MAAM,CAAC,EAAE,KAAK,CAAA;IACd,KAAK,CAAC,EAAE;QACN,KAAK,EAAE,MAAM,CAAA;QACb,UAAU,EAAE,MAAM,CAAA;KACnB,GAAG,IAAI,CAAA;CACT;AAED;;GAEG;AACH,UAAU,mBAAmB;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,CAAC,EAAE,KAAK,CAAA;IACtB,KAAK,CAAC,EAAE;QACN,KAAK,EAAE,MAAM,CAAA;QACb,UAAU,EAAE,MAAM,CAAA;KACnB,GAAG,IAAI,CAAA;CACT;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,mBAAmB,GAAG,mBAAmB,CAAA;AAErE;;GAEG;AACH,qBAAa,cAAc;IAIb,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,IAAI,CAAqB;IACjC,OAAO,CAAC,OAAO,CAAoB;gBAEN,OAAO,EAAE,aAAa;IAiBnD;;OAEG;YACW,aAAa;IAc3B;;OAEG;YACW,YAAY;IAiE1B;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIjC;;OAEG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;CAGzE"}

package/script/deps/jsr.io/@flowcore/sdk/1.11.4/src/common/flowcore-client.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowcoreClient = void 0;
+const client_error_js_1 = require("../exceptions/client-error.js");
+const command_error_js_1 = require("../exceptions/command-error.js");
+const RETRYABLE_ERROR_CODES = [408, 429, 500, 502, 503, 504];
+/**
+ * A base client for executing commands
+ */
+class FlowcoreClient {
+    constructor(options) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        Object.defineProperty(this, "mode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (this.options.getBearerToken) {
+            this.mode = "bearer";
+        }
+        else if (this.options.apiKeyId && this.options.apiKey) {
+            this.mode = "apiKey";
+        }
+        else {
+            throw new Error("Invalid client options");
+        }
+        if (this.options.retry === undefined) {
+            this.options.retry = {
+                delay: 250,
+                maxRetries: 3,
+            };
+        }
+    }
+    /**
+     * Get the auth header
+     */
+    async getAuthHeader() {
+        if (this.options.getBearerToken) {
+            const bearerToken = await this.options.getBearerToken();
+            if (!bearerToken) {
+                return null;
+            }
+            return `Bearer ${bearerToken}`;
+        }
+        if (this.options.apiKeyId && this.options.apiKey) {
+            return `ApiKey ${this.options.apiKeyId}:${this.options.apiKey}`;
+        }
+        return null;
+    }
+    /**
+     * Execute a command (inner method)
+     */
+    async innerExecute(command, retryCount = 0) {
+        const request = await command.getRequest(this);
+        if (!request.allowedModes.includes(this.mode)) {
+            throw new command_error_js_1.CommandError(command.constructor.name, `Not allowed in "${this.mode}" mode`);
+        }
+        const authHeader = await this.getAuthHeader();
+        const headers = {
+            ...request.headers,
+            ...(authHeader ? { Authorization: authHeader } : {}),
+        };
+        let response;
+        const url = this.baseUrl ? this.baseUrl + request.path : request.baseUrl + request.path;
+        let body;
+        if (typeof request.body === "object") {
+            body = JSON.stringify(request.body);
+        }
+        try {
+            response = await fetch(url, {
+                method: request.method,
+                headers,
+                body,
+            });
+        }
+        catch (error) {
+            if (request.retryOnFailure && this.options.retry && retryCount < this.options.retry.maxRetries) {
+                const delay = this.options.retry.delay;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                return this.innerExecute(command, retryCount + 1);
+            }
+            const message = error instanceof Error ? error.message : "Unknown error";
+            throw new client_error_js_1.ClientError(`Failed to execute command: ${message}`, 0, {
+                command: command.constructor.name,
+                error: error,
+            });
+        }
+        if (!response.ok) {
+            if (request.retryOnFailure &&
+                this.options.retry && RETRYABLE_ERROR_CODES.includes(response.status) &&
+                retryCount < this.options.retry.maxRetries) {
+                const delay = this.options.retry.delay;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                return this.innerExecute(command, retryCount + 1);
+            }
+            const body = await response.json().catch(() => undefined);
+            const commandName = command.constructor.name;
+            const error = new client_error_js_1.ClientError(`${commandName} failed with ${response.status}: ${response.statusText}`, response.status, body);
+            request.handleClientError(error);
+        }
+        const responseBody = await response.json();
+        const parsedBody = await request.parseResponse(responseBody);
+        return request.processResponse(this, parsedBody);
+    }
+    /**
+     * Override the base URL for all commands
+     */
+    setBaseUrl(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    /**
+     * Execute a command
+     */
+    execute(command) {
+        return this.innerExecute(command, 0);
+    }
+}
+exports.FlowcoreClient = FlowcoreClient;

package/script/deps/jsr.io/@flowcore/sdk/1.11.4/src/common/notification-client.d.ts

@@ -0,0 +1,90 @@
+import type { Subject } from "rxjs";
+import { type Logger } from "../utils/logger.js";
+/**
+ * Represents an event notification from the Flowcore system
+ */
+export type NotificationEvent = {
+    pattern: string;
+    data: {
+        tenant: string;
+        eventId: string;
+        dataCoreId: string;
+        flowType: string;
+        eventType: string;
+        validTime: string;
+    };
+};
+/**
+ * Interface for OIDC authentication client
+ */
+export type OidcClient = {
+    getToken: () => Promise<{
+        accessToken: string;
+    }>;
+};
+/**
+ * Configuration options for the NotificationClient
+ */
+export type NotificationClientOptions = {
+    reconnectInterval: number;
+    maxReconnects?: number;
+    maxEvents?: number;
+    logger?: Logger;
+};
+/**
+ * Client for handling WebSocket connections to the Flowcore notification system.
+ * Manages connection lifecycle, authentication, and event handling.
+ */
+export declare class NotificationClient {
+    private readonly observer;
+    private readonly oidcClient;
+    private readonly subscriptionSpec;
+    private url;
+    private webSocket;
+    private options;
+    private logger;
+    private eventCount;
+    private reconnectInterval;
+    private reconnectAttempts;
+    private _isOpen;
+    private _isConnecting;
+    /**
+     * Creates a new NotificationClient instance
+     * @param observer - RxJS Subject for emitting notification events
+     * @param oidcClient - Client for handling OIDC authentication
+     * @param subscriptionSpec - Specification for what notifications to subscribe to
+     * @param options - Configuration options for the client
+     */
+    constructor(observer: Subject<NotificationEvent>, oidcClient: OidcClient, subscriptionSpec: {
+        tenant: string;
+        dataCore: string;
+        flowType?: string;
+        eventType?: string;
+    }, options?: Partial<NotificationClientOptions>);
+    /**
+     * Is the websocket connection open
+     */
+    get isOpen(): boolean;
+    /**
+     * Is the websocket connection currently connecting
+     */
+    get isConnecting(): boolean;
+    /**
+     * Establishes WebSocket connection and sets up event handlers
+     */
+    connect(): Promise<void>;
+    /**
+     * Attempts to reconnect to the WebSocket server using exponential backoff
+     */
+    private attemptReconnect;
+    /**
+     * Closes the WebSocket connection
+     */
+    disconnect(): void;
+    /**
+     * Overrides the base WebSocket URL for testing or different environments
+     * @param url - The new base URL to use
+     */
+    overrideBaseUrl(url: string): void;
+}
+//# sourceMappingURL=notification-client.d.ts.map

package/script/deps/jsr.io/@flowcore/sdk/1.11.4/src/common/notification-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-client.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@flowcore/sdk/1.11.4/src/common/notification-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AASnC,OAAO,EAAiB,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAM/D;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE;QACJ,MAAM,EAAE,MAAM,CAAA;QACd,OAAO,EAAE,MAAM,CAAA;QACf,UAAU,EAAE,MAAM,CAAA;QAClB,QAAQ,EAAE,MAAM,CAAA;QAChB,SAAS,EAAE,MAAM,CAAA;QACjB,SAAS,EAAE,MAAM,CAAA;KAClB,CAAA;CACF,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,OAAO,CAAC;QACtB,WAAW,EAAE,MAAM,CAAA;KACpB,CAAC,CAAA;CACH,CAAA;AAcD;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,iBAAiB,EAAE,MAAM,CAAA;IACzB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAKD;;;GAGG;AACH,qBAAa,kBAAkB;IAmB3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IApBnC,OAAO,CAAC,GAAG,CAA+C;IAC1D,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,OAAO,CAA2B;IAC1C,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,UAAU,CAAI;IACtB,OAAO,CAAC,iBAAiB,CAAQ;IACjC,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,aAAa,CAAiB;IAEtC;;;;;;OAMG;gBAEgB,QAAQ,EAAE,OAAO,CAAC,iBAAiB,CAAC,EACpC,UAAU,EAAE,UAAU,EACtB,gBAAgB,EAAE;QACjC,MAAM,EAAE,MAAM,CAAA;QACd,QAAQ,EAAE,MAAM,CAAA;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,SAAS,CAAC,EAAE,MAAM,CAAA;KACnB,EACD,OAAO,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC;IAU9C;;OAEG;IACH,IAAW,MAAM,IAAI,OAAO,CAE3B;IAED;;OAEG;IACH,IAAW,YAAY,IAAI,OAAO,CAEjC;IAED;;OAEG;IACG,OAAO;IAmIb;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAqBxB;;OAEG;IACH,UAAU;IAMV;;;OAGG;IACI,eAAe,CAAC,GAAG,EAAE,MAAM;CAGnC"}

package/script/deps/jsr.io/@flowcore/sdk/1.11.4/src/common/notification-client.js

@@ -0,0 +1,274 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationClient = void 0;
+const dntShim = __importStar(require("../../../../../../../_dnt.shims.js"));
+const mod_js_1 = require("../mod.js");
+const logger_js_1 = require("../utils/logger.js");
+const flowcore_client_js_1 = require("./flowcore-client.js");
+const node_buffer_1 = require("node:buffer");
+// Maximum reconnection interval in milliseconds
+const MAX_RECONNECT_INTERVAL = 30_000;
+/**
+ * Client for handling WebSocket connections to the Flowcore notification system.
+ * Manages connection lifecycle, authentication, and event handling.
+ */
+class NotificationClient {
+    /**
+     * Creates a new NotificationClient instance
+     * @param observer - RxJS Subject for emitting notification events
+     * @param oidcClient - Client for handling OIDC authentication
+     * @param subscriptionSpec - Specification for what notifications to subscribe to
+     * @param options - Configuration options for the client
+     */
+    constructor(observer, oidcClient, subscriptionSpec, options) {
+        Object.defineProperty(this, "observer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: observer
+        });
+        Object.defineProperty(this, "oidcClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: oidcClient
+        });
+        Object.defineProperty(this, "subscriptionSpec", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: subscriptionSpec
+        });
+        Object.defineProperty(this, "url", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "wss://tenant.api.flowcore.io/notifications"
+        });
+        Object.defineProperty(this, "webSocket", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "eventCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "reconnectInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reconnectAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "_isOpen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_isConnecting", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.options = {
+            reconnectInterval: 1000,
+            ...options,
+        };
+        this.logger = options?.logger ?? logger_js_1.defaultLogger;
+        this.reconnectInterval = options?.reconnectInterval ?? 1000;
+    }
+    /**
+     * Is the websocket connection open
+     */
+    get isOpen() {
+        return this._isOpen;
+    }
+    /**
+     * Is the websocket connection currently connecting
+     */
+    get isConnecting() {
+        return this._isConnecting;
+    }
+    /**
+     * Establishes WebSocket connection and sets up event handlers
+     */
+    async connect() {
+        if (this._isConnecting || this._isOpen) {
+            this.logger.debug("Is already connecting or open");
+            return;
+        }
+        this._isConnecting = true;
+        const token = await this.oidcClient.getToken();
+        const flowcoreClient = new flowcore_client_js_1.FlowcoreClient({
+            getBearerToken: () => Promise.resolve(token.accessToken),
+        });
+        const tenant = await flowcoreClient.execute(new mod_js_1.TenantFetchCommand({
+            tenant: this.subscriptionSpec.tenant,
+        }));
+        const dataCore = await flowcoreClient.execute(new mod_js_1.DataCoreFetchCommand({
+            tenantId: tenant.id,
+            dataCore: this.subscriptionSpec.dataCore,
+        }));
+        let flowType;
+        let eventType;
+        if (this.subscriptionSpec.flowType) {
+            flowType = await flowcoreClient.execute(new mod_js_1.FlowTypeFetchCommand({
+                dataCoreId: dataCore.id,
+                flowType: this.subscriptionSpec.flowType,
+            }));
+            if (this.subscriptionSpec.eventType) {
+                eventType = await flowcoreClient.execute(new mod_js_1.EventTypeFetchCommand({
+                    flowTypeId: flowType?.id,
+                    eventType: this.subscriptionSpec.eventType,
+                }));
+            }
+        }
+        this.webSocket = new dntShim.WebSocket(`${this.url}?token=${encodeURIComponent(token.accessToken)}`);
+        this.webSocket.onopen = () => {
+            this._isOpen = true;
+            this._isConnecting = false;
+            this.logger.info("WebSocket connection opened.");
+            this.reconnectInterval = this.options.reconnectInterval;
+            this.reconnectAttempts = 0;
+            this.webSocket.send(JSON.stringify({
+                tenant: this.subscriptionSpec.tenant,
+                dataCoreId: dataCore.id,
+                flowTypeId: flowType?.id,
+                eventTypeId: eventType?.id,
+            }));
+        };
+        this.webSocket.onmessage = (event) => {
+            let parsedData;
+            if (event.data instanceof ArrayBuffer) {
+                parsedData = new TextDecoder().decode(event.data);
+            }
+            else if (node_buffer_1.Buffer.isBuffer(event.data)) {
+                parsedData = event.data.toString();
+            }
+            else if (Array.isArray(event.data)) {
+                // Handle Buffer arrays by concatenating them
+                parsedData = node_buffer_1.Buffer.concat(event.data).toString();
+            }
+            else {
+                parsedData = event.data;
+            }
+            const data = JSON.parse(parsedData);
+            if (data.type === "validation") {
+                this.logger.error(`Bad request: ${data.summary} - ${data.message} - ${data.found} - ${data.errors}`);
+                return;
+            }
+            const parsed = JSON.parse(data.message);
+            this.logger.debug(`Received event: ${parsed.pattern}`);
+            this.observer.next({
+                pattern: parsed.pattern,
+                data: {
+                    tenant: parsed.data.tenantId,
+                    eventId: parsed.data.eventId,
+                    dataCoreId: parsed.data.dataCore,
+                    flowType: parsed.data.aggregator,
+                    eventType: parsed.data.eventType,
+                    validTime: parsed.data.validTime,
+                },
+            });
+            this.eventCount++;
+            if (this.options.maxEvents && this.options.maxEvents <= this.eventCount) {
+                this.observer.complete();
+                this.eventCount = 0;
+                this.webSocket.close(1000, "Max events received");
+            }
+        };
+        this.webSocket.onclose = (event) => {
+            this._isOpen = false;
+            this.logger.info(`Connection closed: Code [${event.code}], Reason: ${event.reason}`);
+            if (![1000].includes(event.code)) {
+                this.attemptReconnect();
+                return;
+            }
+            this._isConnecting = false;
+            this.observer.complete();
+        };
+        this.webSocket.onerror = (error) => {
+            this.logger.error(`WebSocket encountered error: ${error}`);
+            this.observer.error(error);
+            this.webSocket.close();
+        };
+    }
+    /**
+     * Attempts to reconnect to the WebSocket server using exponential backoff
+     */
+    attemptReconnect() {
+        if (this.options.maxReconnects && this.reconnectAttempts >= this.options.maxReconnects) {
+            this.logger.error(`Max reconnect attempts ${this.reconnectAttempts}/${this.options.maxReconnects} reached. Giving up.`);
+            return;
+        }
+        this.reconnectAttempts++;
+        this._isConnecting = true;
+        this.logger.info(`Attempting reconnection ${this.reconnectAttempts}${this.options.maxReconnects ? `/${this.options.maxReconnects}` : ""} in ${this.reconnectInterval} ms...`);
+        setTimeout(() => {
+            this.connect();
+        }, this.reconnectInterval);
+        this.reconnectInterval = Math.min(MAX_RECONNECT_INTERVAL, this.reconnectInterval * 2);
+    }
+    /**
+     * Closes the WebSocket connection
+     */
+    disconnect() {
+        if (this.webSocket) {
+            this.webSocket.close(1000, "Disconnected by user");
+        }
+    }
+    /**
+     * Overrides the base WebSocket URL for testing or different environments
+     * @param url - The new base URL to use
+     */
+    overrideBaseUrl(url) {
+        this.url = url;
+    }
+}
+exports.NotificationClient = NotificationClient;