@interactive-inc/flume 0.1.0

package/dist/github-source-D7Z1RUbe.js

@@ -0,0 +1,280 @@
+import { r as FlumeGitHubNotificationSchema, t as FlumeLogger } from "./logger-B9E8zvgj.js";
+//#region lib/github/github-seen-cache.ts
+var FlumeGitHubSeenCache = class {
+	props;
+	seen = /* @__PURE__ */ new Map();
+	constructor(props) {
+		this.props = props;
+	}
+	has(id, updatedAt) {
+		return this.seen.get(id) === updatedAt;
+	}
+	add(id, updatedAt) {
+		this.seen.set(id, updatedAt);
+	}
+	trim() {
+		if (this.seen.size <= this.props.maxSize) return;
+		const entries = [...this.seen.entries()];
+		this.seen = new Map(entries.slice(entries.length - this.props.maxSize));
+	}
+	get size() {
+		return this.seen.size;
+	}
+};
+//#endregion
+//#region lib/github/github-poller.ts
+var FlumeGitHubPoller = class {
+	props;
+	log;
+	cache = new FlumeGitHubSeenCache({ maxSize: 5e3 });
+	timer = null;
+	since = null;
+	bootstrapped = false;
+	stopped = false;
+	consecutiveErrors = 0;
+	constructor(props) {
+		this.props = props;
+		this.log = new FlumeLogger({
+			source: "github.poller",
+			handler: props.onLog,
+			deps: props.deps
+		});
+	}
+	async start() {
+		this.stopped = false;
+		this.log.info({
+			action: "start",
+			message: `polling every ${this.props.interval}s`
+		});
+		await this.poll();
+		this.timer = this.props.deps.setInterval(() => {
+			this.poll().catch((err) => {
+				this.log.error({
+					action: "poll.unhandled",
+					message: "unexpected error in poll loop",
+					error: err instanceof Error ? err : new Error(String(err))
+				});
+			});
+		}, this.props.interval * 1e3);
+	}
+	stop() {
+		this.log.info({
+			action: "stop",
+			message: "stopping poller"
+		});
+		this.stopped = true;
+		if (this.timer !== null) {
+			this.props.deps.clearInterval(this.timer);
+			this.timer = null;
+		}
+	}
+	async poll() {
+		const params = new URLSearchParams({ all: "false" });
+		if (this.since) params.set("since", this.since);
+		const url = `https://api.github.com/notifications?${params}`;
+		this.log.debug({
+			action: "http.request",
+			message: `GET ${url}`
+		});
+		const response = await this.safeFetch(url);
+		if (response instanceof Error) return;
+		this.log.debug({
+			action: "http.response",
+			message: `GET ${response.status}`,
+			detail: {
+				status: response.status,
+				url
+			}
+		});
+		if (!response.ok) {
+			this.consecutiveErrors++;
+			this.log.error({
+				action: "http.error",
+				message: `HTTP ${response.status} (consecutive=${this.consecutiveErrors})`
+			});
+			if (this.consecutiveErrors >= 3) this.props.onDisconnected(`HTTP ${response.status}`);
+			return;
+		}
+		this.consecutiveErrors = 0;
+		const body = await response.json();
+		if (!Array.isArray(body)) {
+			this.log.warn({
+				action: "http.body",
+				message: "response body is not an array, dropping",
+				detail: { bodyType: typeof body }
+			});
+			return;
+		}
+		this.processNotifications(body);
+	}
+	processNotifications(raw) {
+		let dropped = 0;
+		const notifications = raw.flatMap((item) => {
+			const parsed = FlumeGitHubNotificationSchema.safeParse(item);
+			if (!parsed.success) {
+				dropped++;
+				this.log.warn({
+					action: "parse.skip",
+					message: "notification did not match schema",
+					detail: { issues: parsed.error.issues.map((i) => ({
+						path: i.path,
+						message: i.message
+					})) }
+				});
+				return [];
+			}
+			return [parsed.data];
+		});
+		if (dropped > 0) this.log.warn({
+			action: "parse.summary",
+			message: `${dropped}/${raw.length} notifications dropped by schema`
+		});
+		if (!this.bootstrapped) {
+			this.bootstrapped = true;
+			for (const notification of notifications) this.cache.add(notification.id, notification.updated_at);
+			this.since = new Date(this.props.deps.now()).toISOString();
+			this.log.info({
+				action: "bootstrap",
+				message: `seeded ${notifications.length} existing notifications`
+			});
+			this.props.onConnected();
+			return;
+		}
+		const fresh = [];
+		for (const notification of notifications) {
+			if (this.cache.has(notification.id, notification.updated_at)) continue;
+			this.cache.add(notification.id, notification.updated_at);
+			fresh.push(notification);
+		}
+		this.cache.trim();
+		this.since = new Date(this.props.deps.now()).toISOString();
+		if (fresh.length > 0) {
+			this.log.info({
+				action: "poll.fresh",
+				message: `${fresh.length} new notifications`
+			});
+			this.props.onNotifications(fresh);
+		} else this.log.debug({
+			action: "poll.idle",
+			message: "0 new notifications"
+		});
+	}
+	async safeFetch(url) {
+		try {
+			return await this.props.deps.fetch(url, { headers: {
+				Authorization: `Bearer ${this.props.token}`,
+				Accept: "application/vnd.github+json",
+				"X-GitHub-Api-Version": "2022-11-28"
+			} });
+		} catch (error) {
+			this.consecutiveErrors++;
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.log.error({
+				action: "http.error",
+				message: `network error (consecutive=${this.consecutiveErrors})`,
+				error: err
+			});
+			if (this.consecutiveErrors >= 3) this.props.onDisconnected("network error");
+			return err;
+		}
+	}
+};
+//#endregion
+//#region lib/github/github-source.ts
+var FlumeGitHubSource = class FlumeGitHubSource {
+	options;
+	poller = null;
+	currentStatus = "disconnected";
+	log;
+	deps;
+	constructor(options) {
+		this.options = options;
+		this.deps = options.deps;
+		this.log = new FlumeLogger({
+			source: "github",
+			handler: options.onLog,
+			deps: this.deps
+		});
+	}
+	async start(handler) {
+		if (this.options.signal?.aborted) return;
+		this.options.signal?.addEventListener("abort", () => this.stop(), { once: true });
+		this.log.info({
+			action: "start",
+			message: "starting GitHub source"
+		});
+		this.setStatus("connecting");
+		this.poller = new FlumeGitHubPoller({
+			token: this.options.token,
+			interval: this.options.pollInterval ?? 60,
+			onLog: this.options.onLog,
+			deps: this.deps,
+			onNotifications: (notifications) => this.handleNotifications(handler, notifications),
+			onConnected: () => this.setStatus("connected"),
+			onDisconnected: (detail) => this.setStatus("disconnected", detail)
+		});
+		try {
+			await this.poller.start();
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.log.error({
+				action: "start.failed",
+				message: err.message,
+				error: err
+			});
+			this.setStatus("disconnected");
+		}
+	}
+	async stop() {
+		this.log.info({
+			action: "stop",
+			message: "stopping GitHub source"
+		});
+		this.poller?.stop();
+		this.poller = null;
+		this.setStatus("disconnected");
+	}
+	status() {
+		return this.currentStatus;
+	}
+	handleNotifications(handler, notifications) {
+		for (const notification of notifications) {
+			const event = {
+				source: "github",
+				type: "notification",
+				data: notification,
+				meta: FlumeGitHubSource.extractMeta(notification),
+				receivedAt: this.deps.now()
+			};
+			try {
+				handler(event);
+			} catch (err) {
+				this.log.error({
+					action: "handler.error",
+					message: "user handler threw",
+					error: err instanceof Error ? err : new Error(String(err))
+				});
+			}
+		}
+	}
+	setStatus(next, detail) {
+		if (this.currentStatus === next) return;
+		this.log.info({
+			action: "status",
+			message: `${this.currentStatus} → ${next}${detail ? ` (${detail})` : ""}`
+		});
+		this.currentStatus = next;
+		this.options.onStatus?.(next, detail);
+	}
+	static extractMeta(notification) {
+		return {
+			event_type: "notification",
+			reason: notification.reason,
+			subject_type: notification.subject.type,
+			repository: notification.repository.full_name,
+			thread_id: notification.id
+		};
+	}
+};
+//#endregion
+export { FlumeGitHubPoller as n, FlumeGitHubSeenCache as r, FlumeGitHubSource as t };

