@interactive-inc/flume 0.3.0 → 0.6.0

package/dist/safe-stringify-DbWQw9qe.js

@@ -0,0 +1,157 @@
+import { l as safeErrorMessage, n as safeInvokeCallback, s as attempt } from "./flume-source-DUvt9aJt.js";
+import { t as FlumeConnectionError } from "./connection-error-HUO3PC3G.js";
+//#region lib/utils/safe-random.ts
+/**
+* `deps.random()` を保護する。throw / 範囲外値 / 非数値が返った場合は 0.5 を返す。
+* 0 以上 1 未満 (Math.random と同等) の値のみそのまま透過
+*/
+function safeRandom(props) {
+	try {
+		const value = props.deps.random();
+		if (typeof value !== "number" || !Number.isFinite(value)) return .5;
+		if (value < 0 || value >= 1) return .5;
+		return value;
+	} catch {
+		return .5;
+	}
+}
+//#endregion
+//#region lib/reconnector.ts
+/**
+* 指数バックオフ + ジッタ付きの再接続スケジューラ。
+* `schedule()` の戻り値: 正の delay = 予約成功 / -1 = 試行上限到達 / 0 = cancel 済み or 内部 timer 拒否。
+* setTimeout コールバック内のユーザー fn が throw / reject しても reconnect ループは止めない
+*/
+var FlumeReconnector = class {
+	props;
+	currentAttempt = 0;
+	isAborted = false;
+	timer = null;
+	constructor(props) {
+		this.props = props;
+	}
+	get attempt() {
+		return this.currentAttempt;
+	}
+	get aborted() {
+		return this.isAborted;
+	}
+	schedule(fn) {
+		if (this.isAborted) return 0;
+		if (this.currentAttempt >= this.props.maxAttempts) return -1;
+		this.clearTimer();
+		const delay = this.nextDelay();
+		const timerResult = attempt(() => this.props.deps.setTimeout(() => this.runRetry(fn), delay));
+		if (timerResult instanceof Error) {
+			this.props.log.error({
+				action: "reconnect.timer.schedule.error",
+				message: safeErrorMessage({ error: timerResult }),
+				error: timerResult
+			});
+			this.timer = null;
+			return 0;
+		}
+		this.timer = timerResult;
+		return delay;
+	}
+	reset() {
+		this.currentAttempt = 0;
+	}
+	cancel() {
+		this.isAborted = true;
+		this.clearTimer();
+	}
+	runRetry(fn) {
+		this.timer = null;
+		safeInvokeCallback({
+			fn,
+			onError: (error) => {
+				this.props.log.error({
+					action: "reconnect.timer.error",
+					message: safeErrorMessage({ error }),
+					error
+				});
+			}
+		});
+	}
+	clearTimer() {
+		if (this.timer === null) return;
+		const handle = this.timer;
+		const result = attempt(() => this.props.deps.clearTimeout(handle));
+		if (result instanceof Error) this.props.log.error({
+			action: "reconnect.timer.clear.error",
+			message: safeErrorMessage({ error: result }),
+			error: result
+		});
+		this.timer = null;
+	}
+	nextDelay() {
+		const jitter = Math.min(this.props.baseDelay * 2 ** this.currentAttempt, this.props.maxDelay) * (.5 + safeRandom({ deps: this.props.deps }) * .5);
+		this.currentAttempt++;
+		return jitter;
+	}
+};
+//#endregion
+//#region lib/schedule-reconnect.ts
+/**
+* 接続が落ちた際の共通再接続スケジューラ。
+* 再接続の設定状況 (無効 / 中止 / 試行尽き) を見極めてからステータス遷移する。
+* - reconnector が無ければ reconnect.disabled を info ログし disconnected へ
+* - cancel 済みなら reconnect.aborted を info ログし disconnected へ
+* - schedule() が -1 を返したら reconnect.exhausted を error ログし disconnected へ
+* - それ以外は reconnecting へ遷移し reconnect.scheduled を info ログ
+*/
+function scheduleFlumeReconnect(props) {
+	if (!props.reconnector) {
+		props.log.info({
+			action: "reconnect.disabled",
+			message: "reconnect is disabled, staying disconnected"
+		});
+		props.setStatus("disconnected");
+		return;
+	}
+	if (props.reconnector.aborted) {
+		props.log.info({
+			action: "reconnect.aborted",
+			message: "reconnector cancelled, staying disconnected"
+		});
+		props.setStatus("disconnected");
+		return;
+	}
+	const delay = props.reconnector.schedule(props.retry);
+	if (delay === -1) {
+		const error = new FlumeConnectionError(`reconnect exhausted after ${props.reconnector.attempt} attempts`);
+		props.log.error({
+			action: "reconnect.exhausted",
+			message: safeErrorMessage({ error }),
+			error
+		});
+		props.setStatus("disconnected");
+		return;
+	}
+	props.setStatus("reconnecting");
+	props.log.info({
+		action: "reconnect.scheduled",
+		message: `next attempt in ${Math.round(delay)}ms`,
+		detail: {
+			attempt: props.reconnector.attempt,
+			delayMs: Math.round(delay)
+		}
+	});
+}
+//#endregion
+//#region lib/utils/is-record.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region lib/utils/safe-stringify.ts
+/**
+* `JSON.stringify` を `string | Error` に変換するだけのラッパ。
+* cyclic / BigInt / throwing toJSON など標準が throw するケースを Error として返す
+*/
+function safeStringify(value) {
+	return attempt(() => JSON.stringify(value));
+}
+//#endregion
+export { safeRandom as a, FlumeReconnector as i, isRecord as n, scheduleFlumeReconnect as r, safeStringify as t };

