@interactive-inc/flume 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,66 +1,104 @@
-import { a as FlumeSlackEnvelopeSchema, i as FlumeSlackConnectionResponseSchema, n as FlumeGatewayMessageSchema, r as FlumeGitHubNotificationSchema, t as FlumeLogger } from "./logger-B9E8zvgj.js";
-import { a as FlumeParseError, i as resolveFlumeReconnectConfig, o as FlumeConnectionError, r as FlumeReconnector } from "./safe-json-parse-D8t_4Vm_.js";
-import { i as FlumeHttpError, n as FlumeSlackSocketMode, r as obtainSlackUrl, t as FlumeSlackSource } from "./slack-source-CszepStG.js";
-import { a as FlumeDiscordGatewaySession, i as parseDiscordGatewayMessage, n as FlumeDiscordGatewayIntents, o as FlumeDiscordHeartbeat, r as FlumeDiscordGateway, t as FlumeDiscordSource } from "./discord-source-Q4JRIbNs.js";
-import { n as FlumeGitHubPoller, r as FlumeGitHubSeenCache, t as FlumeGitHubSource } from "./github-source-D7Z1RUbe.js";
-//#region lib/deps.ts
-function createFlumeDefaultDeps() {
-	return {
-		fetch: (url, init) => globalThis.fetch(url, init),
-		WebSocket: globalThis.WebSocket,
-		now: () => Date.now(),
-		random: () => Math.random(),
-		setTimeout: (fn, ms) => globalThis.setTimeout(fn, ms),
-		clearTimeout: (id) => globalThis.clearTimeout(id),
-		setInterval: (fn, ms) => globalThis.setInterval(fn, ms),
-		clearInterval: (id) => globalThis.clearInterval(id)
-	};
-}
+import { n as createFlumeDefaultDeps, t as FlumeLogger } from "./logger-CpGB9WO_.js";
+import { a as FlumeConnectionError, i as FlumeParseError, n as FlumeReconnector, r as resolveFlumeReconnectConfig, t as scheduleFlumeReconnect } from "./schedule-reconnect-DSxZJG3h.js";
+import { t as FlumeHttpError } from "./http-error-BtXonO-W.js";
+//#region lib/flume-stopped.ts
+/**
+* 停止済みの終端状態。最終ステータスのスナップショットのみ観測できる
+*/
+var FlumeStopped = class {
+	props;
+	constructor(props) {
+		this.props = props;
+		Object.freeze(this);
+	}
+	statuses() {
+		return this.props.finalStatuses;
+	}
+};
 //#endregion
-//#region lib/flume.ts
+//#region lib/flume-running.ts
 /**
-* 共有設定を持つ DI コンテナ。各 Source に共通の deps / logging / reconnect を注入する
+* 稼働中の Flume。stop() で FlumeStopped へ遷移する。signal が abort されると自動 stop
 */
