@flowcore/data-pump 0.11.0 → 0.12.0

package/esm/lib/data-pump.js

@@ -1,437 +0,0 @@
-import { DataCoreFetchCommand, EventsFetchCommand, EventsFetchTimeBucketsByNamesCommand, } from "../deps/jsr.io/@flowcore/sdk/1.26.3/src/mod.js";
-import { TimeUuid } from "../deps/jsr.io/@flowcore/time-uuid/0.1.2/src/mod.js";
-import { format, startOfHour } from "date-fns";
-import { utc } from "@date-fns/utc";
-var FlowcoreBufferEventStatus;
-(function (FlowcoreBufferEventStatus) {
-    FlowcoreBufferEventStatus["OPEN"] = "open";
-    FlowcoreBufferEventStatus["DELIVERED"] = "delivered";
-})(FlowcoreBufferEventStatus || (FlowcoreBufferEventStatus = {}));
-export class DataPump {
-    constructor(options) {
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: options
-        });
-        Object.defineProperty(this, "logger", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "state", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_timeBuckets", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "buffer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "bufferWaiter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "waiter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-        Object.defineProperty(this, "running", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "notifierAbortController", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "dataCoreId", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "stopAt", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.state = {
-            timeBucket: this.getNowTimeBucket(),
-        };
-        this.logger = options.logger ?? undefined;
-    }
-    async start() {
-        if (this.running) {
-            return;
-        }
-        await this.updateTimeBuckets();
-        if (this.options.stopAt) {
-            const timeBucket = format(startOfHour(utc(this.options.stopAt)), "yyyyMMddHH0000");
-            const lastTimeBucket = this.getClosestTimeBucket(timeBucket, true);
-            const lastEventId = TimeUuid.fromDate(this.options.stopAt).toString();
-            this.stopAt = {
-                timeBucket: lastTimeBucket,
-                eventId: lastEventId,
-                eventBufferReached: false,
-            };
-            this.logger?.debug("stop at", `${this.stopAt.timeBucket} @ ${this.stopAt.eventId}`);
-        }
-        const newState = await this.options.stateManager.getState();
-        if (!newState) {
-            this.state.timeBucket = this.getClosestTimeBucket(this.getNowTimeBucket());
-            this.state.eventId = TimeUuid.now().toString();
-        }
-        else {
-            this.state.timeBucket = this.getClosestTimeBucket(newState.timeBucket);
-            this.state.eventId = newState.eventId;
-        }
-        if (this.stopAt?.timeBucket && this.state.timeBucket > this.stopAt.timeBucket) {
-            throw new Error("Stop at time is lower than current state");
-        }
-        this.running = true;
-        this.logger?.debug("Starting event buffer loop");
-        this.eventBufferLoop()
-            .then(() => this.logger?.debug("Event buffer loop stopped"))
-            .catch((error) => this.logger?.error("Error in event buffer loop", { error }))
-            .finally(() => this.stop());
-        if (this.options.processor) {
-            this.logger?.debug("Starting processor");
-            this.proceccor()
-                .then(() => this.logger?.debug("Processor stopped"))
-                .catch((error) => this.logger?.error("Error in processor", { error }))
-                .finally(() => this.stop());
-        }
-    }
-    stop() {
-        if (!this.running) {
-            return;
-        }
-        this.logger?.debug("Stopping data pump");
-        this.running = false;
-        this.notifierAbortController?.abort("stopping");
-        this.bufferWaiter?.(true);
-        this.waiter?.(true);
-    }
-    async proceccor() {
-        if (!this.options.processor) {
-            throw new Error("Processor not set");
-        }
-        while (this.running) {
-            try {
-                const events = await this.pullInner(this.options.processor.concurrency);
-                if (!this.running) {
-                    break;
-                }
-                const success = await this.options.processor.onEvents(events);
-                if (success) {
-                    await this.acknowledgeInner(events.map((event) => event.eventId));
-                }
-            }
-            catch (error) {
-                this.logger?.error("Error in processor", { error });
-                await this.stop();
-            }
-        }
-    }
-    async eventBufferLoop() {
-        // Stop buffer loop if we are not running
-        if (!this.running) {
-            return;
-        }
-        if (this.stopAt?.eventBufferReached) {
-            await new Promise((resolve) => setTimeout(resolve, 10_000));
-            return this.eventBufferLoop();
-        }
-        // Buffer is full, wait for some space
-        if (this.buffer.length >= this.options.buffer.size - this.options.buffer.threshold && this.running) {
-            this.logger?.debug("Buffer is full, waiting for some space");
-            await this.waitForBufferThreshold();
-        }
-        // Stop buffer loop if we are not running
-        if (!this.running) {
-            return;
-        }
-        // How many events should we fetch
-        const eventsToFetch = this.options.buffer.size - this.buffer.length;
-        this.logger?.info(`fetching events from ${this.state.timeBucket} @ ${this.state.eventId ?? "-"}`);
-        const timeStart = Date.now();
-        const command = new EventsFetchCommand({
-            tenant: this.options.dataSource.tenant,
-            dataCoreId: await this.getDataCoreId(),
-            flowType: this.options.dataSource.flowType,
-            eventTypes: this.options.dataSource.eventTypes,
-            timeBucket: this.state.timeBucket,
-            afterEventId: this.state.eventId,
-            pageSize: eventsToFetch,
-            toEventId: this.stopAt?.eventId,
-        });
-        const result = await this.options.flowcoreClient.execute(command);
-        const time = Date.now() - timeStart;
-        // Stop buffer loop if we are not running
-        if (!this.running) {
-            return;
-        }
-        const events = result.events.map((event) => ({
-            event,
-            status: FlowcoreBufferEventStatus.OPEN,
-            deliveryCount: 0,
-            deliveryTime: 0,
-            deliveryId: "",
-        }));
-        this.buffer.push(...events);
-        // Check if we have a waiter and if we have events, notify the waiter
-        events.length && this.waiter?.();
-        this.logger?.info(`Got ${result.events.length} events from ${this.state.timeBucket} @ ${this.state.eventId ?? "-"} in ${time}ms. Buffer size ${this.buffer.length}`);
-        // Update buffer state
-        this.state.eventId = result.events[result.events.length - 1]?.eventId ?? this.state.eventId;
-        // If we don't have a next cursor move to next time bucket
-        if (!result.nextCursor) {
-            // Check if we reached the stop at
-            if (this.state.timeBucket === this.stopAt?.timeBucket) {
-                this.stopAt.eventBufferReached = true;
-                this.logger?.debug("Reached stop at");
-                this.waiter?.();
-                return this.eventBufferLoop();
-            }
-            // Get next time bucket
-            const nextTimeBucketIndex = this.timeBuckets.indexOf(this.state.timeBucket) + 1;
-            // There is no next time bucket
-            if (!this.timeBuckets[nextTimeBucketIndex]) {
-                if (result.events.length) {
-                    // If we got events, we can try to get more one more time
-                    this.logger?.debug("Try to get more events");
-                }
-                else {
-                    // If we didn't get events, we wait for notifier
-                    await this.waitForNotifier();
-                }
-            }
-            else {
-                // Set next time bucket
-                this.state.timeBucket = this.timeBuckets[nextTimeBucketIndex];
-            }
-        }
-        return this.eventBufferLoop();
-    }
-    async reOpen(eventIds, deliveryId) {
-        if (!eventIds.length) {
-            return;
-        }
-        const failedEvents = [];
-        const reopenedEvents = [];
-        let lastEvent;
-        this.buffer = this.buffer.filter((event) => {
-            if (event.deliveryId === deliveryId && this.options.buffer.maxRedeliveryCount > -1 &&
-                event.deliveryCount > this.options.buffer.maxRedeliveryCount) {
-                failedEvents.push(event.event);
-                lastEvent = event.event;
-                return false;
-            }
-            if (event.deliveryId === deliveryId && eventIds.includes(event.event.eventId)) {
-                event.status = FlowcoreBufferEventStatus.OPEN;
-                event.deliveryId = "";
-                reopenedEvents.push(event.event);
-            }
-            return true;
-        });
-        if (reopenedEvents.length) {
-            this.waiter?.();
-        }
-        if (this.bufferWaiter && this.buffer.length <= this.options.buffer.size - this.options.buffer.threshold) {
-            this.bufferWaiter();
-        }
-        if (failedEvents.length) {
-            await this.options.processor?.onFailedEvents?.(failedEvents);
-            await this.updateState(lastEvent?.eventId);
-        }
-    }
-    updateState(eventId) {
-        const firstEvent = this.buffer[0];
-        if (!firstEvent) {
-            if (eventId) {
-                const date = TimeUuid.fromString(eventId).getDate();
-                const timeBucket = format(startOfHour(utc(date)), "yyyyMMddHH0000");
-                return this.options.stateManager.setState?.({ timeBucket, eventId });
-            }
-            return;
-        }
-        const timeUuid = TimeUuid.fromString(firstEvent.event.eventId);
-        const timeBucket = firstEvent.event.timeBucket;
-        return this.options.stateManager.setState?.({ timeBucket, eventId: timeUuid.getBefore().toString() });
-    }
-    get timeBuckets() {
-        const timeBucketNow = this.getNowTimeBucket();
-        if (this._timeBuckets[this._timeBuckets.length - 1] !== timeBucketNow) {
-            return [...this._timeBuckets, timeBucketNow];
-        }
-        return this._timeBuckets;
-    }
-    getClosestTimeBucket(timeBucket, getBefore = false) {
-        if (!timeBucket.match(/^\d{14}$/)) {
-            throw new Error(`Invalid timebucket: ${timeBucket}`);
-        }
-        if (getBefore) {
-            return (this.timeBuckets.findLast((t) => Number.parseFloat(t) <= Number.parseFloat(timeBucket)) ??
-                this.timeBuckets[this.timeBuckets.length - 1]);
-        }
-        return (this.timeBuckets.find((t) => Number.parseFloat(t) >= Number.parseFloat(timeBucket)) ??
-            this.timeBuckets[this.timeBuckets.length - 1]);
-    }
-    async updateTimeBuckets() {
-        this._timeBuckets = [];
-        let first = true;
-        let cursor;
-        while (cursor !== undefined || first) {
-            first = false;
-            const command = new EventsFetchTimeBucketsByNamesCommand({
-                tenant: this.options.dataSource.tenant,
-                dataCoreId: await this.getDataCoreId(),
-                flowType: this.options.dataSource.flowType,
-                eventTypes: this.options.dataSource.eventTypes,
-                pageSize: 10_000,
-            });
-            // sdkCommandCount.labels("EventsFetchTimeBucketsByNamesCommand").inc(1)
-            const result = await this.options.flowcoreClient.execute(command);
-            this._timeBuckets.push(...result.timeBuckets);
-            cursor = result.nextCursor;
-        }
-    }
-    async pullInner(amount) {
-        if (!this.running) {
-            throw new Error("Data pump not running");
-        }
-        if (this.stopAt?.eventBufferReached && this.buffer.length === 0) {
-            await this.options.processor?.onDone?.();
-            await this.stop();
-            return [];
-        }
-        const deliveryId = crypto.randomUUID();
-        const events = [];
-        for (const event of this.buffer) {
-            if (event.status === FlowcoreBufferEventStatus.OPEN) {
-                event.status = FlowcoreBufferEventStatus.DELIVERED;
-                event.deliveryCount++;
-                event.deliveryId = deliveryId;
-                events.push(event.event);
-                if (events.length >= amount) {
-                    break;
-                }
-            }
-        }
-        if (!events.length) {
-            await this.waitForEvents();
-            if (!this.running) {
-                return [];
-            }
-            return this.pullInner(amount);
-        }
-        setTimeout(() => {
-            this.reOpen(events.map((event) => event.eventId), deliveryId);
-        }, this.options.buffer.achknowledgeTimeoutMs);
-        return events;
-    }
-    async acknowledgeInner(eventIds) {
-        if (!eventIds.length) {
-            return;
-        }
-        // this.logger.info("Acknowledging events", { events: eventIds.length })
-        const lastEventInBuffer = this.buffer[this.buffer.length - 1];
-        this.buffer = this.buffer.filter((event) => {
-            if (eventIds.includes(event.event.eventId)) {
-                return false;
-            }
-            return true;
-        });
-        if (this.bufferWaiter && this.buffer.length <= this.options.buffer.size - this.options.buffer.threshold) {
-            this.bufferWaiter();
-        }
-        if (!this.buffer.length) {
-            await this.updateState(lastEventInBuffer?.event.eventId);
-        }
-        else {
-            await this.updateState();
-        }
-        if (!this.buffer.length && this.stopAt?.eventBufferReached) {
-            await this.options.processor?.onDone?.();
-            await this.stop();
-        }
-    }
-    async waitForNotifier() {
-        this.logger?.info("No more events, waiting for notifier...");
-        this.notifierAbortController = new AbortController();
-        await this.options.notifier.wait({ ...this.options.dataSource, dataCoreId: await this.getDataCoreId() }, this.notifierAbortController.signal);
-        this.notifierAbortController = undefined;
-    }
-    async waitForEvents() {
-        this.logger?.debug("No events, waiting for events");
-        await new Promise((resolve) => {
-            this.waiter = (stopping) => {
-                if (!stopping) {
-                    this.logger?.debug("Notifying waiter that we have events");
-                }
-                resolve();
-            };
-        });
-        this.waiter = null;
-    }
-    async waitForBufferThreshold() {
-        if (this.buffer.length < this.options.buffer.size - this.options.buffer.threshold) {
-            return;
-        }
-        await new Promise((resolve) => {
-            this.bufferWaiter = (stopping) => {
-                if (!stopping) {
-                    this.logger?.debug("Notifying buffer waiter that we are under threshold");
-                }
-                resolve();
-            };
-        });
-        this.bufferWaiter = null;
-    }
-    getNowTimeBucket() {
-        return format(startOfHour(utc(new Date())), "yyyyMMddHH0000");
-    }
-    async getDataCoreId() {
-        if (this.dataCoreId) {
-            return this.dataCoreId;
-        }
-        const dataCore = await this.options.flowcoreClient.execute(new DataCoreFetchCommand({
-            dataCore: this.options.dataSource.dataCore,
-            tenant: this.options.dataSource.tenant,
-        }));
-        this.dataCoreId = dataCore.id;
-        return this.dataCoreId;
-    }
-    pull(amount) {
-        if (this.options.processor) {
-            throw new Error("Pull is not supported when processor is set");
-        }
-        return this.pullInner(amount);
-    }
-    acknowledge(eventIds) {
-        if (this.options.processor) {
-            throw new Error("Acknowledge is not supported when processor is set");
-        }
-        return this.acknowledgeInner(eventIds);
-    }
-}

