ultrastiching-cli 0.0.0-stage → 0.2.0

package/src/websocket.js

@@ -0,0 +1,72 @@
+import { endpoint, buildPayload } from './registry.js';
+import { normalizeOrigin, resolveKey } from './config.js';
+import { redactKey } from './http.js';
+
+export class MeridianWebSocketError extends Error {
+  constructor(message, { status, requestId, body, key, cause } = {}) {
+    super(message, { cause });
+    this.name = 'MeridianWebSocketError';
+    this.status = status;
+    this.requestId = requestId;
+    this.body = body;
+    this.key = key;
+  }
+  toDiagnostic() {
+    return {
+      type: this.name, message: this.message, status: this.status,
+      request_id: redactKey(this.requestId, this.key), raw_body: redactKey(this.body, this.key),
+      cause: this.cause ? redactKey(String(this.cause), this.key) : undefined,
+    };
+  }
+}
+
+export async function streamNewsflash(values, {
+  key, websocketBaseUrl, count, idleTimeout,
+  onMessage = (line) => process.stdout.write(`${line}\n`),
+  socketFactory,
+} = {}) {
+  const meta = endpoint('ws_newsflash', 'websocket');
+  if (!meta) throw new Error('ws_newsflash is absent from the registry');
+  const subscription = buildPayload(meta, values);
+  const apiKey = resolveKey(key);
+  const origin = websocketBaseUrl === undefined ? meta.origin : normalizeOrigin(websocketBaseUrl, ['ws:', 'wss:']);
+  const max = count === undefined ? Infinity : Number(count);
+  if (!(max > 0 && (max === Infinity || Number.isInteger(max)))) throw new Error('count must be a positive integer');
+  const idleMs = idleTimeout === undefined ? undefined : Number(idleTimeout);
+  if (idleMs !== undefined && (!Number.isFinite(idleMs) || idleMs <= 0)) throw new Error('idle-timeout must be positive milliseconds');
+  const factory = socketFactory ?? ((await import('ws')).default);
+  const socket = new factory(`${origin}${meta.path}`, { headers: { Authorization: `Bearer ${apiKey}` } });
+  return new Promise((resolve, reject) => {
+    let received = 0;
+    let timer;
+    let settled = false;
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (error) reject(error); else resolve({ received });
+    };
+    const resetTimer = () => {
+      if (timer) clearTimeout(timer);
+      if (idleMs) timer = setTimeout(() => socket.close(), idleMs);
+    };
+    socket.on('open', () => { socket.send(JSON.stringify(subscription)); resetTimer(); });
+    socket.on('message', (data) => {
+      resetTimer();
+      received++;
+      try { onMessage(String(data)); }
+      catch (cause) { finish(new MeridianWebSocketError('Could not handle WebSocket message', { cause, key: apiKey })); socket.close(); return; }
+      if (received >= max) socket.close();
+    });
+    socket.on('unexpected-response', (_request, response) => {
+      const chunks = [];
+      response.on('data', (chunk) => chunks.push(chunk));
+      response.on('end', () => finish(new MeridianWebSocketError('WebSocket handshake failed', {
+        status: response.statusCode, requestId: response.headers['x-meridian-request-id'],
+        body: Buffer.concat(chunks).toString('utf8'), key: apiKey,
+      })));
+    });
+    socket.on('error', (cause) => finish(new MeridianWebSocketError('WebSocket transport failed', { cause, key: apiKey })));
+    socket.on('close', () => finish());
+  });
+}