@saltify/milky-node-sdk 0.1.0-beta.5 → 0.1.0-beta.6

package/dist/index.d.ts

@@ -69,20 +69,19 @@ type EventCollection = {
 };
 
 declare class MilkyClient {
-    private readonly accessToken?;
+    private readonly eventEmitter;
     private readonly httpApiUrl;
     private readonly eventUrl;
-    private readonly wsClient;
     private readonly fetchHeader;
-    private readonly eventEmitter;
+    private disposeCore?;
     /**
-     * @param address The address of the Milky API server
-     * @param port The port of the Milky API server
-     * @param base The base path for the Milky API
+     * @param authority The authority of the Milky API (value of `new URL('https://example.com:443/some-path').host`)
+     * @param basePath The base path for the Milky API
      * @param accessToken The access token for authentication (optional)
-     * @param useHttps Whether to use HTTPS (default: false)
+     * @param useTLS Whether to use HTTPS and WSS (default: false)
+     * @param useSSE Whether to use Server-Sent Events for event streaming (default: false)
      */
-    constructor(address: string, port: number, base: string, accessToken?: string | undefined, useHttps?: boolean);
+    constructor(authority: string, basePath?: `/${string}/` | '/', accessToken?: string, useTLS?: boolean, useSSE?: boolean);
     /**
      * Call a Milky API method.
      * @param method The API method to call
@@ -96,6 +95,13 @@ declare class MilkyClient {
      * @param listener The listener function to call when the event is emitted
      */
     onEvent<K extends keyof EventCollection>(eventType: K, listener: (data: EventCollection[K]) => void): Promise<void>;
+    private createSSE;
+    private createWebsocket;
+    /**
+     * Release the WebSocket / Server Sent Event connection.
+     */
+    dispose(): void;
+    [Symbol.dispose]: () => void;
 }
 
 export { MilkyClient };

package/dist/index.js