package/esm/lib/nats-notifier.d.ts

@@ -1,18 +0,0 @@
-import type { DataPumpNotifier } from "./data-pump.js";
-interface NatsClientOptions {
-    servers: string[];
-    timeoutMs?: number;
-}
-export declare class NatsNotifier {
-    private readonly options;
-    private nats;
-    private timeoutMs;
-    constructor(options: NatsClientOptions);
-    private start;
-    private stop;
-    private awaitMessage;
-    private getSubscription;
-    getNotifier(): DataPumpNotifier;
-}
-export {};
-//# sourceMappingURL=nats-notifier.d.ts.map

package/esm/lib/nats-notifier.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nats-notifier.d.ts","sourceRoot":"","sources":["../../src/lib/nats-notifier.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAEtD,UAAU,iBAAiB;IACzB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,qBAAa,YAAY;IAGX,OAAO,CAAC,QAAQ,CAAC,OAAO;IAFpC,OAAO,CAAC,IAAI,CAAiC;IAC7C,OAAO,CAAC,SAAS,CAAQ;gBACI,OAAO,EAAE,iBAAiB;YAIzC,KAAK;YAOL,IAAI;IAOlB,OAAO,CAAC,YAAY;IAoCpB,OAAO,CAAC,eAAe;IAgBhB,WAAW,IAAI,gBAAgB;CAavC"}

