@flowcore/pathways 0.16.4 → 0.17.0

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/data-source.js

@@ -0,0 +1,267 @@
+/**
+ * @module data-source
+ * @description Provides functionality to interact with Flowcore data sources
+ */
+import { DataCoreFetchCommand, EventListCommand, EventTypeListCommand, FlowTypeFetchCommand, TenantTranslateNameToIdCommand, TimeBucketListCommand, } from "../../../../sdk/1.71.0/src/mod.js";
+import { getFlowcoreClient } from "./flowcore-client.js";
+/**
+ * Provides methods to interact with a Flowcore data source
+ * @class FlowcoreDataSource
+ */
+export class FlowcoreDataSource {
+    /**
+     * Creates a new FlowcoreDataSource instance
+     * @param options - Configuration options for the data source
+     */
+    constructor(options) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        /** Flowcore client instance */
+        Object.defineProperty(this, "flowcoreClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Cached tenant ID */
+        Object.defineProperty(this, "tenantId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Cached data core ID */
+        Object.defineProperty(this, "dataCoreId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Cached flow type ID */
+        Object.defineProperty(this, "flowTypeId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Cached event type IDs */
+        Object.defineProperty(this, "eventTypeIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** Cached time buckets */
+        Object.defineProperty(this, "timeBuckets", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.flowcoreClient = getFlowcoreClient(this.options.auth, this.options.baseUrlOverride);
+    }
+    /**
+     * Gets the tenant name from the data source configuration
+     * @returns Tenant name
+     */
+    get tenant() {
+        return this.options.dataSource.tenant;
+    }
+    /**
+     * Gets the data core name from the data source configuration
+     * @returns Data core name
+     */
+    get dataCore() {
+        return this.options.dataSource.dataCore;
+    }
+    /**
+     * Gets the flow type name from the data source configuration
+     * @returns Flow type name
+     */
+    get flowType() {
+        return this.options.dataSource.flowType;
+    }
+    /**
+     * Gets the event type names from the data source configuration
+     * @returns Array of event type names
+     */
+    get eventTypes() {
+        return this.options.dataSource.eventTypes;
+    }
+    /**
+     * Gets the tenant ID, translating from name if necessary
+     * @returns Promise that resolves to the tenant ID
+     */
+    async getTenantId() {
+        if (this.tenantId) {
+            return this.tenantId;
+        }
+        if (this.options.noTranslation) {
+            this.tenantId = this.options.dataSource.tenant;
+        }
+        else {
+            const command = new TenantTranslateNameToIdCommand({
+                tenant: this.options.dataSource.tenant,
+            });
+            const result = await this.flowcoreClient.execute(command, this.options.directMode);
+            this.tenantId = result.id;
+        }
+        return this.tenantId;
+    }
+    /**
+     * Gets the data core ID, translating from name if necessary
+     * @returns Promise that resolves to the data core ID
+     */
+    async getDataCoreId() {
+        if (this.dataCoreId) {
+            return this.dataCoreId;
+        }
+        if (this.options.noTranslation) {
+            this.dataCoreId = this.options.dataSource.dataCore;
+        }
+        else {
+            const command = new DataCoreFetchCommand({
+                tenant: this.options.dataSource.tenant,
+                dataCore: this.options.dataSource.dataCore,
+            });
+            const result = await this.flowcoreClient.execute(command, this.options.directMode);
+            this.dataCoreId = result.id;
+        }
+        return this.dataCoreId;
+    }
+    /**
+     * Gets the flow type ID, translating from name if necessary
+     * @returns Promise that resolves to the flow type ID
+     */
+    async getFlowTypeId() {
+        if (this.flowTypeId) {
+            return this.flowTypeId;
+        }
+        if (this.options.noTranslation) {
+            this.flowTypeId = this.options.dataSource.flowType;
+        }
+        else {
+            const command = new FlowTypeFetchCommand({
+                dataCoreId: await this.getDataCoreId(),
+                flowType: this.options.dataSource.flowType,
+            });
+            const result = await this.flowcoreClient.execute(command, this.options.directMode);
+            this.flowTypeId = result.id;
+        }
+        return this.flowTypeId;
+    }
+    /**
+     * Gets the event type IDs, translating from names if necessary
+     * @returns Promise that resolves to an array of event type IDs
+     * @throws Error if an event type is not found
+     */
+    async getEventTypeIds() {
+        if (this.eventTypeIds) {
+            return this.eventTypeIds;
+        }
+        if (this.options.noTranslation) {
+            this.eventTypeIds = this.options.dataSource.eventTypes;
+        }
+        else {
+            const command = new EventTypeListCommand({
+                flowTypeId: await this.getFlowTypeId(),
+            });
+            const results = await this.flowcoreClient.execute(command, this.options.directMode);
+            const eventTypeIds = [];
+            for (const eventType of this.eventTypes) {
+                const found = results.find((result) => result.name === eventType);
+                if (!found) {
+                    throw new Error(`Event type ${eventType} not found`);
+                }
+                eventTypeIds.push(found.id);
+            }
+            this.eventTypeIds = eventTypeIds;
+        }
+        return this.eventTypeIds;
+    }
+    /**
+     * Gets all time buckets for the configured event types
+     * @param force - When true, forces a refresh of cached time buckets
+     * @returns Promise that resolves to an array of time bucket strings
+     */
+    async getTimeBuckets(force = false) {
+        if (this.timeBuckets && !force) {
+            return this.timeBuckets;
+        }
+        let cursor;
+        const timeBuckets = [];
+        do {
+            const result = await this.flowcoreClient.execute(new TimeBucketListCommand({
+                tenant: this.options.dataSource.tenant,
+                eventTypeId: (await this.getEventTypeIds()),
+                cursor: cursor || undefined,
+                pageSize: 10_000,
+            }), this.options.directMode);
+            timeBuckets.push(...result.timeBuckets);
+            cursor = result.nextCursor;
+        } while (cursor !== undefined);
+        this.timeBuckets = timeBuckets;
+        return this.timeBuckets;
+    }
+    /**
+     * Gets the next time bucket after the specified time bucket
+     * @param timeBucket - The reference time bucket
+     * @returns Promise that resolves to the next time bucket, or null if none exists
+     */
+    async getNextTimeBucket(timeBucket) {
+        const closestTimeBucket = await this.getClosestTimeBucket(timeBucket);
+        if (!closestTimeBucket) {
+            return null;
+        }
+        const timeBuckets = await this.getTimeBuckets();
+        const index = timeBuckets.indexOf(closestTimeBucket);
+        if (index === -1) {
+            throw new Error(`Could not get next timeBucket, timeBucket ${timeBucket} not found`);
+        }
+        return timeBuckets[index + 1] ?? null;
+    }
+    /**
+     * Gets the closest time bucket to the specified time bucket
+     * @param timeBucket - The reference time bucket
+     * @param getBefore - When true, gets the closest time bucket before the reference
+     * @returns Promise that resolves to the closest time bucket, or null if none exists
+     * @throws Error if the time bucket format is invalid
+     */
+    async getClosestTimeBucket(timeBucket, getBefore = false) {
+        const timeBuckets = await this.getTimeBuckets();
+        if (!timeBucket.match(/^\d{14}$/)) {
+            throw new Error(`Invalid timebucket: ${timeBucket}`);
+        }
+        if (getBefore) {
+            return (timeBuckets.findLast((t) => Number.parseFloat(t) <= Number.parseFloat(timeBucket)) ??
+                timeBuckets[timeBuckets.length - 1]);
+        }
+        return (timeBuckets.find((t) => Number.parseFloat(t) >= Number.parseFloat(timeBucket)) ??
+            timeBuckets[timeBuckets.length - 1]);
+    }
+    /**
+     * Gets events from the data source starting from a specific state
+     * @param from - The state to start from (includes timeBucket and eventId)
+     * @param amount - Maximum number of events to retrieve
+     * @param toEventId - Optional ID to stop at when retrieving events
+     * @returns Promise that resolves to an array of Flowcore events
+     */
+    async getEvents(from, amount, toEventId, cursor, includeSensitiveData = false) {
+        const eventTypeIds = await this.getEventTypeIds();
+        const result = await this.flowcoreClient.execute(new EventListCommand({
+            tenant: this.options.dataSource.tenant,
+            eventTypeId: eventTypeIds,
+            timeBucket: from.timeBucket,
+            afterEventId: !cursor ? from.eventId : undefined,
+            pageSize: amount,
+            toEventId,
+            cursor,
+            includeSensitiveData,
+        }), this.options.directMode);
+        return result;
+    }
+}

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/flowcore-client.d.ts

@@ -0,0 +1,8 @@
+import { type Command, FlowcoreClient } from "../../../../sdk/1.71.0/src/mod.js";
+import type { FlowcoreDataPumpAuth } from "./types.js";
+declare class FlowcoreClientWithMetrics extends FlowcoreClient {
+    execute<Input, Output>(command: Command<Input, Output>, directMode?: boolean): Promise<Output>;
+}
+export declare function getFlowcoreClient(auth: FlowcoreDataPumpAuth, baseUrlOverride?: string): FlowcoreClientWithMetrics;
+export {};
+//# sourceMappingURL=flowcore-client.d.ts.map

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/flowcore-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowcore-client.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/flowcore-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAA;AAChF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAGtD,cAAM,yBAA0B,SAAQ,cAAc;IACpC,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;CAI/G;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,oBAAoB,EAAE,eAAe,CAAC,EAAE,MAAM,6BAarF"}

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/flowcore-client.js

@@ -0,0 +1,20 @@
+import { FlowcoreClient } from "../../../../sdk/1.71.0/src/mod.js";
+import { metrics } from "./metrics.js";
+class FlowcoreClientWithMetrics extends FlowcoreClient {
+    execute(command, directMode) {
+        metrics.sdkCommandsCounter.inc({ command: command.constructor.name }, 1);
+        return super.execute(command, directMode);
+    }
+}
+export function getFlowcoreClient(auth, baseUrlOverride) {
+    const client = "apiKey" in auth
+        ? new FlowcoreClientWithMetrics({
+            apiKey: auth.apiKey,
+            apiKeyId: auth.apiKeyId,
+        })
+        : new FlowcoreClientWithMetrics(auth);
+    if (baseUrlOverride) {
+        client.setBaseUrl(baseUrlOverride);
+    }
+    return client;
+}

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/metrics.d.ts

@@ -0,0 +1,12 @@
+import PromClient from "prom-client";
+export declare const dataPumpPromRegistry: PromClient.Registry<"text/plain; version=0.0.4; charset=utf-8">;
+export declare const metrics: {
+    bufferEventCountGauge: PromClient.Gauge<"tenant" | "data_core" | "flow_type" | "event_type">;
+    bufferReservedEventCountGauge: PromClient.Gauge<"tenant" | "data_core" | "flow_type" | "event_type">;
+    bufferSizeBytesGauge: PromClient.Gauge<"tenant" | "data_core" | "flow_type" | "event_type">;
+    eventsAcknowledgedCounter: PromClient.Counter<"tenant" | "data_core" | "flow_type" | "event_type">;
+    eventsFailedCounter: PromClient.Counter<"tenant" | "data_core" | "flow_type" | "event_type">;
+    eventsPulledSizeBytesCounter: PromClient.Counter<"tenant" | "data_core" | "flow_type" | "event_type">;
+    sdkCommandsCounter: PromClient.Counter<"command">;
+};
+//# sourceMappingURL=metrics.d.ts.map

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/metrics.ts"],"names":[],"mappings":"AAAA,OAAO,UAA8B,MAAM,aAAa,CAAA;AAExD,eAAO,MAAM,oBAAoB,EAAE,UAAU,CAAC,QAAQ,CAAC,0CAA0C,CACpF,CAAA;AAoDb,eAAO,MAAM,OAAO;;;;;;;;CAQnB,CAAA"}

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/metrics.js

@@ -0,0 +1,54 @@
+import PromClient, { Counter, Gauge } from "prom-client";
+export const dataPumpPromRegistry = new PromClient
+    .Registry();
+const bufferEventCountGauge = new Gauge({
+    name: "flowcore_data_pump_buffer_events_gauge",
+    help: "The number of events in the buffer",
+    labelNames: ["tenant", "data_core", "flow_type", "event_type"],
+});
+const bufferReservedEventCountGauge = new Gauge({
+    name: "flowcore_data_pump_buffer_reserved_events_gauge",
+    help: "The number of reserved events in the buffer",
+    labelNames: ["tenant", "data_core", "flow_type", "event_type"],
+});
+const bufferSizeBytesGauge = new Gauge({
+    name: "flowcore_data_pump_buffer_size_bytes_gauge",
+    help: "The size of the buffer in bytes",
+    labelNames: ["tenant", "data_core", "flow_type", "event_type"],
+});
+const eventsAcknowledgedCounter = new Counter({
+    name: "flowcore_data_pump_events_acknowledged_counter",
+    help: "The number of events acknowledged",
+    labelNames: ["tenant", "data_core", "flow_type", "event_type"],
+});
+const eventsFailedCounter = new Counter({
+    name: "flowcore_data_pump_events_failed_counter",
+    help: "The number of events failed",
+    labelNames: ["tenant", "data_core", "flow_type", "event_type"],
+});
+const eventsPulledSizeBytesCounter = new Counter({
+    name: "flowcore_data_pump_events_pulled_size_bytes_counter",
+    help: "The size of the events pulled in bytes",
+    labelNames: ["tenant", "data_core", "flow_type", "event_type"],
+});
+const sdkCommandsCounter = new Counter({
+    name: "flowcore_data_pump_sdk_commands_counter",
+    help: "The number of SDK commands",
+    labelNames: ["command"],
+});
+dataPumpPromRegistry.registerMetric(bufferEventCountGauge);
+dataPumpPromRegistry.registerMetric(bufferReservedEventCountGauge);
+dataPumpPromRegistry.registerMetric(bufferSizeBytesGauge);
+dataPumpPromRegistry.registerMetric(eventsAcknowledgedCounter);
+dataPumpPromRegistry.registerMetric(eventsFailedCounter);
+dataPumpPromRegistry.registerMetric(eventsPulledSizeBytesCounter);
+dataPumpPromRegistry.registerMetric(sdkCommandsCounter);
+export const metrics = {
+    bufferEventCountGauge,
+    bufferReservedEventCountGauge,
+    bufferSizeBytesGauge,
+    eventsAcknowledgedCounter,
+    eventsFailedCounter,
+    eventsPulledSizeBytesCounter,
+    sdkCommandsCounter,
+};

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/no-op-logger.d.ts

@@ -0,0 +1,3 @@
+import type { FlowcoreLogger } from "./types.js";
+export declare const noOpLogger: FlowcoreLogger;
+//# sourceMappingURL=no-op-logger.d.ts.map

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/no-op-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-op-logger.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/no-op-logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEhD,eAAO,MAAM,UAAU,EAAE,cAKxB,CAAA"}

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/no-op-logger.js

@@ -0,0 +1,6 @@
+export const noOpLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: console.error,
+};

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/notifier.d.ts

@@ -0,0 +1,28 @@
+import type { FlowcoreDataPumpAuth, FlowcoreDataPumpDataSource, FlowcoreLogger } from "./types.js";
+export interface FlowcoreNotifierOptions {
+    dataSource: FlowcoreDataPumpDataSource;
+    auth: FlowcoreDataPumpAuth;
+    natsServers?: string[];
+    pollerIntervalMs?: number;
+    timeoutMs?: number;
+    logger?: FlowcoreLogger;
+    directMode?: boolean;
+    noTranslation?: boolean;
+}
+export declare class FlowcoreNotifier {
+    private readonly options;
+    private dataSource;
+    private nats?;
+    private subject?;
+    private notificationClient?;
+    private eventResolver?;
+    private timer?;
+    constructor(options: FlowcoreNotifierOptions);
+    wait(signal?: AbortSignal): Promise<void>;
+    private waitPoller;
+    private waitNats;
+    private onWebSocketEvent;
+    private waitWebSocket;
+    private webSocketAuth;
+}
+//# sourceMappingURL=notifier.d.ts.map

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/notifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifier.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/notifier.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAKlG,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,0BAA0B,CAAA;IACtC,IAAI,EAAE,oBAAoB,CAAA;IAC1B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,qBAAa,gBAAgB;IASf,OAAO,CAAC,QAAQ,CAAC,OAAO;IARpC,OAAO,CAAC,UAAU,CAAoB;IACtC,OAAO,CAAC,IAAI,CAAC,CAAqB;IAClC,OAAO,CAAC,OAAO,CAAC,CAA4B;IAC5C,OAAO,CAAC,kBAAkB,CAAC,CAAoB;IAC/C,OAAO,CAAC,aAAa,CAAC,CAAY;IAElC,OAAO,CAAC,KAAK,CAAC,CAAK;gBAEU,OAAO,EAAE,uBAAuB;IAStD,IAAI,CAAC,MAAM,CAAC,EAAE,WAAW;YASlB,UAAU;YAUV,QAAQ;IAuCtB,OAAO,CAAC,gBAAgB;YAMV,aAAa;IAmC3B,OAAO,CAAC,aAAa;CAgBtB"}

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/notifier.js

@@ -0,0 +1,154 @@
+import { NotificationClient } from "../../../../sdk/1.71.0/src/mod.js";
+import * as Nats from "nats";
+import { Subject } from "rxjs";
+import { FlowcoreDataSource } from "./data-source.js";
+import { noOpLogger } from "./no-op-logger.js";
+const DEFAULT_TIMEOUT_MS = 20_000;
+export class FlowcoreNotifier {
+    constructor(options) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        Object.defineProperty(this, "dataSource", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "nats", {
+            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, "eventResolver", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // deno-lint-ignore no-explicit-any
+        Object.defineProperty(this, "timer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.dataSource = new FlowcoreDataSource({
+            auth: this.options.auth,
+            dataSource: this.options.dataSource,
+            directMode: this.options.directMode,
+            noTranslation: this.options.noTranslation,
+        });
+    }
+    wait(signal) {
+        if (this.options.natsServers) {
+            return this.waitNats();
+        }
+        else if (this.options.pollerIntervalMs) {
+            return this.waitPoller(this.options.pollerIntervalMs, signal);
+        }
+        return this.waitWebSocket(signal);
+    }
+    async waitPoller(intervalMs, signal) {
+        this.options.logger?.debug("Waiting for poller");
+        const promise = new Promise((resolve) => {
+            this.eventResolver = resolve;
+        });
+        signal?.addEventListener("abort", () => this.eventResolver?.());
+        setTimeout(() => this.eventResolver?.(), Math.min(intervalMs, 1000));
+        await promise;
+    }
+    async waitNats(signal) {
+        this.options.logger?.debug("Waiting for nats");
+        if (!this.nats) {
+            this.nats = await Nats.connect({ servers: this.options.natsServers });
+        }
+        const dataCoreId = await this.dataSource.getDataCoreId();
+        const topics = this.dataSource.eventTypes.map((eventType) => `stored.event.notify.0.${dataCoreId}.${this.dataSource.flowType}.${eventType}`);
+        const promise = new Promise((resolve) => {
+            this.eventResolver = resolve;
+        });
+        const subscriptions = [];
+        for (const topic of topics) {
+            subscriptions.push(this.nats.subscribe(topic, {
+                callback: () => {
+                    this.options.logger?.debug(`Received event from nats: ${topic}`);
+                    this.eventResolver?.();
+                },
+            }));
+        }
+        clearTimeout(this.timer);
+        this.timer = setTimeout(() => this.eventResolver?.(), this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        signal?.addEventListener("abort", () => this.eventResolver?.());
+        await promise;
+        this.options.logger?.debug("Unsubscribing from nats");
+        for (const subscription of subscriptions) {
+            subscription.unsubscribe();
+        }
+        this.nats?.close();
+        this.nats = undefined;
+    }
+    onWebSocketEvent(event) {
+        if (this.dataSource.eventTypes.includes(event.data.eventType)) {
+            this.eventResolver?.();
+        }
+    }
+    async waitWebSocket(signal) {
+        this.options.logger?.debug("Waiting for web socket");
+        this.subject = new Subject();
+        this.subject.subscribe({
+            next: this.onWebSocketEvent.bind(this),
+            error: (error) => this.options.logger?.error("Notification stream error:", { error }),
+        });
+        this.notificationClient = new NotificationClient(this.subject, this.webSocketAuth(), {
+            tenant: this.dataSource.tenant,
+            dataCore: this.dataSource.dataCore,
+            flowType: this.dataSource.flowType,
+        }, {
+            logger: this.options.logger ?? noOpLogger,
+            reconnectInterval: 1000,
+        });
+        await this.notificationClient.connect();
+        const promise = new Promise((resolve) => {
+            this.eventResolver = resolve;
+        });
+        clearTimeout(this.timer);
+        this.timer = setTimeout(() => this.eventResolver?.(), this.options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        signal?.addEventListener("abort", () => this.eventResolver?.());
+        await promise;
+        this.eventResolver = undefined;
+        this.notificationClient.disconnect();
+    }
+    webSocketAuth() {
+        if ("apiKey" in this.options.auth) {
+            return {
+                apiKey: this.options.auth.apiKey,
+                apiKeyId: this.options.auth.apiKeyId,
+            };
+        }
+        const getBearerToken = this.options.auth.getBearerToken;
+        return {
+            oidcClient: {
+                getToken: async () => ({
+                    accessToken: await getBearerToken(),
+                }),
+            },
+        };
+    }
+}

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/types.d.ts

@@ -0,0 +1,37 @@
+import type { FlowcoreEvent } from "../../../../sdk/1.71.0/src/mod.js";
+export type FlowcoreDataPumpAuth = {
+    apiKey: string;
+    /**
+     * The ID of the API key.
+     * @deprecated Use apiKey only instead (apiKeyId is only used for old api keys).
+     */
+    apiKeyId?: string;
+} | {
+    getBearerToken: () => Promise<string>;
+};
+export interface FlowcoreDataPumpState {
+    timeBucket: string;
+    eventId?: string;
+}
+export interface FlowcoreDataPumpDataSource {
+    tenant: string;
+    dataCore: string;
+    flowType: string;
+    eventTypes: string[];
+}
+export interface FlowcoreDataPumpStateManager {
+    getState: () => Promise<FlowcoreDataPumpState | null> | FlowcoreDataPumpState | null;
+    setState?: (state: FlowcoreDataPumpState) => Promise<void> | void;
+}
+export interface FlowcoreLogger {
+    debug: (message: string, metadata?: Record<string, unknown>) => void;
+    info: (message: string, metadata?: Record<string, unknown>) => void;
+    warn: (message: string, metadata?: Record<string, unknown>) => void;
+    error: (message: string | Error, metadata?: Record<string, unknown>) => void;
+}
+export interface FlowcoreDataPumpProcessor {
+    concurrency?: number;
+    handler: (events: FlowcoreEvent[]) => Promise<void>;
+    failedHandler?: (events: FlowcoreEvent[]) => void | Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAA;AAEtE,MAAM,MAAM,oBAAoB,GAC5B;IACA,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,GACC;IACA,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;CACtC,CAAA;AAEH,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,MAAM,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,GAAG,qBAAqB,GAAG,IAAI,CAAA;IACpF,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CAClE;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IACpE,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IACnE,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IACnE,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;CAC7E;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACnD,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAClE"}

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/types.js

@@ -0,0 +1 @@
+export {};

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/mod.d.ts

@@ -0,0 +1,6 @@
+export * from "./data-pump/data-pump.js";
+export * from "./data-pump/data-source.js";
+export * from "./data-pump/metrics.js";
+export * from "./data-pump/types.js";
+export * from "./data-pump/no-op-logger.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@flowcore/data-pump/0.16.5/src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA;AACxC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,6BAA6B,CAAA"}

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/mod.js

@@ -0,0 +1,5 @@
+export * from "./data-pump/data-pump.js";
+export * from "./data-pump/data-source.js";
+export * from "./data-pump/metrics.js";
+export * from "./data-pump/types.js";
+export * from "./data-pump/no-op-logger.js";