package/dist/slack.d.ts

@@ -1,84 +1,24 @@
-import { C as FlumeStartResult, D as FlumeSlackEnvelopeSchema, O as FlumeSlackConnectionResponseSchema, c as FlumeLogHandler, g as FlumeSlackSourceOptions, h as FlumeSlackEnvelope, o as FlumeHandler, p as FlumeRuntimeDeps, w as FlumeStatus } from "./types-Bm9uKUQz.js";
-import { t as FlumeConnectionError } from "./connection-error-BOk97djj.js";
-import { t as FlumeHttpError } from "./http-error-K-Ym4lfK.js";
+import { C as FlumeSourceStartContext, b as FlumeSlackSourceOptions, t as FlumeSource, v as FlumeSlackEnvelope } from "./flume-source-DuUFPhSe.js";
 
 //#region lib/slack/slack-source.d.ts
-declare class FlumeSlackSource {
+declare class FlumeSlackSource extends FlumeSource {
   private readonly options;
   readonly name: "slack";
   private socket;
   private reconnector;
-  private handler;
-  private currentStatus;
-  private readonly log;
-  private readonly deps;
-  private readonly queue;
-  private readonly seen;
+  private internalController;
+  private seen;
   constructor(options: FlumeSlackSourceOptions);
-  start(handler: FlumeHandler): Promise<FlumeStartResult>;
-  stop(): Promise<void>;
-  status(): FlumeStatus;
+  protected connect(ctx: FlumeSourceStartContext): Promise<Error | null>;
+  protected disconnect(): void;
+  private hasWebSocket;
   private connectInternal;
   private handleMessage;
+  private safeExtractMeta;
   private scheduleReconnect;
-  private setStatus;
 }
 //#endregion
 //#region lib/slack/extract-slack-meta.d.ts
-declare function extractSlackMeta(envelope: FlumeSlackEnvelope): Record<string, string>;
-//#endregion
-//#region lib/slack/slack-socket-mode.d.ts
-type Deps = Pick<FlumeRuntimeDeps, "WebSocket" | "fetch" | "now">;
-type Props$2 = {
-  appToken: string;
-  onMessage: (envelope: FlumeSlackEnvelope) => void;
-  onConnected: () => void;
-  onDisconnected: () => void;
-  onLog?: FlumeLogHandler;
-  deps: Deps;
-};
-declare class FlumeSlackSocketMode {
-  private readonly props;
-  private readonly log;
-  private ws;
-  stopped: boolean;
-  private pendingResolve;
-  private pendingResolved;
-  constructor(props: Props$2);
-  connect(): Promise<FlumeConnectionError | FlumeHttpError | null>;
-  disconnect(): void;
-  isConnected(): boolean;
-  private openSocket;
-  private completeConnect;
-  private onMessage;
-  private onClose;
-  private onError;
-}
-//#endregion
-//#region lib/slack/slack-seen-cache.d.ts
-type Props$1 = {
-  maxSize: number;
-};
-/**
- * Slack envelope_id の LRU 風キャッシュ。Slack は ack 失敗時に同じ envelope を再送するため、
- * source レイヤで handler への重複配送を防ぐ
- */
-declare class FlumeSlackSeenCache {
-  private readonly props;
-  private seen;
-  constructor(props: Props$1);
-  has(envelopeId: string): boolean;
-  add(envelopeId: string): void;
-  trim(): void;
-  get size(): number;
-}
-//#endregion
-//#region lib/slack/obtain-slack-url.d.ts
-type Props = {
-  appToken: string;
-  onLog?: FlumeLogHandler;
-  deps: Pick<FlumeRuntimeDeps, "fetch" | "now">;
-};
-declare function obtainSlackUrl(props: Props): Promise<string | FlumeHttpError>;
+declare function flumeExtractSlackMeta(envelope: FlumeSlackEnvelope): Record<string, string>;
 //#endregion
-export { FlumeSlackConnectionResponseSchema, FlumeSlackEnvelopeSchema, FlumeSlackSeenCache, FlumeSlackSocketMode, FlumeSlackSource, extractSlackMeta, obtainSlackUrl };
+export { FlumeSlackSource, flumeExtractSlackMeta };