package/esm/lib/nats-notifier.js

@@ -1,88 +0,0 @@
-import * as Nats from "nats";
-export class NatsNotifier {
-    constructor(options) {
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: options
-        });
-        Object.defineProperty(this, "nats", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "timeoutMs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.timeoutMs = options.timeoutMs ?? 20_000;
-    }
-    async start() {
-        if (this.nats) {
-            return;
-        }
-        this.nats = await Nats.connect({ servers: this.options.servers });
-    }
-    async stop() {
-        if (this.nats) {
-            await this.nats.close();
-            this.nats = undefined;
-        }
-    }
-    awaitMessage(subjects, timeoutMs) {
-        const abortController = new AbortController();
-        const promise = new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                for (const subscription of subscriptions) {
-                    subscription.unsubscribe();
-                }
-                resolve();
-            }, timeoutMs);
-            const subscriptions = [];
-            for (const subject of subjects) {
-                subscriptions.push(this.getSubscription(subject, (_message) => {
-                    for (const subscription of subscriptions) {
-                        clearTimeout(timer);
-                        subscription.unsubscribe();
-                    }
-                    resolve();
-                }));
-            }
-            abortController.signal.addEventListener("abort", () => {
-                for (const subscription of subscriptions) {
-                    subscription.unsubscribe();
-                    clearTimeout(timer);
-                }
-                resolve();
-            });
-        });
-        return [promise, abortController];
-    }
-    getSubscription(subject, onMessage) {
-        if (!this.nats) {
-            throw new Error("NatsClient is not started");
-        }
-        const subscription = this.nats.subscribe(subject);
-        (async () => {
-            for await (const message of subscription) {
-                await onMessage(message, subscription);
-            }
-        })().catch(console.error);
-        return subscription;
-    }
-    getNotifier() {
-        return {
-            wait: async (dataSource, signal) => {
-                await this.start();
-                const topics = dataSource.eventTypes.map((eventType) => `stored.event.notify.0.${dataSource.dataCoreId}.${dataSource.flowType}.${eventType}`);
-                const [promise, abortController] = this.awaitMessage(topics, this.timeoutMs);
-                signal?.addEventListener("abort", () => abortController.abort());
-                await promise;
-            },
-        };
-    }
-}

