@interactive-inc/flume 0.1.0 → 0.2.0

package/dist/slack-source-CszepStG.js

@@ -1,400 +0,0 @@
-import { a as FlumeSlackEnvelopeSchema, i as FlumeSlackConnectionResponseSchema, t as FlumeLogger } from "./logger-B9E8zvgj.js";
-import { a as FlumeParseError, i as resolveFlumeReconnectConfig, n as isRecord, o as FlumeConnectionError, r as FlumeReconnector, t as safeJsonParse } from "./safe-json-parse-D8t_4Vm_.js";
-//#region lib/errors/http-error.ts
-var FlumeHttpError = class extends Error {
-	status;
-	constructor(props) {
-		super(props.message);
-		this.name = "FlumeHttpError";
-		this.status = props.status;
-		Object.freeze(this);
-	}
-};
-//#endregion
-//#region lib/slack/obtain-slack-url.ts
-async function obtainSlackUrl(props) {
-	const log = new FlumeLogger({
-		source: "slack.url",
-		handler: props.onLog,
-		deps: props.deps
-	});
-	const url = "https://slack.com/api/apps.connections.open";
-	log.debug({
-		action: "http.request",
-		message: `POST ${url}`
-	});
-	const response = await safeFetch(props, url, log);
-	if (response instanceof FlumeHttpError) return response;
-	log.debug({
-		action: "http.response",
-		message: `POST ${response.status}`,
-		detail: {
-			status: response.status,
-			url
-		}
-	});
-	const raw = await response.json();
-	log.debug({
-		action: "http.body",
-		message: "apps.connections.open response",
-		detail: {
-			ok: isOk(raw),
-			error: errorField(raw)
-		}
-	});
-	const parsed = FlumeSlackConnectionResponseSchema.safeParse(raw);
-	if (!parsed.success) {
-		log.warn({
-			action: "parse.fail",
-			message: "apps.connections.open: invalid response shape",
-			detail: { issues: parsed.error.issues.map((i) => ({
-				path: i.path,
-				message: i.message
-			})) }
-		});
-		return new FlumeHttpError({
-			message: "apps.connections.open: invalid response shape",
-			status: response.status
-		});
-	}
-	if (!parsed.data.ok || !parsed.data.url) {
-		log.warn({
-			action: "api.fail",
-			message: `apps.connections.open failed: ${parsed.data.error ?? "no url"}`
-		});
-		return new FlumeHttpError({
-			message: `apps.connections.open failed: ${parsed.data.error ?? "no url"}`,
-			status: response.status
-		});
-	}
-	log.info({
-		action: "url.obtained",
-		message: "WSS URL obtained"
-	});
-	return parsed.data.url;
-}
-function isOk(raw) {
-	return raw?.ok;
-}
-function errorField(raw) {
-	return raw?.error;
-}
-async function safeFetch(props, url, log) {
-	try {
-		return await props.deps.fetch(url, {
-			method: "POST",
-			headers: { Authorization: `Bearer ${props.appToken}` }
-		});
-	} catch (error) {
-		const err = error instanceof Error ? error : new Error(String(error));
-		log.error({
-			action: "http.error",
-			message: `network error: ${err.message}`,
-			error: err
-		});
-		return new FlumeHttpError({
-			message: err.message,
-			status: 0
-		});
-	}
-}
-//#endregion
-//#region lib/slack/slack-socket-mode.ts
-function framePreview(raw) {
-	return raw.length > 200 ? `${raw.slice(0, 200)}... (${raw.length} bytes)` : raw;
-}
-var FlumeSlackSocketMode = class {
-	props;
-	log;
-	ws = null;
-	stopped = false;
-	pendingResolve = null;
-	pendingResolved = false;
-	constructor(props) {
-		this.props = props;
-		this.log = new FlumeLogger({
-			source: "slack.socket-mode",
-			handler: props.onLog,
-			deps: props.deps
-		});
-	}
-	async connect() {
-		this.log.info({
-			action: "connect.start",
-			message: "opening WebSocket connection"
-		});
-		const url = await obtainSlackUrl({
-			appToken: this.props.appToken,
-			onLog: this.props.onLog,
-			deps: this.props.deps
-		});
-		if (url instanceof FlumeHttpError) {
-			this.log.error({
-				action: "http.error",
-				message: url.message,
-				error: url
-			});
-			return url;
-		}
-		this.log.info({
-			action: "url.obtained",
-			message: "WebSocket URL obtained"
-		});
-		return this.openSocket(url);
-	}
-	disconnect() {
-		this.log.info({
-			action: "disconnect",
-			message: "stopping socket mode"
-		});
-		this.stopped = true;
-		if (this.ws) {
-			this.ws.close();
-			this.ws = null;
-		}
-	}
-	isConnected() {
-		return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
-	}
-	openSocket(url) {
-		this.pendingResolved = false;
-		return new Promise((resolve) => {
-			this.pendingResolve = resolve;
-			const socket = new this.props.deps.WebSocket(url);
-			this.ws = socket;
-			socket.addEventListener("message", (ev) => this.onMessage(String(ev.data), socket));
-			socket.addEventListener("close", (ev) => this.onClose(ev));
-			socket.addEventListener("error", () => this.onError());
-		});
-	}
-	completeConnect(error) {
-		if (this.pendingResolved || !this.pendingResolve) return;
-		this.pendingResolved = true;
-		this.pendingResolve(error);
-	}
-	onMessage(raw, socket) {
-		this.log.debug({
-			action: "ws.recv",
-			message: framePreview(raw)
-		});
-		const json = safeJsonParse(raw);
-		if (!isRecord(json)) {
-			this.log.error({
-				action: "ws.parse-error",
-				message: "invalid JSON",
-				error: new FlumeParseError(raw.slice(0, 200))
-			});
-			return;
-		}
-		if (json.type === "hello") {
-			this.log.info({
-				action: "ws.hello",
-				message: "connection ready"
-			});
-			this.props.onConnected();
-			this.completeConnect(null);
-			return;
-		}
-		if (json.type === "disconnect") {
-			const reason = typeof json.reason === "string" ? json.reason : "unknown";
-			this.log.info({
-				action: "ws.disconnect-requested",
-				message: `reason=${reason}`,
-				detail: { reason }
-			});
-			socket.close();
-			return;
-		}
-		if (typeof json.envelope_id === "string") {
-			this.log.debug({
-				action: "ws.ack",
-				message: `envelope_id=${json.envelope_id}`
-			});
-			const ack = JSON.stringify({ envelope_id: json.envelope_id });
-			socket.send(ack);
-			this.log.debug({
-				action: "ws.send",
-				message: framePreview(ack)
-			});
-		}
-		const envelope = FlumeSlackEnvelopeSchema.safeParse(json);
-		if (envelope.success) {
-			this.log.debug({
-				action: "envelope.recv",
-				message: `type=${envelope.data.type} envelope_id=${envelope.data.envelope_id}`,
-				detail: {
-					type: envelope.data.type,
-					envelopeId: envelope.data.envelope_id
-				}
-			});
-			this.props.onMessage(envelope.data);
-			return;
-		}
-		this.log.warn({
-			action: "envelope.parse-fail",
-			message: "unrecognised envelope shape, dropping",
-			detail: {
-				type: typeof json.type === "string" ? json.type : "unknown",
-				issues: envelope.error.issues.map((i) => ({
-					path: i.path,
-					message: i.message
-				}))
-			}
-		});
-	}
-	onClose(ev) {
-		this.log.info({
-			action: "ws.close",
-			message: `code=${ev.code} reason=${ev.reason || "none"}`
-		});
-		this.ws = null;
-		this.props.onDisconnected();
-		this.completeConnect(new FlumeConnectionError(`WebSocket closed before hello (code=${ev.code})`));
-	}
-	onError() {
-		this.log.error({
-			action: "ws.error",
-			message: "WebSocket error event"
-		});
-		this.completeConnect(new FlumeConnectionError("WebSocket connection error"));
-	}
-};
-//#endregion
-//#region lib/slack/slack-source.ts
-var FlumeSlackSource = class FlumeSlackSource {
-	options;
-	socket = null;
-	reconnector = null;
-	handler = null;
-	currentStatus = "disconnected";
-	log;
-	deps;
-	constructor(options) {
-		this.options = options;
-		this.deps = options.deps;
-		this.log = new FlumeLogger({
-			source: "slack",
-			handler: options.onLog,
-			deps: this.deps
-		});
-		const rc = resolveFlumeReconnectConfig(options.reconnect);
-		if (rc) this.reconnector = new FlumeReconnector({
-			...rc,
-			deps: this.deps
-		});
-	}
-	async start(handler) {
-		if (this.options.signal?.aborted) return;
-		this.options.signal?.addEventListener("abort", () => this.stop(), { once: true });
-		this.handler = handler;
-		this.log.info({
-			action: "start",
-			message: "starting Slack source"
-		});
-		await this.connectInternal();
-	}
-	async stop() {
-		this.log.info({
-			action: "stop",
-			message: "stopping Slack source"
-		});
-		if (this.reconnector && !this.reconnector.aborted) this.log.debug({
-			action: "reconnect.cancel",
-			message: "aborting reconnector"
-		});
-		this.reconnector?.cancel();
-		this.socket?.disconnect();
-		this.socket = null;
-		this.handler = null;
-		this.setStatus("disconnected");
-	}
-	status() {
-		return this.currentStatus;
-	}
-	async connectInternal() {
-		this.setStatus("connecting");
-		this.socket = new FlumeSlackSocketMode({
-			appToken: this.options.appToken,
-			onLog: this.options.onLog,
-			deps: this.deps,
-			onMessage: (envelope) => this.handleMessage(envelope),
-			onConnected: () => {
-				if (this.reconnector && this.reconnector.attempt > 0) this.log.info({
-					action: "reconnect.reset",
-					message: `cleared ${this.reconnector.attempt} attempts`
-				});
-				this.reconnector?.reset();
-				this.setStatus("connected");
-			},
-			onDisconnected: () => {
-				if (!this.socket?.stopped) this.scheduleReconnect();
-			}
-		});
-		const error = await this.socket.connect();
-		if (error instanceof Error) {
-			this.log.error({
-				action: "connect.failed",
-				message: error.message,
-				error
-			});
-			this.scheduleReconnect();
-		}
-	}
-	handleMessage(envelope) {
-		const event = {
-			source: "slack",
-			type: envelope.type,
-			data: envelope.payload,
-			meta: FlumeSlackSource.extractMeta(envelope),
-			receivedAt: this.deps.now()
-		};
-		try {
-			this.handler?.(event);
-		} catch (err) {
-			this.log.error({
-				action: "handler.error",
-				message: "user handler threw",
-				error: err instanceof Error ? err : new Error(String(err))
-			});
-		}
-	}
-	scheduleReconnect() {
-		if (!this.reconnector || this.reconnector.aborted) {
-			this.setStatus("disconnected");
-			return;
-		}
-		this.setStatus("reconnecting");
-		const delay = this.reconnector.schedule(() => this.connectInternal());
-		if (delay === -1) {
-			this.log.error({
-				action: "reconnect.exhausted",
-				message: `gave up after ${this.reconnector.attempt} attempts`
-			});
-			this.setStatus("disconnected");
-		} else this.log.info({
-			action: "reconnect.scheduled",
-			message: `next attempt in ${Math.round(delay)}ms`
-		});
-	}
-	setStatus(next) {
-		if (this.currentStatus === next) return;
-		this.log.info({
-			action: "status",
-			message: `${this.currentStatus} → ${next}`
-		});
-		this.currentStatus = next;
-		this.options.onStatus?.(next);
-	}
-	static extractMeta(envelope) {
-		const meta = { event_type: envelope.type };
-		const eventPayload = isRecord(envelope.payload.event) ? envelope.payload.event : null;
-		if (!eventPayload) return meta;
-		if (typeof eventPayload.channel === "string") meta.channel_id = eventPayload.channel;
-		if (typeof eventPayload.user === "string") meta.user_id = eventPayload.user;
-		if (typeof eventPayload.thread_ts === "string") meta.thread_ts = eventPayload.thread_ts;
-		if (typeof eventPayload.type === "string") meta.slack_event_type = eventPayload.type;
-		return meta;
-	}
-};
-//#endregion
-export { FlumeHttpError as i, FlumeSlackSocketMode as n, obtainSlackUrl as r, FlumeSlackSource as t };