@ondewo/sip-client-nodejs 5.4.1 → 5.4.2

package/auth/offlineTokenProvider.js

@@ -13,15 +13,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OfflineTokenProvider = exports.TokenError = void 0;
 exports.login = login;
@@ -76,54 +67,54 @@ function buildTokenEndpoint(keycloakUrl, realm) {
  * @returns A promise resolving to the parsed {@link KeycloakTokenResponse}.
  * @throws {TokenError} On a non-2xx response, an unparseable body, or a missing `access_token`.
  */
-function postTokenRequest(tokenEndpoint, params, fetchImpl) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const body = new URLSearchParams(params).toString();
-        const response = yield fetchImpl(tokenEndpoint, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded',
-                Accept: 'application/json'
-            },
-            body
-        });
-        const text = yield response.text();
-        if (!response.ok) {
-            throw new TokenError(`Keycloak token endpoint returned HTTP ${response.status}: ${text}`);
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(text);
-        }
-        catch (_a) {
-            throw new TokenError(`Keycloak token endpoint returned a non-JSON body: ${text}`);
-        }
-        if (typeof parsed.access_token !== 'string' || parsed.access_token.length === 0) {
-            throw new TokenError('Keycloak token response did not contain an access_token');
-        }
-        return parsed;
+async function postTokenRequest(tokenEndpoint, params, fetchImpl) {
+    const body = new URLSearchParams(params).toString();
+    const response = await fetchImpl(tokenEndpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: 'application/json'
+        },
+        body
     });
