@jacebenson/jsn 4.3.10 → 4.3.11-dev.69

package/src/sdk.js

@@ -50,6 +50,7 @@ export class SDKClient {
     this.timeout = opts.timeout || DEFAULT_TIMEOUT;
     this.domain = opts.domain || '';
     this.oauthCookies = null;
+    this._sessionPromise = null;
     this.sessionUserToken = '';
   }
 
@@ -94,74 +95,63 @@ export class SDKClient {
     }
   }
 
-  async request(endpoint, opts = {}) {
-    const { timeout = this.timeout, readOnly = false, touchLastSeen, ...requestOptions } = opts;
-    if (readOnly && (requestOptions.method || 'GET').toUpperCase() !== 'GET') throw new Error('Read-only SDK requests require GET');
+  // Keep the timeout alive through body consumption for text/JSON requests.
+  // Raw-response callers retain their existing timeout boundary at headers.
+  async _withAuthenticatedRequest(endpoint, opts, {
+    timeout = this.timeout, prepare, skipOAuthSession = false, normalizeErrors = false,
+  }, consume = (response) => response) {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeout);
-
     try {
-      const req = new Request(endpoint, {
-        ...requestOptions,
-        signal: controller.signal,
-      });
-      req.headers.set('Accept', 'application/json');
-      if (requestOptions.body && typeof requestOptions.body === 'string') {
-        req.headers.set('Content-Type', 'application/json');
-      }
-      if (this.domain) {
-        req.headers.set('X-Now-Domain', this.domain);
+      const req = new Request(endpoint, { ...opts, signal: controller.signal });
+      if (prepare) prepare(req);
+      await this._setAuth(req, { skipOAuthSession });
+      return await consume(await fetch(req));
+    } catch (err) {
+      if (normalizeErrors) {
+        if (err.name === 'AbortError') throw errNetwork(new Error('Request timed out'));
+        if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND' || err.code === 'ETIMEDOUT') {
+          throw errNetwork(err);
+        }
       }
-      // readOnly guards the data request, not standard authentication bootstrap.
-      // OAuth refresh and session/GCK negotiation are not instance-record writes.
-      await this._setAuth(req);
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
 
-      const resp = await fetch(req);
+  async request(endpoint, opts = {}) {
+    const { timeout = this.timeout, readOnly = false, touchLastSeen, ...requestOptions } = opts;
+    if (readOnly && (requestOptions.method || 'GET').toUpperCase() !== 'GET') throw new Error('Read-only SDK requests require GET');
+    return this._withAuthenticatedRequest(endpoint, requestOptions, {
+      timeout,
+      normalizeErrors: true,
+      prepare: (req) => {
+        req.headers.set('Accept', 'application/json');
+        if (requestOptions.body && typeof requestOptions.body === 'string') {
+          req.headers.set('Content-Type', 'application/json');
+        }
+        if (this.domain) req.headers.set('X-Now-Domain', this.domain);
+      },
+    }, async (resp) => {
       const body = await resp.text();
+      if (!resp.ok) throw errAPI(resp.status, body || resp.statusText);
+      if (resp.status === 204 || body === '') return null;
 
-      if (!resp.ok) {
-        throw errAPI(resp.status, body || resp.statusText);
-      }
-
-      if (resp.status === 204 || body === '') {
-        return null;
-      }
-
-      // Stamp last_seen on successful API call
+      // Preserve read-only credential-write suppression and the existing empty-body behavior.
       try {
-        // readOnly suppresses the credential last-seen write unconditionally: a
-        // caller passing touchLastSeen cannot override it (GLOSSARY contract).
         const shouldTouch = readOnly ? false : (touchLastSeen ?? true);
         if (shouldTouch && this.authProvider && typeof this.authProvider.touchLastSeen === 'function') {
           this.authProvider.touchLastSeen(this.baseURL);
         }
       } catch { /* non-fatal */ }
-
       return JSON.parse(body);
-    } catch (err) {
-      if (err.name === 'AbortError') {
-        throw errNetwork(new Error('Request timed out'));
-      }
-      if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND' || err.code === 'ETIMEDOUT') {
-        throw errNetwork(err);
-      }
-      throw err;
-    } finally {
-      clearTimeout(timer);
-    }
+    });
   }
 