package/esm/lib/ws-notifier.d.ts

@@ -1,37 +0,0 @@
-import type { DataPumpNotifier, Logger } from "./data-pump.js";
-interface WebSocketNotifierOptionsAuthOidcClient {
-    oidcClient: {
-        getToken: () => Promise<{
-            accessToken: string;
-        }>;
-    };
-}
-interface WebSocketNotifierOptionsAuthApiKey {
-    apiKey: string;
-    apiKeyId: string;
-}
-type WebSocketNotifierOptionsAuth = WebSocketNotifierOptionsAuthOidcClient | WebSocketNotifierOptionsAuthApiKey;
-export declare class WebSocketNotifier {
-    private readonly authOptions;
-    private subject?;
-    private notificationClient?;
-    private dataSource;
-    private eventResolver?;
-    private logger?;
-    private timeoutMs;
-    constructor(options: {
-        auth: WebSocketNotifierOptionsAuth;
-        dataSource: {
-            tenant: string;
-            dataCore: string;
-            flowType: string;
-            eventTypes: string[];
-        };
-        logger?: Logger;
-        timeoutMs?: number;
-    });
-    private onEvent;
-    getNotifier(): DataPumpNotifier;
-}
-export {};
-//# sourceMappingURL=ws-notifier.d.ts.map