+    const text = await response.text();
+    if (!response.ok) {
+        throw new TokenError(`Keycloak token endpoint returned HTTP ${response.status}: ${text}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new TokenError(`Keycloak token endpoint returned a non-JSON body: ${text}`);
+    }
+    if (typeof parsed.access_token !== 'string' || parsed.access_token.length === 0) {
+        throw new TokenError('Keycloak token response did not contain an access_token');
+    }
+    return parsed;
 }
 /**
- * Build the default fetch layer: delegate to the global `fetch` (Node >= 18).
+ * Build the default {@link TokenFetch}: delegate to the global `fetch` (Node >= 18).
  *
  * When `verifySsl` is `false`, a cached undici `Agent` with `rejectUnauthorized: false` is attached
  * to every request as its `dispatcher`, so the Keycloak token call skips TLS certificate verification
  * (opt-in insecure; Node-only). The dispatcher is built once here and reused for all requests this
  * transport makes (login + refreshes); the secure default never loads undici.
  *
- * @param {boolean} verifySsl - Whether to verify the Keycloak server's TLS certificate.
- * @returns {Function} A fetch layer bound to the chosen TLS-verification behaviour.
+ * @param verifySsl - Whether to verify the Keycloak server's TLS certificate.
+ * @returns A fetch layer bound to the chosen TLS-verification behaviour.
  */
 function createDefaultFetch(verifySsl) {
     let dispatcher;
     if (!verifySsl) {
+        // Lazy require keeps undici out of the default (secure) code path.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
         const { Agent } = require('undici');
         dispatcher = new Agent({ connect: { rejectUnauthorized: false } });
     }
     return (url, init) => {
         const globalFetch = globalThis.fetch;
-        return globalFetch(url, dispatcher === undefined ? init : Object.assign({}, init, { dispatcher }));
+        return globalFetch(url, dispatcher === undefined ? init : { ...init, dispatcher });
     };
 }
 /**
@@ -141,7 +132,8 @@ class OfflineTokenProvider {
         this.tokenEndpoint = buildTokenEndpoint(options.keycloakUrl, options.realm);
         this.clientId = options.clientId;
         this.tokenExpirationInS = options.tokenExpirationInS;
-        this.fetchImpl = options.fetchImpl !== undefined ? options.fetchImpl : createDefaultFetch(options.keycloakVerifySsl !== false);
+        this.fetchImpl =
+            options.fetchImpl !== undefined ? options.fetchImpl : createDefaultFetch(options.keycloakVerifySsl ?? true);
         this.nowInMs = options.nowInMs !== undefined ? options.nowInMs : Date.now;
         this.accessToken = null;
         this.refreshToken = null;
@@ -159,27 +151,25 @@ class OfflineTokenProvider {
      * @throws {TokenError} If the token endpoint fails or the response carries no `refresh_token`
      *   (the SDK client lacks `directAccessGrants` + the `offline_access` scope).
      */
-    bootstrap(username, password) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tokenResponse = yield postTokenRequest(this.tokenEndpoint, {
-                grant_type: 'password',
-                client_id: this.clientId,
-                username,
-                password,
-                scope: 'offline_access'
-            }, this.fetchImpl);
-            this.accessToken = tokenResponse.access_token;
-            this.refreshToken = typeof tokenResponse.refresh_token === 'string' ? tokenResponse.refresh_token : null;
-            if (this.refreshToken === null) {
-                throw new TokenError('Keycloak token response did not contain a refresh_token; the SDK client must have ' +
-                    'directAccessGrants + the offline_access scope (ondewo-sip-cai-sdk-public)');
-            }
-            if (this.tokenExpirationInS !== undefined) {
-                const expirationInMs = this.tokenExpirationInS * 1000;
-                this.deadlineInMs = this.nowInMs() + expirationInMs;
-            }
-            this.scheduleRefresh(tokenResponse.expires_in);
-        });
+    async bootstrap(username, password) {
+        const tokenResponse = await postTokenRequest(this.tokenEndpoint, {
+            grant_type: 'password',
+            client_id: this.clientId,
+            username,
+            password,
+            scope: 'offline_access'
+        }, this.fetchImpl);
+        this.accessToken = tokenResponse.access_token;
+        this.refreshToken = typeof tokenResponse.refresh_token === 'string' ? tokenResponse.refresh_token : null;
+        if (this.refreshToken === null) {
+            throw new TokenError('Keycloak token response did not contain a refresh_token; the SDK client must have ' +
+                'directAccessGrants + the offline_access scope (ondewo-sip-cai-sdk-public)');
+        }
+        if (this.tokenExpirationInS !== undefined) {
+            const expirationInMs = this.tokenExpirationInS * 1000;
+            this.deadlineInMs = this.nowInMs() + expirationInMs;
+        }
+        this.scheduleRefresh(tokenResponse.expires_in);
     }
     /**
      * Exchange the offline refresh token for a fresh access token and re-arm the next refresh.
@@ -188,30 +178,28 @@ class OfflineTokenProvider {
      * @returns A promise that resolves once the token is refreshed (or the loop has lapsed/stopped).
      * @throws {TokenError} If the refresh token-endpoint call fails or returns an invalid body.
      */
-    refresh() {
-        return __awaiter(this, void 0, void 0, function* () {
-            /* c8 ignore next 3 -- unreachable: stop() always clears the only timer that calls refresh() */
-            if (this.stopped) {
-                return;
-            }
-            // Re-check the bounded deadline at fire time (not just at schedule time): once it has elapsed the
-            // loop stops with no further renewal -> the access token lapses -> re-login is required.
-            if (this.deadlineInMs !== null && this.nowInMs() >= this.deadlineInMs) {
-                this.stop();
-                return;
-            }
-            const tokenResponse = yield postTokenRequest(this.tokenEndpoint, {
-                grant_type: 'refresh_token',
-                client_id: this.clientId,
-                refresh_token: this.refreshToken
-            }, this.fetchImpl);
-            this.accessToken = tokenResponse.access_token;
-            // Keycloak may rotate the offline refresh token; keep the newest one when present.
-            if (typeof tokenResponse.refresh_token === 'string' && tokenResponse.refresh_token.length > 0) {
-                this.refreshToken = tokenResponse.refresh_token;
-            }
-            this.scheduleRefresh(tokenResponse.expires_in);
-        });
+    async refresh() {
+        /* c8 ignore next 3 -- unreachable: stop() always clears the only timer that calls refresh() */
+        if (this.stopped) {
+            return;
+        }
+        // Re-check the bounded deadline at fire time (not just at schedule time): once it has elapsed the
+        // loop stops with no further renewal -> the access token lapses -> re-login is required.
+        if (this.deadlineInMs !== null && this.nowInMs() >= this.deadlineInMs) {
+            this.stop();
+            return;
+        }
+        const tokenResponse = await postTokenRequest(this.tokenEndpoint, {
+            grant_type: 'refresh_token',
+            client_id: this.clientId,
+            refresh_token: this.refreshToken
+        }, this.fetchImpl);
+        this.accessToken = tokenResponse.access_token;
+        // Keycloak may rotate the offline refresh token; keep the newest one when present.
+        if (typeof tokenResponse.refresh_token === 'string' && tokenResponse.refresh_token.length > 0) {
+            this.refreshToken = tokenResponse.refresh_token;
+        }
+        this.scheduleRefresh(tokenResponse.expires_in);
     }
     /**
      * Arm a single timer for the next refresh, clamped to the bounded deadline. Stops silently once
@@ -301,20 +289,18 @@ exports.OfflineTokenProvider = OfflineTokenProvider;
  * @throws {TokenError} If `options` is missing, a required string option is empty, or the token
  *   endpoint / response is invalid.
  */
-function login(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (options === undefined || options === null) {
-            throw new TokenError('login() requires an options object');
-        }
-        const requiredKeys = ['keycloakUrl', 'realm', 'clientId', 'username', 'password'];
-        for (const key of requiredKeys) {
-            const value = options[key];
-            if (typeof value !== 'string' || value.length === 0) {
-                throw new TokenError(`login() option "${key}" is required and must be a non-empty string`);
-            }
+async function login(options) {
+    if (options === undefined || options === null) {
+        throw new TokenError('login() requires an options object');
+    }
+    const requiredKeys = ['keycloakUrl', 'realm', 'clientId', 'username', 'password'];
+    for (const key of requiredKeys) {
+        const value = options[key];
+        if (typeof value !== 'string' || value.length === 0) {
+            throw new TokenError(`login() option "${key}" is required and must be a non-empty string`);
         }
-        const provider = new OfflineTokenProvider(options);
-        yield provider.bootstrap(options.username, options.password);
-        return provider;
-    });
+    }
+    const provider = new OfflineTokenProvider(options);
+    await provider.bootstrap(options.username, options.password);
+    return provider;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ondewo/sip-client-nodejs",
-  "version": "5.4.1",
+  "version": "5.4.2",
   "description": "ONDEWO Session Initiation Protocol (SIP) Client library for Nodejs",
   "author": "ONDEWO GmbH <office@ondewo.com>",
   "homepage": "https://ondewo.com",

package/public-api.d.ts

@@ -1,4 +1,6 @@
-export * from './api/ondewo/sip/sip_grpc_pb.d';
-export * from './api/ondewo/sip/sip_pb.d';
 export * from './api/google/protobuf/empty_pb.d';
 export * from './api/google/protobuf/timestamp_pb.d';
+export * from './api/ondewo/sip/sip_grpc_pb.d';
+export * from './api/ondewo/sip/sip_pb.d';
+export * from './auth/grpcChannel';
+export * from './auth/offlineTokenProvider';

package/public-api.js

@@ -1,6 +1,16 @@
-export * from './api/ondewo/sip/sip_grpc_pb';
-export * from './api/ondewo/sip/sip_pb';
-export * from './api/google/protobuf/empty_grpc_pb';
-export * from './api/google/protobuf/timestamp_pb';
-export * from './api/google/protobuf/empty_pb';
-export * from './api/google/protobuf/timestamp_grpc_pb';
+'use strict';
+function reexport(m) {
+  Object.keys(m).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) {
+      Object.defineProperty(exports, k, { enumerable: true, get: function () { return m[k]; } });
+    }
+  });
+}
+reexport(require('./api/google/protobuf/empty_grpc_pb'));
+reexport(require('./api/google/protobuf/empty_pb'));
+reexport(require('./api/google/protobuf/timestamp_grpc_pb'));
+reexport(require('./api/google/protobuf/timestamp_pb'));
+reexport(require('./api/ondewo/sip/sip_grpc_pb'));
+reexport(require('./api/ondewo/sip/sip_pb'));
+reexport(require('./auth/grpcChannel'));
+reexport(require('./auth/offlineTokenProvider'));