@eyepop.ai/eyepop 0.9.1 → 0.9.2

package/dist/index.js

@@ -8584,9 +8584,9 @@ var require_mime_types = __commonJS({
         return false;
       }
       var match = EXTRACT_TYPE_REGEXP.exec(type);
-      var mime2 = match && db[match[1].toLowerCase()];
-      if (mime2 && mime2.charset) {
-        return mime2.charset;
+      var mime = match && db[match[1].toLowerCase()];
+      if (mime && mime.charset) {
+        return mime.charset;
       }
       if (match && TEXT_TYPE_REGEXP.test(match[1])) {
         return "UTF-8";
@@ -8597,16 +8597,16 @@ var require_mime_types = __commonJS({
       if (!str || typeof str !== "string") {
         return false;
       }
-      var mime2 = str.indexOf("/") === -1 ? exports2.lookup(str) : str;
-      if (!mime2) {
+      var mime = str.indexOf("/") === -1 ? exports2.lookup(str) : str;
+      if (!mime) {
         return false;
       }
-      if (mime2.indexOf("charset") === -1) {
-        var charset2 = exports2.charset(mime2);
+      if (mime.indexOf("charset") === -1) {
+        var charset2 = exports2.charset(mime);
         if (charset2)
-          mime2 += "; charset=" + charset2.toLowerCase();
+          mime += "; charset=" + charset2.toLowerCase();
       }
-      return mime2;
+      return mime;
     }
     function extension(type) {
       if (!type || typeof type !== "string") {
@@ -8632,8 +8632,8 @@ var require_mime_types = __commonJS({
     function populateMaps(extensions, types) {
       var preference = ["nginx", "apache", void 0, "iana"];
       Object.keys(db).forEach(function forEachMimeType(type) {
-        var mime2 = db[type];
-        var exts = mime2.extensions;
+        var mime = db[type];
+        var exts = mime.extensions;
         if (!exts || !exts.length) {
           return;
         }
@@ -8642,7 +8642,7 @@ var require_mime_types = __commonJS({
           var extension2 = exts[i];
           if (types[extension2]) {
             var from = preference.indexOf(db[types[extension2]].source);
-            var to = preference.indexOf(mime2.source);
+            var to = preference.indexOf(mime.source);
             if (types[extension2] !== "application/octet-stream" && (from > to || from === to && types[extension2].substr(0, 12) === "application/")) {
               continue;
             }
@@ -8914,13 +8914,13 @@ function readableStreamAsyncIterable(stream) {
 
 // src/jobs.ts
 var _AbstractJob = class _AbstractJob {
-  constructor(baseUrl, pipelineId, authorizationHeader, dispatcher, requestLogger) {
+  constructor(baseUrl, pipelineId, authorizationHeader, client, requestLogger) {
     this._responseStream = null;
     this._controller = new AbortController();
     this._baseUrl = baseUrl.replace(/\/+$/, "");
     this._pipelineId = pipelineId;
     this._authorizationHeader = authorizationHeader;
-    this._dispatcher = dispatcher;
+    this._client = client;
     this._requestLogger = requestLogger;
     this.i = _AbstractJob.n++;
   }
@@ -8930,19 +8930,19 @@ var _AbstractJob = class _AbstractJob {
     }
     return Stream.iterFromReadableStream(this._responseStream, this._controller);
   }
-  async _fetch() {
+  async startJob() {
     return Promise.reject("abstract class");
   }
   start(done) {
-    this._responseStream = new Promise((resolve, reject) => {
-      const request = this._fetch();
+    this._responseStream = new Promise((resolve2, reject) => {
+      const request = this.startJob();
       request.then((response) => {
         if (response.status != 200) {
           reject(`upload error ${response.status}: ${response.text()}`);
         } else if (!response.body) {
           reject(`response body is empty`);
         } else {
-          resolve(response.body);
+          resolve2(response.body);
         }
       }).catch((reason) => {
         reject(reason);
@@ -8962,12 +8962,12 @@ var UploadJob = class extends AbstractJob {
   get [Symbol.toStringTag]() {
     return "uploadJob";
   }
-  constructor(stream, mimeType, baseUrl, pipelineId, authorizationHeader, dispatcher, requestLogger) {
-    super(baseUrl, pipelineId, authorizationHeader, dispatcher, requestLogger);
+  constructor(stream, mimeType, baseUrl, pipelineId, authorizationHeader, client, requestLogger) {
+    super(baseUrl, pipelineId, authorizationHeader, client, requestLogger);
     this._uploadStream = stream;
     this._mimeType = mimeType;
   }
-  async _fetch() {
+  async startJob() {
     const headers = {
       "Authorization": this._authorizationHeader,
       "Accept": "application/jsonl",
@@ -8975,7 +8975,7 @@ var UploadJob = class extends AbstractJob {
     };
     const postUrl = `${this._baseUrl}/pipelines/${this._pipelineId}/source?mode=queue&processing=sync`;
     this._requestLogger.debug("before POST %s with stream as body");
-    const response = await fetch(postUrl, {
+    const response = await this._client.fetch(postUrl, {
       headers,
       method: "POST",
       body: this._uploadStream,
@@ -8989,14 +8989,14 @@ var UploadJob = class extends AbstractJob {
   }
 };
 var LoadFromJob = class extends AbstractJob {
-  constructor(location, baseUrl, pipelineId, authorizationHeader, dispatcher, requestLogger) {
-    super(baseUrl, pipelineId, authorizationHeader, dispatcher, requestLogger);
+  constructor(location, baseUrl, pipelineId, authorizationHeader, client, requestLogger) {
+    super(baseUrl, pipelineId, authorizationHeader, client, requestLogger);
     this._location = location;
   }
   get [Symbol.toStringTag]() {
     return "loadFromJob";
   }
-  async _fetch() {
+  async startJob() {
     const headers = {
       "Authorization": this._authorizationHeader,
       "Accept": "application/jsonl",
@@ -9008,7 +9008,7 @@ var LoadFromJob = class extends AbstractJob {
     };
     const postUrl = `${this._baseUrl}/pipelines/${this._pipelineId}/source?mode=queue&processing=sync`;
     this._requestLogger.debug("before PATCH %s with url %s as source", postUrl, this._location);
-    const response = await fetch(postUrl, {
+    const response = await this._client.fetch(postUrl, {
       headers,
       method: "PATCH",
       body: JSON.stringify(body),
@@ -9021,20 +9021,226 @@ var LoadFromJob = class extends AbstractJob {
   }
 };
 
+// src/shims/http_client.ts
+var createHttpClient;
+if ("document" in globalThis && "implementation" in globalThis.document) {
+  class HttpClient2 {
+    constructor() {
+    }
+    async fetch(input, init) {
+      return fetch(input, init);
+    }
+    async close() {
+    }
+  }
+  createHttpClient = async () => {
+    return new HttpClient2();
+  };
+} else {
+  class HttpClient2 {
+    constructor(agent) {
+      this.agent = agent;
+    }
+    async fetch(input, init) {
+      init || (init = {});
+      init.dispatcher = this.agent;
+      return fetch(input, init);
+    }
+    async close() {
+      return this.agent.close();
+    }
+  }
+  createHttpClient = async () => {
+    const undici = await import("undici");
+    const agent = new undici.Agent({
+      keepAliveTimeout: 1e4,
+      connections: 5
+    });
+    return new HttpClient2(agent);
+  };
+}
+
+// src/semaphore.ts
+var Semaphore = class {
+  /**
+   * Creates a semaphore.
+   * @param permits  The number of permits, i.e. strands of execution being allowed
+   * to run in parallel.
+   * This number can be initialized with a negative integer.
+   */
+  constructor(permits) {
+    this.promiseResolverQueue = [];
+    this.permits = permits;
+  }
+  /**
+   * Returns the number of available permits.
+   * @returns  The number of available permits.
+   */
+  getPermits() {
+    return this.permits;
+  }
+  /**
+   * Returns a promise used to wait for a permit to become available. This method should be awaited on.
+   * @returns  A promise that gets resolved when execution is allowed to proceed.
+   */
+  async wait() {
+    if (this.permits > 0) {
+      this.permits -= 1;
+      return Promise.resolve(true);
+    }
+    return new Promise((resolver) => this.promiseResolverQueue.push(resolver));
+  }
+  /**
+   * Alias for {@linkcode Semaphore.wait}.
+   * @returns  A promise that gets resolved when execution is allowed to proceed.
+   */
+  async acquire() {
+    return this.wait();
+  }
+  /**
+   * Same as {@linkcode Semaphore.wait} except the promise returned gets resolved with false if no
+   * permit becomes available in time.
+   * @param milliseconds  The time spent waiting before the wait is aborted. This is a lower bound,
+   * you shouldn't rely on it being precise.
+   * @returns  A promise that gets resolved to true when execution is allowed to proceed or
+   * false if the time given elapses before a permit becomes available.
+   */
+  async waitFor(milliseconds) {
+    if (this.permits > 0) {
+      this.permits -= 1;
+      return Promise.resolve(true);
+    }
+    let resolver = (b) => void 0;
+    const promise = new Promise((r) => {
+      resolver = r;
+    });
+    this.promiseResolverQueue.push(resolver);
+    setTimeout(() => {
+      const index = this.promiseResolverQueue.indexOf(resolver);
+      if (index !== -1) {
+        this.promiseResolverQueue.splice(index, 1);
+      } else {
+        console.warn(`Semaphore.waitFor couldn't find its promise resolver in the queue`);
+      }
+      resolver(false);
+    }, milliseconds);
+    return promise;
+  }
+  /**
+   * Synchronous function that tries to acquire a permit and returns true if successful, false otherwise.
+   * @returns  Whether a permit could be acquired.
+   */
+  tryAcquire() {
+    if (this.permits > 0) {
+      this.permits -= 1;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Acquires all permits that are currently available and returns the number of acquired permits.
+   * @returns  Number of acquired permits.
+   */
+  drainPermits() {
+    if (this.permits > 0) {
+      const permitCount = this.permits;
+      this.permits = 0;
+      return permitCount;
+    }
+    return 0;
+  }
+  /**
+   * Increases the number of permits by one. If there are other functions waiting, one of them will
+   * continue to execute in a future iteration of the event loop.
+   */
+  signal() {
+    this.permits += 1;
+    if (this.permits > 1 && this.promiseResolverQueue.length > 0) {
+      console.warn("Semaphore.permits should never be > 0 when there is someone waiting.");
+    } else if (this.permits === 1 && this.promiseResolverQueue.length > 0) {
+      this.permits -= 1;
+      const nextResolver = this.promiseResolverQueue.shift();
+      if (nextResolver) {
+        nextResolver(true);
+      }
+    }
+  }
+  /**
+   * Alias for {@linkcode Semaphore.signal}.
+   */
+  release() {
+    this.signal();
+  }
+  /**
+   * Schedules func to be called once a permit becomes available.
+   * Returns a promise that resolves to the return value of func.
+   * @typeparam T  The return type of func.
+   * @param func  The function to be executed.
+   * @return  A promise that gets resolved with the return value of the function.
+   */
+  async execute(func) {
+    await this.wait();
+    try {
+      return await func();
+    } finally {
+      this.signal();
+    }
+  }
+};
+
+// src/shims/local_file.ts
+var resolve;
+if ("document" in globalThis && "implementation" in globalThis.document) {
+  const isFileLike = (value) => value != null && typeof value === "object" && typeof value.name === "string" && typeof value.lastModified === "number";
+  resolve = async (params) => {
+    if (params.file) {
+      if (isFileLike(params.file)) {
+        params = {
+          mimeType: params.file.type,
+          file: params.file
+        };
+        return params;
+      }
+    }
+    throw new DOMException("resolving a path to a file is not supported in browser");
+  };
+} else {
+  resolve = async (params) => {
+    if (params.file) {
+      return params;
+    }
+    const mime = await Promise.resolve().then(() => __toESM(require_mime_types()));
+    const fs = await import("fs");
+    let mimeType;
+    let stream;
+    if (params.filePath) {
+      if (params.mimeType) {
+        mimeType = params.mimeType;
+      } else {
+        mimeType = mime.lookup(params.filePath) || void 0;
+      }
+      stream = fs.createReadStream(params.filePath);
+    }
+    params = {
+      filePath: params.filePath,
+      mimeType,
+      file: stream
+    };
+    return params;
+  };
+}
+
 // src/endpoint.ts
-var fs = __toESM(require("fs"));
-var import_mime_types = __toESM(require_mime_types());
-var import_undici = require("undici");
-var import_await_semaphore = require("await-semaphore");
 var import_pino = require("pino");
-var _Endpoint = class _Endpoint {
+var Endpoint = class {
   constructor(options) {
     this._options = options;
     this._baseUrl = null;
     this._pipelineId = null;
+    this._popName = null;
     this._token = null;
     this._expire_token_time = null;
-    this._dispatcher = null;
+    this._client = null;
     this._limit = null;
     let rootLogger;
     if (options.logger) {
@@ -9045,56 +9251,62 @@ var _Endpoint = class _Endpoint {
     this._logger = rootLogger.child({ module: "eyepop" });
     this._requestLogger = this._logger.child({ module: "requests" });
   }
+  popName() {
+    return this._popName;
+  }
+  async session() {
+    await this.currentAccessToken();
+    if (this._token == null || this._expire_token_time == null) {
+      return Promise.reject("endpoint not connected");
+    }
+    const token = {
+      accessToken: this._token,
+      validUntil: new Date(this._expire_token_time * 1e3)
+    };
+    return token;
+  }
   async upload(params) {
-    if (!this._baseUrl || !this._pipelineId || !this._dispatcher || !this._limit) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       return Promise.reject("endpoint not connected, use open() before upload()");
     }
-    let mimeType = null;
-    let stream = null;
-    if (params.filePath) {
-      if (params.mimeType) {
-        mimeType = params.mimeType;
-      } else {
-        mimeType = import_mime_types.default.lookup(params.filePath);
-      }
-      stream = fs.createReadStream(params.filePath);
-    } else if (params.stream) {
-      stream = params.stream;
-      mimeType = params.mimeType;
-    }
-    if (!mimeType) {
+    params = await resolve(params);
+    if (!params.mimeType) {
       return Promise.reject("upload for streams requires a mimeType");
     }
-    let release = await this._limit.acquire();
+    await this._limit.acquire();
     const job = new UploadJob(
-      stream,
-      mimeType,
+      params.file,
+      params.mimeType,
       this._baseUrl,
       this._pipelineId,
       await this.authorizationHeader(),
-      this._dispatcher,
+      this._client,
       this._requestLogger
     );
-    return job.start(release);
+    return job.start(() => {
+      this._limit?.release();
+    });
   }
   async loadFrom(location) {
-    if (!this._baseUrl || !this._pipelineId || !this._dispatcher || !this._limit) {
+    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use open() before loadFrom()");
     }
-    const release = await this._limit.acquire();
+    await this._limit.acquire();
     const job = new LoadFromJob(
       location,
       this._baseUrl,
       this._pipelineId,
       await this.authorizationHeader(),
-      this._dispatcher,
+      this._client,
       this._requestLogger
     );
-    return job.start(release);
+    return job.start(() => {
+      this._limit?.release();
+    });
   }
   // noinspection TypeScriptValidateTypes
   async connect() {
-    if (this._dispatcher) {
+    if (this._client) {
       console.info("endpoint already connected");
       return this;
     }
@@ -9104,33 +9316,31 @@ var _Endpoint = class _Endpoint {
     if (!this._options.popId) {
       return Promise.reject("option popId or environment variable EYEPOP_POP_ID is required");
     }
-    if (!this._options.secretKey) {
-      return Promise.reject("option secretKey or environment variable EYEPOP_SECRET_KEY is required");
+    if (this._options.session) {
+      this._token = this._options.session.accessToken;
+      this._expire_token_time = this._options.session.validUntil.getTime() / 1e3;
+    } else {
+      if (!this._options.secretKey) {
+        return Promise.reject("option secretKey or environment variable EYEPOP_SECRET_KEY is required");
+      }
     }
-    this._dispatcher = new import_undici.Agent({
-      keepAliveTimeout: 1e4,
-      pipelining: 100,
-      maxConcurrentStreams: 100,
-      maxCachedSessions: 100,
-      connections: _Endpoint.MAX_CONNECTIONS
-    });
-    this._limit = new import_await_semaphore.Semaphore(this._options.jobQueueLength);
+    this._client = await createHttpClient();
+    this._limit = new Semaphore(this._options.jobQueueLength);
     const config_url = `${this.eyepopUrl()}/pops/${this._options.popId}/config?auto_start=${this._options.autoStart}`;
     const headers = {
       "Authorization": await this.authorizationHeader()
     };
     this._requestLogger.debug("before GET %s", config_url);
-    let response = await fetch(config_url, { headers });
+    let response = await this._client.fetch(config_url, { headers });
     if (response.status == 401) {
       this._requestLogger.debug("after GET %s: 401, about to retry with fresh access token", config_url);
       this._token = null;
       const headers2 = {
         "Authorization": await this.authorizationHeader()
       };
-      response = await fetch(config_url, {
-        headers: headers2,
+      response = await this._client.fetch(config_url, {
+        headers: headers2
         // @ts-ignore
-        dispatcher: this._dispatcher
       });
     }
     if (response.status != 200) {
@@ -9141,6 +9351,7 @@ var _Endpoint = class _Endpoint {
     const config = data;
     this._baseUrl = config.base_url;
     this._pipelineId = config.pipeline_id;
+    this._popName = config.name;
     this._requestLogger.debug("after GET %s: %s / %s", config_url, this._baseUrl, this._pipelineId);
     if (!this._pipelineId || !this._baseUrl) {
       return Promise.reject(`Pop not started`);
@@ -9154,7 +9365,7 @@ var _Endpoint = class _Endpoint {
         "Content-Type": "application/json"
       };
       this._requestLogger.debug("before PATCH %s", stop_url);
-      let response2 = await fetch(stop_url, { method: "PATCH", headers: headers2, body: JSON.stringify(body) });
+      let response2 = await this._client.fetch(stop_url, { method: "PATCH", headers: headers2, body: JSON.stringify(body) });
       if (response2.status >= 300) {
         const message = await response2.text();
         return Promise.reject(`Unexpected status ${response2.status}: ${message}`);
@@ -9165,34 +9376,37 @@ var _Endpoint = class _Endpoint {
   }
   async disconnect(wait = true) {
     if (wait && this._limit) {
-      for (let i = 0; i < this._options.jobQueueLength; i++) {
+      for (let j = 0; j < this._options.jobQueueLength; j++) {
         await this._limit.acquire();
       }
     }
-    if (this._dispatcher) {
-      await this._dispatcher.close();
-      this._dispatcher = null;
+    if (this._client) {
+      await this._client.close();
+      this._client = null;
     }
     this._baseUrl = null;
     this._pipelineId = null;
     this._limit = null;
   }
   async authorizationHeader() {
-    return `Bearer ${await this.accessToken()}`;
+    return `Bearer ${await this.currentAccessToken()}`;
   }
-  async accessToken() {
+  async currentAccessToken() {
     const now = Date.now() / 1e3;
     if (!this._token || this._expire_token_time < now) {
+      if (!this._client) {
+        return Promise.reject("endpoint not connected");
+      } else if (!this._options.secretKey) {
+        return Promise.reject("temporary access token expired");
+      }
       const body = { "secret_key": this._options.secretKey };
       const headers = { "Content-Type": "application/json" };
       const post_url = `${this.eyepopUrl()}/authentication/token`;
       this._requestLogger.debug("before POST %s", post_url);
-      const response = await fetch(post_url, {
+      const response = await this._client.fetch(post_url, {
         method: "POST",
         headers,
-        body: JSON.stringify(body),
-        // @ts-ignore
-        dispatcher: this._dispatcher
+        body: JSON.stringify(body)
       });
       if (response.status != 200) {
         const message = await response.text();
@@ -9215,8 +9429,6 @@ var _Endpoint = class _Endpoint {
     }
   }
 };
-_Endpoint.MAX_CONNECTIONS = 5;
-var Endpoint = _Endpoint;
 
 // src/visualize.ts
 var _EyePopPlot = class _EyePopPlot {
@@ -9333,6 +9545,7 @@ var EyePopPlot = _EyePopPlot;
 var EyePopSdk = class {
   static endpoint({
     secretKey = readEnv("EYEPOP_SECRET_KEY"),
+    session = void 0,
     popId = readEnv("EYEPOP_POP_ID"),
     eyepopUrl = readEnv("EYEPOP_URL"),
     autoStart = true,
@@ -9343,6 +9556,7 @@ var EyePopSdk = class {
   } = {}) {
     const options = {
       secretKey,
+      session,
       popId,
       eyepopUrl: eyepopUrl ?? "https://api.eyepop.ai",
       autoStart,