package/esm/lib/ws-notifier.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ws-notifier.d.ts","sourceRoot":"","sources":["../../src/lib/ws-notifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAI9D,UAAU,sCAAsC;IAC9C,UAAU,EAAE;QACV,QAAQ,EAAE,MAAM,OAAO,CAAC;YAAE,WAAW,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KACjD,CAAA;CACF;AAED,UAAU,kCAAkC;IAC1C,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,KAAK,4BAA4B,GAAG,sCAAsC,GAAG,kCAAkC,CAAA;AAE/G,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8B;IAC1D,OAAO,CAAC,OAAO,CAAC,CAA4B;IAC5C,OAAO,CAAC,kBAAkB,CAAC,CAAoB;IAC/C,OAAO,CAAC,UAAU,CAKjB;IACD,OAAO,CAAC,aAAa,CAAC,CAAY;IAClC,OAAO,CAAC,MAAM,CAAC,CAAQ;IACvB,OAAO,CAAC,SAAS,CAAQ;gBAEb,OAAO,EAAE;QACnB,IAAI,EAAE,4BAA4B,CAAA;QAClC,UAAU,EAAE;YACV,MAAM,EAAE,MAAM,CAAA;YACd,QAAQ,EAAE,MAAM,CAAA;YAChB,QAAQ,EAAE,MAAM,CAAA;YAChB,UAAU,EAAE,MAAM,EAAE,CAAA;SACrB,CAAA;QACD,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,SAAS,CAAC,EAAE,MAAM,CAAA;KACnB;IAOD,OAAO,CAAC,OAAO;IAMR,WAAW,IAAI,gBAAgB;CAkCvC"}