-var Flume = class {
+var FlumeRunning = class {
 	props;
-	resolvedDeps;
+	stopPromise = null;
+	onAbort;
 	constructor(props) {
 		this.props = props;
-		this.resolvedDeps = {
-			...createFlumeDefaultDeps(),
-			...props.deps
+		this.onAbort = () => {
+			this.stop();
 		};
+		if (props.signal) props.signal.addEventListener("abort", this.onAbort, { once: true });
 	}
-	discord(options) {
-		return new FlumeDiscordSource({
-			onLog: this.props.onLog,
-			onStatus: this.props.onStatus,
-			reconnect: this.props.reconnect,
-			signal: this.props.signal,
-			deps: this.resolvedDeps,
-			...options
-		});
+	stop() {
+		if (this.stopPromise) return this.stopPromise;
+		this.stopPromise = this.runStop();
+		return this.stopPromise;
 	}
-	slack(options) {
-		return new FlumeSlackSource({
-			onLog: this.props.onLog,
-			onStatus: this.props.onStatus,
-			reconnect: this.props.reconnect,
-			signal: this.props.signal,
-			deps: this.resolvedDeps,
-			...options
-		});
+	statuses() {
+		return this.props.sources.map((source) => ({
+			name: source.name,
+			status: source.status()
+		}));
+	}
+	async runStop() {
+		await Promise.allSettled(this.props.sources.map((source) => source.stop()));
+		this.props.signal?.removeEventListener("abort", this.onAbort);
+		return new FlumeStopped({ finalStatuses: this.props.sources.map((source) => ({
+			name: source.name,
+			status: source.status()
+		})) });
+	}
+};
+//#endregion
+//#region lib/flume.ts
+/**
+* 起動前の Flume。start() で FlumeRunning へ遷移する
+*/
+var Flume = class {
+	props;
+	consumed = false;
+	constructor(props) {
+		this.props = props;
 	}
-	github(options) {
-		return new FlumeGitHubSource({
-			onLog: this.props.onLog,
-			onStatus: this.props.onStatus,
-			reconnect: this.props.reconnect,
-			signal: this.props.signal,
-			deps: this.resolvedDeps,
-			...options
+	async start(handler) {
+		if (this.consumed) return /* @__PURE__ */ new Error("Flume.start: already started");
+		if (this.props.signal?.aborted) return /* @__PURE__ */ new Error("Flume.start: signal already aborted");
+		this.consumed = true;
+		const settled = await Promise.allSettled(this.props.sources.map((source) => source.start(handler)));
+		const failures = [];
+		const started = [];
+		for (let i = 0; i < settled.length; i++) {
+			const result = settled[i];
+			const source = this.props.sources[i];
+			if (result === void 0 || source === void 0) continue;
+			if (result.status === "rejected") {
+				const reason = result.reason;
+				failures.push({
+					name: source.name,
+					error: reason instanceof Error ? reason : new Error(String(reason))
+				});
+			} else if (result.value instanceof Error) failures.push({
+				name: source.name,
+				error: result.value
+			});
+			else started.push(source);
+		}
+		if (failures.length > 0) {
+			await Promise.allSettled(started.map((source) => source.stop()));
+			const detail = failures.map((f) => `${f.name}: ${f.error.message}`).join("; ");
+			return /* @__PURE__ */ new Error(`Flume.start: ${failures.length} source(s) failed: ${detail}`);
+		}
+		if (this.props.signal?.aborted) {
+			await Promise.allSettled(this.props.sources.map((source) => source.stop()));
+			return /* @__PURE__ */ new Error("Flume.start: aborted during start");
+		}
+		return new FlumeRunning({
+			sources: this.props.sources,
+			signal: this.props.signal
 		});
 	}
 };
 //#endregion
-export { Flume, FlumeConnectionError, FlumeDiscordGateway, FlumeDiscordGatewayIntents, FlumeDiscordGatewaySession, FlumeDiscordHeartbeat, FlumeDiscordSource, FlumeGatewayMessageSchema, FlumeGitHubNotificationSchema, FlumeGitHubPoller, FlumeGitHubSeenCache, FlumeGitHubSource, FlumeHttpError, FlumeLogger, FlumeParseError, FlumeReconnector, FlumeSlackConnectionResponseSchema, FlumeSlackEnvelopeSchema, FlumeSlackSocketMode, FlumeSlackSource, createFlumeDefaultDeps, obtainSlackUrl, parseDiscordGatewayMessage, resolveFlumeReconnectConfig };
+export { Flume, FlumeConnectionError, FlumeHttpError, FlumeLogger, FlumeParseError, FlumeReconnector, FlumeRunning, FlumeStopped, createFlumeDefaultDeps, resolveFlumeReconnectConfig, scheduleFlumeReconnect };

package/dist/logger-CpGB9WO_.js

@@ -0,0 +1,49 @@
+//#region lib/deps.ts
+function createFlumeDefaultDeps() {
+	return {
+		fetch: (url, init) => globalThis.fetch(url, init),
+		WebSocket: globalThis.WebSocket,
+		now: () => Date.now(),
+		random: () => Math.random(),
+		setTimeout: (fn, ms) => globalThis.setTimeout(fn, ms),
+		clearTimeout: (id) => globalThis.clearTimeout(id),
+		setInterval: (fn, ms) => globalThis.setInterval(fn, ms),
+		clearInterval: (id) => globalThis.clearInterval(id)
+	};
+}
+//#endregion
+//#region lib/logger.ts
+var FlumeLogger = class {
+	props;
+	constructor(props) {
+		this.props = props;
+		Object.freeze(this);
+	}
+	debug(entry) {
+		this.emit("debug", entry);
+	}
+	info(entry) {
+		this.emit("info", entry);
+	}
+	warn(entry) {
+		this.emit("warn", entry);
+	}
+	error(entry) {
+		this.emit("error", entry);
+	}
+	emit(level, input) {
+		if (!this.props.handler) return;
+		const log = {
+			level,
+			source: this.props.source,
+			action: input.action,
+			message: input.message,
+			timestamp: this.props.deps.now(),
+			error: input.error,
+			detail: input.detail
+		};
+		this.props.handler(log);
+	}
+};
+//#endregion
+export { createFlumeDefaultDeps as n, FlumeLogger as t };

package/dist/parse-error-BAiCLRmk.d.ts

@@ -0,0 +1,6 @@
+//#region lib/errors/parse-error.d.ts
+declare class FlumeParseError extends Error {
+  constructor(message: string);
+}
+//#endregion
+export { FlumeParseError as t };

package/dist/safe-fetch-30ZzOKHL.js

@@ -0,0 +1,20 @@
+//#region lib/utils/safe-fetch.ts
+/**
+* deps.fetch を try/catch で包み、ネットワーク例外を Error として返す。
+* HTTP ステータスの解釈や追加の副作用 (リトライ計数等) は呼び出し側の責務
+*/
+async function safeFetch(props) {
+	try {
+		return await props.fetch(props.url, props.init);
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		props.log.error({
+			action: "http.error",
+			message: `network error: ${err.message}`,
+			error: err
+		});
+		return err;
+	}
+}
+//#endregion
+export { safeFetch as t };

package/dist/safe-json-parse-WCg_x1JS.js

@@ -0,0 +1,15 @@
+//#region lib/utils/is-record.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region lib/utils/safe-json-parse.ts
+function safeJsonParse(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { isRecord as n, safeJsonParse as t };

package/dist/{safe-json-parse-D8t_4Vm_.js → schedule-reconnect-DSxZJG3h.js}

@@ -64,18 +64,30 @@ var FlumeReconnector = class {
 	}
 };
 //#endregion
-//#region lib/utils/is-record.ts
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-//#endregion
-//#region lib/utils/safe-json-parse.ts
-function safeJsonParse(raw) {
-	try {
-		return JSON.parse(raw);
-	} catch {
-		return null;
+//#region lib/schedule-reconnect.ts
+/**
+* 接続が落ちた際の共通再接続スケジューラ。reconnector の状態を見て次回試行を予約し、
+* 試行回数が尽きていれば disconnected に落とす
+*/
+function scheduleFlumeReconnect(props) {
+	if (!props.reconnector || props.reconnector.aborted) {
+		props.setStatus("disconnected");
+		return;
+	}
+	props.setStatus("reconnecting");
+	const delay = props.reconnector.schedule(props.retry);
+	if (delay === -1) {
+		props.log.error({
+			action: "reconnect.exhausted",
+			message: `gave up after ${props.reconnector.attempt} attempts`
+		});
+		props.setStatus("disconnected");
+		return;
 	}
+	props.log.info({
+		action: "reconnect.scheduled",
+		message: `next attempt in ${Math.round(delay)}ms`
+	});
 }
 //#endregion
-export { FlumeParseError as a, resolveFlumeReconnectConfig as i, isRecord as n, FlumeConnectionError as o, FlumeReconnector as r, safeJsonParse as t };
+export { FlumeConnectionError as a, FlumeParseError as i, FlumeReconnector as n, resolveFlumeReconnectConfig as r, scheduleFlumeReconnect as t };

package/dist/serial-queue-ExmlnpzQ.js

@@ -0,0 +1,16 @@
+//#region lib/utils/serial-queue.ts
+/**
+* 投入順を保ったまま task を直列実行する。各 task は前の完了を待ってから走る。
+* task が throw しても後続には伝播しない (キュー自体は止まらない)
+*/
+var FlumeSerialQueue = class {
+	chain = Promise.resolve();
+	add(task) {
+		this.chain = this.chain.then(task).catch(() => {});
+	}
+	async drain() {
+		await this.chain;
+	}
+};
+//#endregion
+export { FlumeSerialQueue as t };

package/dist/slack.d.ts

@@ -1,23 +1,84 @@
-import { g as FlumeSlackSourceOptions, h as FlumeSlackEnvelope, o as FlumeHandler, y as FlumeStatus } from "./types-BVQSU336.js";
+import { T as FlumeSlackConnectionResponseSchema, c as FlumeLogHandler, g as FlumeSlackSourceOptions, h as FlumeSlackEnvelope, o as FlumeHandler, p as FlumeRuntimeDeps, w as FlumeSlackEnvelopeSchema, x as FlumeStatus } from "./types-tnOPBc1p.js";
+import { t as FlumeConnectionError } from "./connection-error-BOk97djj.js";
+import { t as FlumeHttpError } from "./http-error-K-Ym4lfK.js";
 
 //#region lib/slack/slack-source.d.ts
 declare class FlumeSlackSource {
   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;
   constructor(options: FlumeSlackSourceOptions);
-  start(handler: FlumeHandler): Promise<void>;
+  start(handler: FlumeHandler): Promise<void | Error>;
   stop(): Promise<void>;
   status(): FlumeStatus;
   private connectInternal;
   private handleMessage;
   private scheduleReconnect;
   private setStatus;
-  static extractMeta(envelope: FlumeSlackEnvelope): Record<string, string>;
 }
 //#endregion
-export { FlumeSlackSource };
+//#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>;
+//#endregion
+export { FlumeSlackConnectionResponseSchema, FlumeSlackEnvelopeSchema, FlumeSlackSeenCache, FlumeSlackSocketMode, FlumeSlackSource, extractSlackMeta, obtainSlackUrl };