@flowcore/data-pump 0.1.2

package/esm/lib/data-pump.js

@@ -0,0 +1,364 @@
+import { DataCoreFetchCommand, EventsFetchCommand, EventsFetchTimeBucketsByNamesCommand, TenantFetchCommand, } from "../deps/jsr.io/@flowcore/sdk/1.11.4/src/mod.js";
+import { TimeUuid } from "./time-uuid.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
+        });
+        this.state = {
+            timeBucket: this.getNowTimeBucket(),
+        };
+        this.logger = options.logger ?? undefined;
+    }
+    async start() {
+        if (this.running) {
+            return;
+        }
+        await this.updateTimeBuckets();
+        const newState = await this.options.stateManager.getState();
+        if (!newState) {
+            this.state.timeBucket = this.getClosestTimeBucket(this.getNowTimeBucket());
+            this.state.eventId = TimeUuid.fromNow().toString();
+        }
+        else {
+            this.state.timeBucket = this.getClosestTimeBucket(newState.timeBucket);
+            this.state.eventId = newState.eventId;
+        }
+        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;
+                }
+                await this.options.processor.onEvents(events);
+                await this.acknowledgeInner(events.map((event) => event.eventId));
+            }
+            catch (error) {
+                this.logger?.error("Error in processor", { error });
+                this.stop();
+            }
+        }
+    }
+    async eventBufferLoop() {
+        // Stop buffer loop if we are not running
+        if (!this.running) {
+            return;
+        }
+        // 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?.debug(`fetching ${eventsToFetch} 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,
+        });
+        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?.debug(`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) {
+            // 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();
+    }
+    reOpen(eventIds, deliveryId) {
+        if (!eventIds.length) {
+            return;
+        }
+        this.buffer.forEach((event) => {
+            if (event.deliveryId === deliveryId && eventIds.includes(event.event.eventId)) {
+                event.status = FlowcoreBufferEventStatus.OPEN;
+                event.deliveryId = "";
+            }
+        });
+        if (this.bufferWaiter && this.buffer.length <= this.options.buffer.size - this.options.buffer.threshold) {
+            this.bufferWaiter();
+        }
+    }
+    updateState() {
+        const firstEvent = this.buffer[0];
+        if (!firstEvent) {
+            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) {
+        if (!timeBucket.match(/^\d{14}$/)) {
+            throw new Error(`Invalid timebucket: ${timeBucket}`);
+        }
+        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");
+        }
+        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 })
+        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();
+        }
+        await this.updateState();
+    }
+    async waitForNotifier() {
+        this.logger?.debug("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 tenant = await this.options.flowcoreClient.execute(new TenantFetchCommand({
+            tenant: this.options.dataSource.tenant,
+        }));
+        const dataCore = await this.options.flowcoreClient.execute(new DataCoreFetchCommand({
+            dataCore: this.options.dataSource.dataCore,
+            tenantId: tenant.id,
+        }));
+        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

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

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

@@ -0,0 +1,88 @@
+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/time-uuid.d.ts

@@ -0,0 +1,13 @@
+import type { Buffer } from "node:buffer";
+import { types } from "cassandra-driver";
+export declare class TimeUuid {
+    private readonly timeUuid;
+    constructor(timeUuid: types.TimeUuid);
+    static fromDate(date: Date, ticks?: number, nodeId?: string | Buffer, clockId?: string | Buffer): TimeUuid;
+    static fromString(value: string): TimeUuid;
+    private getDatePrecision;
+    getBefore(): TimeUuid;
+    static fromNow(): TimeUuid;
+    toString(): string;
+}
+//# sourceMappingURL=time-uuid.d.ts.map

package/esm/lib/time-uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-uuid.d.ts","sourceRoot":"","sources":["../../src/lib/time-uuid.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAExC,qBAAa,QAAQ;IACP,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,KAAK,CAAC,QAAQ;WAEvC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;WAIxF,UAAU,CAAC,KAAK,EAAE,MAAM;IAItC,OAAO,CAAC,gBAAgB;IAIjB,SAAS;WASF,OAAO;IAId,QAAQ,IAAI,MAAM;CAG1B"}

package/esm/lib/time-uuid.js

@@ -0,0 +1,36 @@
+import { subMilliseconds } from "date-fns";
+import { utc } from "@date-fns/utc";
+import { types } from "cassandra-driver";
+export class TimeUuid {
+    constructor(timeUuid) {
+        Object.defineProperty(this, "timeUuid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: timeUuid
+        });
+    }
+    static fromDate(date, ticks, nodeId, clockId) {
+        return new TimeUuid(types.TimeUuid.fromDate(utc(date), ticks, nodeId, clockId));
+    }
+    static fromString(value) {
+        return new TimeUuid(types.TimeUuid.fromString(value));
+    }
+    getDatePrecision() {
+        return this.timeUuid.getDatePrecision();
+    }
+    getBefore() {
+        const { date, ticks } = this.getDatePrecision();
+        const newTicks = ticks - 1;
+        if (newTicks < 0) {
+            return TimeUuid.fromDate(subMilliseconds(date, 1), 10_000);
+        }
+        return TimeUuid.fromDate(date, newTicks);
+    }
+    static fromNow() {
+        return TimeUuid.fromDate(new Date(), 10_000);
+    }
+    toString() {
+        return this.timeUuid.toString();
+    }
+}

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

@@ -0,0 +1,28 @@
+import type { DataPumpNotifier, Logger } from "./data-pump.js";
+export declare class WebSocketNotifier {
+    private readonly authClient;
+    private subject?;
+    private notificationClient?;
+    private dataSource;
+    private eventResolver?;
+    private logger?;
+    private timeoutMs;
+    constructor(options: {
+        auth: {
+            clientId: string;
+            clientSecret: string;
+            authUrl: string;
+        };
+        dataSource: {
+            tenant: string;
+            dataCore: string;
+            flowType: string;
+            eventTypes: string[];
+        };
+        logger?: Logger;
+        timeoutMs?: number;
+    });
+    private onEvent;
+    getNotifier(): DataPumpNotifier;
+}
+//# sourceMappingURL=ws-notifier.d.ts.map

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

@@ -0,0 +1 @@
+{"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;AAK9D,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAuB;IAClD,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;YACJ,QAAQ,EAAE,MAAM,CAAA;YAChB,YAAY,EAAE,MAAM,CAAA;YACpB,OAAO,EAAE,MAAM,CAAA;SAChB,CAAA;QACD,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;IAWD,OAAO,CAAC,OAAO;IAMR,WAAW,IAAI,gBAAgB;CAkCvC"}

package/esm/lib/ws-notifier.js

@@ -0,0 +1,87 @@
+import { Subject } from "rxjs";
+import { NotificationClient } from "../deps/jsr.io/@flowcore/sdk/1.11.4/src/mod.js";
+import OidcClient from "@flowcore/sdk-oidc-client";
+export class WebSocketNotifier {
+    constructor(options) {
+        Object.defineProperty(this, "authClient", {
+            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.authClient = new OidcClient.OidcClient(options.auth.clientId, options.auth.clientSecret, options.auth.authUrl);
+        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.authClient, {
+                    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();
+            },
+        };
+    }
+}

package/esm/mod.d.ts

@@ -0,0 +1,3 @@
+export * from "./lib/data-pump.js";
+export * from "./lib/data-pump-client.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,2BAA2B,CAAA"}

package/esm/mod.js

@@ -0,0 +1,2 @@
+export * from "./lib/data-pump.js";
+export * from "./lib/data-pump-client.js";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}