@@ -1,40 +1,350 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/eventsource-parser@3.0.6/node_modules/eventsource-parser/dist/index.cjs
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/eventsource-parser@3.0.6/node_modules/eventsource-parser/dist/index.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var ParseError = class extends Error {
+      constructor(message, options) {
+        super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+      }
+    };
+    function noop(_arg) {
+    }
+    function createParser(callbacks) {
+      if (typeof callbacks == "function")
+        throw new TypeError(
+          "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+        );
+      const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
+      let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
+      function feed(newChunk) {
+        const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+        for (const line of complete)
+          parseLine(line);
+        incompleteLine = incomplete, isFirstChunk = false;
+      }
+      function parseLine(line) {
+        if (line === "") {
+          dispatchEvent();
+          return;
+        }
+        if (line.startsWith(":")) {
+          onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+          return;
+        }
+        const fieldSeparatorIndex = line.indexOf(":");
+        if (fieldSeparatorIndex !== -1) {
+          const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+          processField(field, value, line);
+          return;
+        }
+        processField(line, "", line);
+      }
+      function processField(field, value, line) {
+        switch (field) {
+          case "event":
+            eventType = value;
+            break;
+          case "data":
+            data = `${data}${value}
+`;
+            break;
+          case "id":
+            id = value.includes("\0") ? void 0 : value;
+            break;
+          case "retry":
+            /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+              new ParseError(`Invalid \`retry\` value: "${value}"`, {
+                type: "invalid-retry",
+                value,
+                line
+              })
+            );
+            break;
+          default:
+            onError(
+              new ParseError(
+                `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+                { type: "unknown-field", field, value, line }
+              )
+            );
+            break;
+        }
+      }
+      function dispatchEvent() {
+        data.length > 0 && onEvent({
+          id,
+          event: eventType || void 0,
+          // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+          // then remove the last character from the data buffer.
+          data: data.endsWith(`
+`) ? data.slice(0, -1) : data
+        }), id = void 0, data = "", eventType = "";
+      }
+      function reset(options = {}) {
+        incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
+      }
+      return { feed, reset };
+    }
+    function splitLines(chunk) {
+      const lines = [];
+      let incompleteLine = "", searchIndex = 0;
+      for (; searchIndex < chunk.length; ) {
+        const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+        let lineEnd = -1;
+        if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+          incompleteLine = chunk.slice(searchIndex);
+          break;
+        } else {
+          const line = chunk.slice(searchIndex, lineEnd);
+          lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
+` && searchIndex++;
+        }
+      }
+      return [lines, incompleteLine];
+    }
+    exports.ParseError = ParseError;
+    exports.createParser = createParser;
+  }
+});
+
+// ../../node_modules/.pnpm/eventsource-client@1.1.4/node_modules/eventsource-client/dist/node.js
+var require_node = __commonJS({
+  "../../node_modules/.pnpm/eventsource-client@1.1.4/node_modules/eventsource-client/dist/node.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var node_stream = __require("stream");
+    var eventsourceParser = require_dist();
+    var CONNECTING2 = "connecting";
+    var OPEN2 = "open";
+    var CLOSED2 = "closed";
+    var noop = () => {
+    };
+    function createEventSource$1(optionsOrUrl, { getStream: getStream2 }) {
+      const options = typeof optionsOrUrl == "string" || optionsOrUrl instanceof URL ? { url: optionsOrUrl } : optionsOrUrl, { onMessage, onConnect = noop, onDisconnect = noop, onScheduleReconnect = noop } = options, { fetch: fetch2, url, initialLastEventId } = validate(options), requestHeaders = { ...options.headers }, onCloseSubscribers = [], subscribers = onMessage ? [onMessage] : [], emit = (event) => subscribers.forEach((fn) => fn(event)), parser = eventsourceParser.createParser({ onEvent, onRetry });
+      let request, currentUrl = url.toString(), controller = new AbortController(), lastEventId = initialLastEventId, reconnectMs = 2e3, reconnectTimer, readyState = CLOSED2;
+      return connect(), {
+        close,
+        connect,
+        [Symbol.iterator]: () => {
+          throw new Error(
+            "EventSource does not support synchronous iteration. Use `for await` instead."
+          );
+        },
+        [Symbol.asyncIterator]: getEventIterator,
+        get lastEventId() {
+          return lastEventId;
+        },
+        get url() {
+          return currentUrl;
+        },
+        get readyState() {
+          return readyState;
+        }
+      };
+      function connect() {
+        request || (readyState = CONNECTING2, controller = new AbortController(), request = fetch2(url, getRequestOptions()).then(onFetchResponse).catch((err) => {
+          request = null, !(err.name === "AbortError" || err.type === "aborted" || controller.signal.aborted) && scheduleReconnect();
+        }));
+      }
+      function close() {
+        readyState = CLOSED2, controller.abort(), parser.reset(), clearTimeout(reconnectTimer), onCloseSubscribers.forEach((fn) => fn());
+      }
+      function getEventIterator() {
+        const pullQueue = [], pushQueue = [];
+        function pullValue() {
+          return new Promise((resolve) => {
+            const value = pushQueue.shift();
+            value ? resolve({ value, done: false }) : pullQueue.push(resolve);
+          });
+        }
+        const pushValue = function(value) {
+          const resolve = pullQueue.shift();
+          resolve ? resolve({ value, done: false }) : pushQueue.push(value);
+        };
+        function unsubscribe() {
+          for (subscribers.splice(subscribers.indexOf(pushValue), 1); pullQueue.shift(); )
+            ;
+          for (; pushQueue.shift(); )
+            ;
+        }
+        function onClose() {
+          const resolve = pullQueue.shift();
+          resolve && (resolve({ done: true, value: void 0 }), unsubscribe());
+        }
+        return onCloseSubscribers.push(onClose), subscribers.push(pushValue), {
+          next() {
+            return readyState === CLOSED2 ? this.return() : pullValue();
+          },
+          return() {
+            return unsubscribe(), Promise.resolve({ done: true, value: void 0 });
+          },
+          throw(error) {
+            return unsubscribe(), Promise.reject(error);
+          },
+          [Symbol.asyncIterator]() {
+            return this;
+          }
+        };
+      }
+      function scheduleReconnect() {
+        onScheduleReconnect({ delay: reconnectMs }), readyState = CONNECTING2, reconnectTimer = setTimeout(connect, reconnectMs);
+      }
+      async function onFetchResponse(response) {
+        onConnect(), parser.reset();
+        const { body, redirected, status } = response;
+        if (status === 204) {
+          onDisconnect(), close();
+          return;
+        }
+        if (!body)
+          throw new Error("Missing response body");
+        redirected && (currentUrl = response.url);
+        const stream = getStream2(body), decoder = new TextDecoder(), reader = stream.getReader();
+        let open = true;
+        readyState = OPEN2;
+        do {
+          const { done, value } = await reader.read();
+          value && parser.feed(decoder.decode(value, { stream: !done })), done && (open = false, request = null, parser.reset(), scheduleReconnect(), onDisconnect());
+        } while (open);
+      }
+      function onEvent(msg) {
+        typeof msg.id == "string" && (lastEventId = msg.id), emit(msg);
+      }
+      function onRetry(ms) {
+        reconnectMs = ms;
+      }
+      function getRequestOptions() {
+        const { mode, credentials, body, method, redirect, referrer, referrerPolicy } = options, headers = { Accept: "text/event-stream", ...requestHeaders, ...lastEventId ? { "Last-Event-ID": lastEventId } : void 0 };
+        return {
+          mode,
+          credentials,
+          body,
+          method,
+          redirect,
+          referrer,
+          referrerPolicy,
+          headers,
+          cache: "no-store",
+          signal: controller.signal
+        };
+      }
+    }
+    function validate(options) {
+      const fetch2 = options.fetch || globalThis.fetch;
+      if (!isFetchLike(fetch2))
+        throw new Error("No fetch implementation provided, and one was not found on the global object.");
+      if (typeof AbortController != "function")
+        throw new Error("Missing AbortController implementation");
+      const { url, initialLastEventId } = options;
+      if (typeof url != "string" && !(url instanceof URL))
+        throw new Error("Invalid URL provided - must be string or URL instance");
+      if (typeof initialLastEventId != "string" && initialLastEventId !== void 0)
+        throw new Error("Invalid initialLastEventId provided - must be string or undefined");
+      return { fetch: fetch2, url, initialLastEventId };
+    }
+    function isFetchLike(fetch2) {
+      return typeof fetch2 == "function";
+    }
+    var nodeAbstractions = {
+      getStream
+    };
+    function createEventSource2(optionsOrUrl) {
+      return createEventSource$1(optionsOrUrl, nodeAbstractions);
+    }
+    function getStream(body) {
+      if ("getReader" in body)
+        return body;
+      if (typeof body.pipe != "function" || typeof body.on != "function")
+        throw new Error("Invalid response body, expected a web or node.js stream");
+      if (typeof node_stream.Readable.toWeb != "function")
+        throw new Error("Node.js 18 or higher required (`Readable.toWeb()` not defined)");
+      return node_stream.Readable.toWeb(node_stream.Readable.from(body));
+    }
+    exports.CLOSED = CLOSED2;
+    exports.CONNECTING = CONNECTING2;
+    exports.OPEN = OPEN2;
+    exports.createEventSource = createEventSource2;
+  }
+});
+
 // src/index.ts
 import EventEmitter from "events";