package/dist/github.d.ts

@@ -0,0 +1,19 @@
+import { a as FlumeGitHubSourceOptions, i as FlumeGitHubNotification, o as FlumeHandler, y as FlumeStatus } from "./types-BVQSU336.js";
+
+//#region lib/github/github-source.d.ts
+declare class FlumeGitHubSource {
+  private readonly options;
+  private poller;
+  private currentStatus;
+  private readonly log;
+  private readonly deps;
+  constructor(options: FlumeGitHubSourceOptions);
+  start(handler: FlumeHandler): Promise<void>;
+  stop(): Promise<void>;
+  status(): FlumeStatus;
+  private handleNotifications;
+  private setStatus;
+  static extractMeta(notification: FlumeGitHubNotification): Record<string, string>;
+}
+//#endregion
+export { FlumeGitHubSource };

package/dist/github.js

@@ -0,0 +1,2 @@
+import { t as FlumeGitHubSource } from "./github-source-D7Z1RUbe.js";
+export { FlumeGitHubSource };

package/dist/index.d.ts

@@ -0,0 +1,278 @@
+import { C as FlumeGitHubNotificationSchema, S as FlumeGatewayMessageSchema, T as FlumeSlackEnvelopeSchema, _ as FlumeSourceName, a as FlumeGitHubSourceOptions, b as FlumeStatusHandler, c as FlumeLogHandler, d as FlumeReconnectConfig, f as FlumeReconnectOptions, g as FlumeSlackSourceOptions, h as FlumeSlackEnvelope, i as FlumeGitHubNotification, l as FlumeLogInput, m as FlumeSlackConnectionResponse, n as FlumeEvent, o as FlumeHandler, p as FlumeRuntimeDeps, r as FlumeGatewayMessage, s as FlumeLog, t as FlumeDiscordSourceOptions, u as FlumeLogLevel, v as FlumeSourceOptions, w as FlumeSlackConnectionResponseSchema, x as FlumeTimerHandle, y as FlumeStatus } from "./types-BVQSU336.js";
+import { FlumeDiscordSource } from "./discord.js";
+import { FlumeGitHubSource } from "./github.js";
+import { FlumeSlackSource } from "./slack.js";
+
+//#region lib/deps.d.ts
+declare function createFlumeDefaultDeps(): FlumeRuntimeDeps;
+//#endregion
+//#region lib/errors/connection-error.d.ts
+declare class FlumeConnectionError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region lib/errors/http-error.d.ts
+type Props$10 = {
+  message: string;
+  status: number;
+};
+declare class FlumeHttpError extends Error {
+  readonly status: number;
+  constructor(props: Props$10);
+}
+//#endregion
+//#region lib/errors/parse-error.d.ts
+declare class FlumeParseError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region lib/logger.d.ts
+type Props$9 = {
+  source: string;
+  handler?: FlumeLogHandler;
+  deps: Pick<FlumeRuntimeDeps, "now">;
+};
+declare class FlumeLogger {
+  private readonly props;
+  constructor(props: Props$9);
+  debug(entry: FlumeLogInput): void;
+  info(entry: FlumeLogInput): void;
+  warn(entry: FlumeLogInput): void;
+  error(entry: FlumeLogInput): void;
+  private emit;
+}
+//#endregion
+//#region lib/reconnect-config.d.ts
+declare function resolveFlumeReconnectConfig(input: boolean | FlumeReconnectOptions | undefined): FlumeReconnectConfig | null;
+//#endregion
+//#region lib/reconnector.d.ts
+type Props$8 = {
+  maxAttempts: number;
+  baseDelay: number;
+  maxDelay: number;
+  deps: Pick<FlumeRuntimeDeps, "setTimeout" | "clearTimeout" | "random">;
+};
+declare class FlumeReconnector {
+  private readonly props;
+  attempt: number;
+  aborted: boolean;
+  private timer;
+  constructor(props: Props$8);
+  schedule(fn: () => void): number;
+  reset(): void;
+  cancel(): void;
+  private nextDelay;
+}
+//#endregion
+//#region lib/flume.d.ts
+type Props$7 = {
+  onLog?: FlumeLogHandler;
+  onStatus?: FlumeStatusHandler;
+  reconnect?: boolean | FlumeReconnectOptions;
+  signal?: AbortSignal;
+  deps?: Partial<FlumeRuntimeDeps>;
+};
+/**
+ * 共有設定を持つ DI コンテナ。各 Source に共通の deps / logging / reconnect を注入する
+ */
+declare class Flume {
+  private readonly props;
+  private readonly resolvedDeps;
+  constructor(props: Props$7);
+  discord(options: {
+    token: string;
+    intents?: number;
+  }): FlumeDiscordSource;
+  slack(options: {
+    appToken: string;
+    botToken?: string;
+  }): FlumeSlackSource;
+  github(options: {
+    token: string;
+    pollInterval?: number;
+  }): FlumeGitHubSource;
+}
+//#endregion
+//#region lib/discord/discord-gateway-intents.d.ts
+declare const FlumeDiscordGatewayIntents: {
+  readonly Guilds: number;
+  readonly GuildMembers: number;
+  readonly GuildModeration: number;
+  readonly GuildExpressions: number;
+  readonly GuildIntegrations: number;
+  readonly GuildWebhooks: number;
+  readonly GuildInvites: number;
+  readonly GuildVoiceStates: number;
+  readonly GuildPresences: number;
+  readonly GuildMessages: number;
+  readonly GuildMessageReactions: number;
+  readonly GuildMessageTyping: number;
+  readonly DirectMessages: number;
+  readonly DirectMessageReactions: number;
+  readonly DirectMessageTyping: number;
+  readonly MessageContent: number;
+  readonly GuildScheduledEvents: number;
+  readonly AutoModerationConfiguration: number;
+  readonly AutoModerationExecution: number;
+  readonly GuildMessagePolls: number;
+  readonly DirectMessagePolls: number;
+};
+//#endregion
+//#region lib/discord/discord-gateway-session.d.ts
+type Props$6 = {
+  sessionId: string | null;
+  resumeUrl: string | null;
+  seq: number | null;
+};
+declare class FlumeDiscordGatewaySession {
+  readonly sessionId: string | null;
+  readonly resumeUrl: string | null;
+  readonly seq: number | null;
+  constructor(props: Props$6);
+  static empty(): FlumeDiscordGatewaySession;
+  canResume(): boolean;
+  withSeq(seq: number): FlumeDiscordGatewaySession;
+  withReady(sessionId: string, resumeUrl: string): FlumeDiscordGatewaySession;
+  withReset(): FlumeDiscordGatewaySession;
+}
+//#endregion
+//#region lib/discord/discord-gateway.d.ts
+type Deps$2 = Pick<FlumeRuntimeDeps, "WebSocket" | "setInterval" | "clearInterval" | "setTimeout" | "random" | "now">;
+type Props$5 = {
+  token: string;
+  intents: number;
+  onDispatch: (event: string, data: Record<string, unknown>) => void;
+  onStatus: (status: "connected" | "disconnected") => void;
+  onLog?: FlumeLogHandler;
+  deps: Deps$2;
+};
+declare class FlumeDiscordGateway {
+  private readonly props;
+  private readonly log;
+  private ws;
+  private heartbeat;
+  session: FlumeDiscordGatewaySession;
+  stopped: boolean;
+  private pendingResolve;
+  private pendingResolved;
+  constructor(props: Props$5);
+  connect(url?: string): Promise<FlumeConnectionError | null>;
+  disconnect(): void;
+  isConnected(): boolean;
+  private completeConnect;
+  private onMessage;
+  private onHello;
+  private onHeartbeatAck;
+  private onHeartbeatRequest;
+  private onReconnectRequest;
+  private onInvalidSession;
+  private onDispatch;
+  private onClose;
+  private onError;
+  private send;
+  private sendIdentify;
+  private sendResume;
+}
+//#endregion
+//#region lib/discord/discord-heartbeat.d.ts
+type Props$4 = {
+  onSend: () => void;
+  onZombie: () => void;
+  deps: Pick<FlumeRuntimeDeps, "setInterval" | "clearInterval">;
+};
+declare class FlumeDiscordHeartbeat {
+  private readonly props;
+  private timer;
+  private ackReceived;
+  constructor(props: Props$4);
+  start(intervalMs: number): void;
+  stop(): void;
+  ack(): void;
+  isRunning(): boolean;
+}
+//#endregion
+//#region lib/discord/parse-discord-gateway-message.d.ts
+declare function parseDiscordGatewayMessage(raw: string): FlumeGatewayMessage | FlumeParseError;
+//#endregion
+//#region lib/slack/slack-socket-mode.d.ts
+type Deps$1 = Pick<FlumeRuntimeDeps, "WebSocket" | "fetch" | "now">;
+type Props$3 = {
+  appToken: string;
+  onMessage: (envelope: FlumeSlackEnvelope) => void;
+  onConnected: () => void;
+  onDisconnected: () => void;
+  onLog?: FlumeLogHandler;
+  deps: Deps$1;
+};
+declare class FlumeSlackSocketMode {
+  private readonly props;
+  private readonly log;
+  private ws;
+  stopped: boolean;
+  private pendingResolve;
+  private pendingResolved;
+  constructor(props: Props$3);
+  connect(): Promise<FlumeConnectionError | FlumeHttpError | null>;
+  disconnect(): void;
+  isConnected(): boolean;
+  private openSocket;
+  private completeConnect;
+  private onMessage;
+  private onClose;
+  private onError;
+}
+//#endregion
+//#region lib/slack/obtain-slack-url.d.ts
+type Props$2 = {
+  appToken: string;
+  onLog?: FlumeLogHandler;
+  deps: Pick<FlumeRuntimeDeps, "fetch" | "now">;
+};
+declare function obtainSlackUrl(props: Props$2): Promise<string | FlumeHttpError>;
+//#endregion
+//#region lib/github/github-poller.d.ts
+type Deps = Pick<FlumeRuntimeDeps, "fetch" | "setInterval" | "clearInterval" | "now">;
+type Props$1 = {
+  token: string;
+  interval: number;
+  onNotifications: (notifications: FlumeGitHubNotification[]) => void;
+  onConnected: () => void;
+  onDisconnected: (detail: string) => void;
+  onLog?: FlumeLogHandler;
+  deps: Deps;
+};
+declare class FlumeGitHubPoller {
+  private readonly props;
+  private readonly log;
+  private readonly cache;
+  private timer;
+  private since;
+  private bootstrapped;
+  stopped: boolean;
+  private consecutiveErrors;
+  constructor(props: Props$1);
+  start(): Promise<void>;
+  stop(): void;
+  private poll;
+  private processNotifications;
+  private safeFetch;
+}
+//#endregion
+//#region lib/github/github-seen-cache.d.ts
+type Props = {
+  maxSize: number;
+};
+declare class FlumeGitHubSeenCache {
+  private readonly props;
+  private seen;
+  constructor(props: Props);
+  has(id: string, updatedAt: string): boolean;
+  add(id: string, updatedAt: string): void;
+  trim(): void;
+  get size(): number;
+}
+//#endregion
+//#region lib/index.d.ts
+type FlumeSource = FlumeDiscordSource | FlumeSlackSource | FlumeGitHubSource;
+//#endregion
+export { Flume, FlumeConnectionError, FlumeDiscordGateway, FlumeDiscordGatewayIntents, FlumeDiscordGatewaySession, FlumeDiscordHeartbeat, FlumeDiscordSource, type FlumeDiscordSourceOptions, type FlumeEvent, type FlumeGatewayMessage, FlumeGatewayMessageSchema, type FlumeGitHubNotification, FlumeGitHubNotificationSchema, FlumeGitHubPoller, FlumeGitHubSeenCache, FlumeGitHubSource, type FlumeGitHubSourceOptions, type FlumeHandler, FlumeHttpError, type FlumeLog, type FlumeLogHandler, type FlumeLogInput, type FlumeLogLevel, FlumeLogger, FlumeParseError, type FlumeReconnectConfig, type FlumeReconnectOptions, FlumeReconnector, type FlumeRuntimeDeps, type FlumeSlackConnectionResponse, FlumeSlackConnectionResponseSchema, type FlumeSlackEnvelope, FlumeSlackEnvelopeSchema, FlumeSlackSocketMode, FlumeSlackSource, type FlumeSlackSourceOptions, FlumeSource, type FlumeSourceName, type FlumeSourceOptions, type FlumeStatus, type FlumeStatusHandler, type FlumeTimerHandle, createFlumeDefaultDeps, obtainSlackUrl, parseDiscordGatewayMessage, resolveFlumeReconnectConfig };

package/dist/index.js

@@ -0,0 +1,66 @@
+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)
+	};
+}
+//#endregion
+//#region lib/flume.ts
+/**
+* 共有設定を持つ DI コンテナ。各 Source に共通の deps / logging / reconnect を注入する
+*/
+var Flume = class {
+	props;
+	resolvedDeps;
+	constructor(props) {
+		this.props = props;
+		this.resolvedDeps = {
+			...createFlumeDefaultDeps(),
+			...props.deps
+		};
+	}
+	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
+		});
+	}
+	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
+		});
+	}
+	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
+		});
+	}
+};
+//#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 };