package/esm/lib/ws-notifier.js

@@ -1,86 +0,0 @@
-import { Subject } from "rxjs";
-import { NotificationClient } from "../deps/jsr.io/@flowcore/sdk/1.26.3/src/mod.js";
-export class WebSocketNotifier {
-    constructor(options) {
-        Object.defineProperty(this, "authOptions", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "subject", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "notificationClient", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "dataSource", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "eventResolver", {
-            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, "timeoutMs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.authOptions = options.auth;
-        this.dataSource = options.dataSource;
-        this.logger = options.logger;
-        this.timeoutMs = options.timeoutMs ?? 20_000;
-    }
-    onEvent(event) {
-        if (this.dataSource.eventTypes.includes(event.data.eventType)) {
-            this.eventResolver?.();
-        }
-    }
-    getNotifier() {
-        return {
-            wait: async (_, signal) => {
-                this.subject = new Subject();
-                this.subject.subscribe({
-                    next: this.onEvent.bind(this),
-                    error: (error) => this.logger?.error("Notification stream error:", error),
-                    complete: () => this.logger?.info("Notification stream completed"),
-                });
-                this.notificationClient = new NotificationClient(this.subject, this.authOptions, {
-                    tenant: this.dataSource.tenant,
-                    dataCore: this.dataSource.dataCore,
-                    flowType: this.dataSource.flowType,
-                }, {
-                    logger: this.logger,
-                    reconnectInterval: 1000,
-                });
-                await this.notificationClient.connect();
-                const promise = new Promise((resolve) => {
-                    this.eventResolver = resolve;
-                });
-                setTimeout(() => this.eventResolver?.(), this.timeoutMs);
-                signal?.addEventListener("abort", () => this.eventResolver?.());
-                await promise;
-                this.eventResolver = undefined;
-                this.notificationClient.disconnect();
-            },
-        };
-    }
-}