-  // _fetchWithAuth makes an authenticated fetch and returns the Response object.
+  // Authentication bootstrap bypasses session warming to avoid recursion.
   async _fetchWithAuth(endpoint, opts = {}) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const req = new Request(endpoint, { ...opts, signal: controller.signal });
-      await this._setAuth(req, { skipOAuthSession: true });
-      return await fetch(req);
-    } finally {
-      clearTimeout(timer);
-    }
+    return this._withAuthenticatedRequest(endpoint, opts, { skipOAuthSession: true });
   }
 
   // Public raw-response seam for callers that must inspect non-2xx bodies.
@@ -170,38 +160,18 @@ export class SDKClient {
   }
 
   async rawRequest(endpoint, opts = {}) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-
-    try {
-      const req = new Request(endpoint, {
-        ...opts,
-        signal: controller.signal,
-      });
-      if (opts.body && typeof opts.body === 'string') {
-        req.headers.set('Content-Type', opts.headers?.['Content-Type'] || 'application/x-www-form-urlencoded');
-      }
-      await this._setAuth(req);
-
-      const resp = await fetch(req);
+    return this._withAuthenticatedRequest(endpoint, opts, {
+      normalizeErrors: true,
+      prepare: (req) => {
+        if (opts.body && typeof opts.body === 'string') {
+          req.headers.set('Content-Type', opts.headers?.['Content-Type'] || 'application/x-www-form-urlencoded');
+        }
+      },
+    }, async (resp) => {
       const body = await resp.text();
-
-      if (!resp.ok) {
-        throw errAPI(resp.status, body || resp.statusText);
-      }
-
+      if (!resp.ok) throw errAPI(resp.status, body || resp.statusText);
       return body;
-    } catch (err) {
-      if (err.name === 'AbortError') {
-        throw errNetwork(new Error('Request timed out'));
-      }
-      if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND' || err.code === 'ETIMEDOUT') {
-        throw errNetwork(err);
-      }
-      throw err;
-    } finally {
-      clearTimeout(timer);
-    }
+    });
   }
 
   async getSkippedUpdateBaseline(sysID) {
@@ -791,18 +761,26 @@ export class SDKClient {
 
     const result = { _record: records[0] };
 
-    for (const rel of related) {
-      try {
-        const relParams = new URLSearchParams();
-        relParams.set('sysparm_display_value', 'all');
-        relParams.set('sysparm_fields', (rel.fields || []).join(','));
-        relParams.set('sysparm_query', `${rel.queryField}=${rel.queryValue}`);
-        relParams.set('sysparm_limit', '100');
-        result[rel.displayAs] = await this.list(rel.table, relParams);
-      } catch {
-        result[rel.displayAs] = [];
+    // Four workers bound instance load while overlapping independent reads.
+    let next = 0;
+    const values = new Array(related.length);
+    await Promise.all(Array.from({ length: Math.min(4, related.length) }, async () => {
+      while (next < related.length) {
+        const index = next++;
+        const rel = related[index];
+        try {
+          const relParams = new URLSearchParams();
+          relParams.set('sysparm_display_value', 'all');
+          relParams.set('sysparm_fields', (rel.fields || []).join(','));
+          relParams.set('sysparm_query', `${rel.queryField}=${rel.queryValue}`);
+          relParams.set('sysparm_limit', '100');
+          values[index] = await this.list(rel.table, relParams);
+        } catch {
+          values[index] = [];
+        }
       }
-    }
+    }));
+    related.forEach((rel, index) => { result[rel.displayAs] = values[index]; });
 
     return result;
   }
@@ -859,6 +837,15 @@ export class SDKClient {
 
   async _warmSession() {
     if (this.oauthCookies) return this.oauthCookies;
+    if (!this._sessionPromise) {
+      this._sessionPromise = this._initializeSession().finally(() => {
+        this._sessionPromise = null;
+      });
+    }
+    return this._sessionPromise;
+  }
+
+  async _initializeSession() {
     try {
       const creds = await this.authProvider.getCredentials();
       if (creds.auth_method === 'oauth') {