-if (typeof globalThis.WebSocket === "undefined") {
-  console.error("WebSocket is not supported in this environment.");
-  process.exit(1);
-}
+
+// ../../node_modules/.pnpm/eventsource-client@1.1.4/node_modules/eventsource-client/dist/node.cjs.mjs
+var import_node = __toESM(require_node(), 1);
+var CLOSED = import_node.default.CLOSED;
+var CONNECTING = import_node.default.CONNECTING;
+var OPEN = import_node.default.OPEN;
+var createEventSource = import_node.default.createEventSource;
+
+// src/index.ts
+var combineUrl = (base, path) => {
+  const baseUrl = base.endsWith("/") ? base.slice(0, -1) : base;
+  const pathUrl = path.startsWith("/") ? path.slice(1) : path;
+  return `${baseUrl}/${pathUrl}`;
+};
 var MilkyClient = class {
+  eventEmitter;
+  httpApiUrl;
+  eventUrl;
+  fetchHeader;
+  disposeCore;
   /**
-   * @param address The address of the Milky API server
-   * @param port The port of the Milky API server
-   * @param base The base path for the Milky API
+   * @param authority The authority of the Milky API (value of `new URL('https://example.com:443/some-path').host`)
+   * @param basePath The base path for the Milky API
    * @param accessToken The access token for authentication (optional)
-   * @param useHttps Whether to use HTTPS (default: false)
+   * @param useTLS Whether to use HTTPS and WSS (default: false)
+   * @param useSSE Whether to use Server-Sent Events for event streaming (default: false)
    */
-  constructor(address, port, base, accessToken, useHttps = false) {
-    this.accessToken = accessToken;
-    base = base.endsWith("/") ? base.slice(0, -1) : base;
-    this.httpApiUrl = `${useHttps ? "https" : "http"}://${address}:${port}${base}/api`;
-    this.eventUrl = accessToken ? `${useHttps ? "wss" : "ws"}://${address}:${port}${base}/event?access_token=${accessToken}` : `${useHttps ? "wss" : "ws"}://${address}:${port}${base}/event`;
-    this.fetchHeader = this.accessToken ? {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${this.accessToken}`
-    } : {
-      "Content-Type": "application/json"
-    };
-    this.wsClient = new WebSocket(this.eventUrl);
+  constructor(authority, basePath, accessToken, useTLS, useSSE) {
+    const httpProtocol = useTLS ? "https" : "http";
+    const urlFragment = `${authority}${basePath}`;
+    const httpUrlBase = `${httpProtocol}://${urlFragment}`;
+    this.fetchHeader = {};
+    if (accessToken) this.fetchHeader["Authorization"] = `Bearer ${accessToken}`;
     this.eventEmitter = new EventEmitter();
-    this.wsClient.addEventListener("message", (event) => {
-      const data = JSON.parse(event.data);
-      this.eventEmitter.emit(data.event_type, data);
-    });
+    this.httpApiUrl = combineUrl(httpUrlBase, "api");
+    this.eventUrl = combineUrl(httpUrlBase, "api");
+    if (!useSSE) {
+      this.createWebsocket();
+    } else {
+      this.createSSE();
+    }
   }
-  httpApiUrl;
-  eventUrl;
-  wsClient;
-  fetchHeader;
-  eventEmitter;
   /**
    * Call a Milky API method.
    * @param method The API method to call
@@ -42,9 +352,13 @@ var MilkyClient = class {
    * If the API does not require any input, you can leave it empty.
    */
   async callApi(method, ...input) {
-    const response = await fetch(`${this.httpApiUrl}/${method}`, {
+    const response = await fetch(combineUrl(this.httpApiUrl, method), {
       method: "POST",
-      headers: this.fetchHeader,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...this.fetchHeader
+      },
       body: JSON.stringify(input[0] ?? {})
     });
     const callResult = await response.json();
@@ -61,6 +375,42 @@ var MilkyClient = class {
   async onEvent(eventType, listener) {
     this.eventEmitter.on(eventType, listener);
   }
+  createSSE() {
+    const sse = createEventSource({
+      url: this.eventUrl,
+      headers: {
+        Accept: "text/event-stream",
+        ...this.fetchHeader
+      },
+      onMessage: ({ event, data }) => {
+        if (event !== "milky_event") return;
+        const parsedData = JSON.parse(data);
+        this.eventEmitter.emit(parsedData.event_type, parsedData);
+      }
+    });
+    sse.connect();
+    this.disposeCore = sse.close;
+  }
+  createWebsocket() {
+    if (!globalThis.WebSocket) throw new Error("WebSocket is not supported in this environment.");
+    const ws = new WebSocket(this.eventUrl, {
+      headers: {
+        ...this.fetchHeader
+      }
+    });
+    ws.addEventListener("message", (event) => {
+      const data = JSON.parse(event.data);
+      this.eventEmitter.emit(data.event_type, data);
+    });
+    this.disposeCore = ws.close;
+  }
+  /**
+   * Release the WebSocket / Server Sent Event connection.
+   */
+  dispose() {
+    this.disposeCore?.();
+  }
+  [Symbol.dispose] = this.dispose;
 };
 export {
   MilkyClient

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@saltify/milky-node-sdk",
   "type": "module",
-  "version": "0.1.0-beta.5",
+  "version": "0.1.0-beta.6",
   "description": "Node.js SDK for Milky protocol",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -16,13 +16,15 @@
   },
   "license": "CC0-1.0",
   "devDependencies": {
-    "@types/node": "^22.17.2"
+    "@types/node": "^22.17.2",
+    "eventsource-client": "^1.1.4"
   },
   "dependencies": {
-    "@saltify/milky-types": "^1.0.0-draft.12",
+    "@saltify/milky-types": "^1.0.0-draft.14",
     "zod": "^4.1.5"
   },
   "scripts": {
-    "build": "tsup"
+    "build": "npm run gen:apis && tsup",
+    "gen:apis": "tsx ./scripts/gen_code.ts"
   }
 }