@webex/byods 0.0.0-next.1

package/dist/data-source-client/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DATASOURCE_ENDPOINT = void 0;
+const DATASOURCE_ENDPOINT = exports.DATASOURCE_ENDPOINT = '/dataSources';

package/dist/data-source-client/index.js

@@ -0,0 +1,205 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _jose = require("jose");
+var _types = require("../Errors/types");
+var _ExtendedError = _interopRequireDefault(require("../Errors/catalog/ExtendedError"));
+var _constants = require("./constants");
+var _constants2 = require("../constants");
+var _Logger = _interopRequireDefault(require("../Logger"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Client for interacting with the /dataSource API.
+ */
+class DataSourceClient {
+  /**
+   * Creates an instance of DataSourceClient.
+   * @param {HttpClient} httpClient - The HttpClient instance to use for API requests.
+   * @example
+   * const httpClient = new HttpClient();
+   * const client = new DataSourceClient(httpClient);
+   */
+  constructor(httpClient, loggerConfig = _constants2.DEFAULT_LOGGER_CONFIG) {
+    this.httpClient = httpClient;
+    this.loggerConfig = loggerConfig;
+    _Logger.default.setLogger(this.loggerConfig.level, _constants2.BYODS_DATA_SOURCE_CLIENT_MODULE);
+  }
+
+  /**
+   * Creates a new data source.
+   * @param {DataSourceRequest} createDataSourceRequest - The request object for creating a data source.
+   * @returns {Promise<ApiResponse<DataSourceResponse>>} - A promise that resolves to the API response containing the created data source.
+   * @example
+   * const request: DataSourceRequest = { name: 'New DataSource', url: 'https://mydatasource.com', schemaId: '123', audience: 'myaudience', subject: 'mysubject', nonce: 'uniqueNonce' };
+   * const response = await client.create(request);
+   */
+  async create(dataSourcePayload) {
+    return this.httpClient.post(_constants.DATASOURCE_ENDPOINT, dataSourcePayload); // TODO: Move /dataSources to constants
+  }
+
+  /**
+   * Retrieves a data source by ID.
+   * @param {string} id - The ID of the data source to retrieve.
+   * @returns {Promise<ApiResponse<DataSourceResponse>>} - A promise that resolves to the API response containing the data source.
+   * @example
+   * const id = '123';
+   * const response = await client.get(id);
+   */
+  async get(id) {
+    return this.httpClient.get(`${_constants.DATASOURCE_ENDPOINT}/${id}`);
+  }
+
+  /**
+   * Lists all data sources.
+   * @returns {Promise<ApiResponse<DataSourceResponse[]>>} - A promise that resolves to the API response containing the list of data sources.
+   * @example
+   * const response = await client.list();
+   */
+  async list() {
+    return this.httpClient.get(_constants.DATASOURCE_ENDPOINT).then(response => ({
+      ...response,
+      data: response.data.items
+    }));
+  }
+
+  /**
+   * Updates a data source by ID.
+   * @param {string} id - The ID of the data source to update.
+   * @param {DataSourceRequest} updateDataSourceRequest - The request object for updating a data source.
+   * @returns {Promise<ApiResponse<DataSourceResponse>>} - A promise that resolves to the API response containing the updated data source.
+   * @example
+   * const id = '123';
+   * const request: DataSourceRequest = { name: 'Updated DataSource', url: 'https://mydatasource.com', schemaId: '123', audience: 'myaudience', subject: 'mysubject', nonce: 'uniqueNonce' };
+   * const response = await client.update(id, request);
+   */
+  async update(id, dataSourcePayload) {
+    return this.httpClient.put(`${_constants.DATASOURCE_ENDPOINT}/${id}`, dataSourcePayload);
+  }
+
+  /**
+   * Deletes a data source by ID.
+   * @param {string} id - The ID of the data source to delete.
+   * @returns {Promise<ApiResponse<void>>} - A promise that resolves to the API response confirming the deletion.
+   * @example
+   * const id = '123';
+   * const response = await client.delete(id);
+   */
+  async delete(id) {
+    return this.httpClient.delete(`${_constants.DATASOURCE_ENDPOINT}/${id}`);
+  }
+
+  /**
+   * This method refreshes the DataSource token using dataSourceId, tokenLifetimeMinutes & nonceGenerator.
+   * @param {string} dataSourceId The id of the data source.
+   * @param {number} tokenLifetimeMinutes The refresh interval in minutes for the data source. Defaults to 60 mins. Should be an integer.
+   * @param {string} nonceGenerator Accepts an nonceGenerator, developer can provide their own nonceGenerator, defaults to randomUUID.
+   * @returns {Promise<Cancelable>} A promise that resolves to an object containing a cancel method that cancels the timer.
+   * @example
+   * try {
+    const result = await dataSourceClient.scheduleJWSTokenRefresh('myDataSourceId', 'uniqueNonce', 'myTokenLifeTimeMinutes');
+    // Use the cancel function if needed!
+    result.cancel();
+  } catch (error) {
+    console.error('Error scheduling JWS refresh for data source:', error);
+  }
+   */
+
+  async scheduleJWSTokenRefresh(dataSourceId, tokenLifetimeMinutes = 60, nonceGenerator = crypto.randomUUID) {
+    try {
+      const timer = await this.startAutoRefresh(dataSourceId, tokenLifetimeMinutes, nonceGenerator);
+      const cancel = () => {
+        if (timer) {
+          try {
+            clearInterval(timer);
+            _Logger.default.info(`JWS Auto-refresh has been cancelled successfully for dataSource: ${dataSourceId}`, {
+              file: _constants2.BYODS_DATA_SOURCE_CLIENT_MODULE,
+              method: 'scheduleJWSTokenRefresh'
+            });
+          } catch (error) {
+            _Logger.default.error(new _ExtendedError.default(`Failed to cancel the timer, the timer might have expired or is invalid ${error}`, _types.ERROR_TYPE.SCHEDULE_JWS_TOKEN_REFRESH_ERROR), {
+              file: _constants2.BYODS_DATA_SOURCE_CLIENT_MODULE,
+              method: 'scheduleJWSTokenRefresh'
+            });
+            throw new Error('Failed to cancel the timer, the timer might have expired or is invalid');
+          }
+        }
+      };
+      return Promise.resolve({
+        cancel
+      });
+    } catch (error) {
+      _Logger.default.error(new _ExtendedError.default(`Encountered error while trying to setup JWS refresh schedule ${error}`, _types.ERROR_TYPE.SCHEDULE_JWS_TOKEN_REFRESH_ERROR), {
+        file: _constants2.BYODS_DATA_SOURCE_CLIENT_MODULE,
+        method: 'scheduleJWSTokenRefresh'
+      });
+      return Promise.reject(error);
+    }
+  }
+
+  /**
+   * Sets up a timer that will auto refresh the DataSource JWS token for given intervals
+   * @param {string} dataSourceId The id of the data source
+   * @param {number} tokenLifetimeMinutes The refresh interval in minutes for the data source. Defaults to 60 mins. Should be <= 1440 & >=1.
+   * @param {string} nonceGenerator Accepts an nonceGenerator that will generate nonce for the data source request.
+   * @returns {Promise<NodeJS.Timeout>} A promise that resolves to the API response containing NodeJS.Timeout.
+   */
+  async startAutoRefresh(dataSourceId, tokenLifetimeMinutes, nonceGenerator) {
+    try {
+      // Generate a random percentage between 5% and 10%
+      const randomPercentage = Math.random() * 5 + 5;
+      // Then calculate the reducedTokenLifetimeMinutes
+      const reducedTokenLifetimeMinutes = Math.ceil(tokenLifetimeMinutes * (1 - randomPercentage / 100));
+      const interval = setInterval(async () => {
+        try {
+          // Fetch the dataSource details before each update
+          const getMethodResponse = await this.get(dataSourceId);
+          if (!getMethodResponse || !getMethodResponse.data || !getMethodResponse.data.jwsToken) {
+            throw new Error('Invalid response from get method.');
+          }
+          const jwsToken = getMethodResponse?.data?.jwsToken;
+          const jwsTokenPayload = (0, _jose.decodeJwt)(jwsToken);
+          if (!jwsTokenPayload || !jwsToken) {
+            throw new Error('jwsTokenPayload or jwsToken is undefined.');
+          }
+          const payloadForDataSourceUpdateMethod = {
+            schemaId: getMethodResponse?.data?.schemaId,
+            tokenLifetimeMinutes,
+            url: jwsTokenPayload['com.cisco.datasource.url'],
+            subject: jwsTokenPayload.sub,
+            audience: jwsTokenPayload.aud,
+            nonce: nonceGenerator ? nonceGenerator() : crypto.randomUUID(),
+            status: getMethodResponse?.data?.status
+          };
+          await this.update(dataSourceId, payloadForDataSourceUpdateMethod);
+          _Logger.default.info('dataSource has been refreshed successfully', {
+            file: _constants2.BYODS_DATA_SOURCE_CLIENT_MODULE,
+            method: 'startAutoRefresh'
+          });
+          return Promise.resolve();
+        } catch (updateError) {
+          // If there is some error then clear the Interval only if interval is active
+          if (interval) {
+            clearInterval(interval);
+          }
+          _Logger.default.error(new _ExtendedError.default(`Error while updating dataSource token ${updateError}`, _types.ERROR_TYPE.START_AUTO_REFRESH_ERROR), {
+            file: _constants2.BYODS_DATA_SOURCE_CLIENT_MODULE,
+            method: 'startAutoRefresh'
+          });
+          return Promise.reject(new Error(`Error while starting auto-refresh for dataSource token: ${updateError}`));
+        }
+      }, reducedTokenLifetimeMinutes * 60 * 1000); // Converts minutes to milliseconds.
+
+      return Promise.resolve(interval);
+    } catch (error) {
+      _Logger.default.error(new _ExtendedError.default(`Error while starting auto-refresh for dataSource token: ${error}`, _types.ERROR_TYPE.START_AUTO_REFRESH_ERROR), {
+        file: _constants2.BYODS_DATA_SOURCE_CLIENT_MODULE,
+        method: 'startAutoRefresh'
+      });
+      return Promise.reject(new Error(`Error while starting auto-refresh for dataSource token: ${error}`));
+    }
+  }
+}
+exports.default = DataSourceClient;

package/dist/data-source-client/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/http-client/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/http-utils/index.js

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.httpUtils = void 0;
+exports.put = put;
+var _crypto = require("crypto");
+var _constants = require("../constants");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Makes an HTTP request.
+ * @param {string} url - The URL for the request.
+ * @param {HttpRequestInit} [options=\{\}] - The request options.
+ * @returns {Promise<ApiResponse<T>>} - The API response.
+ * @example
+ * const response = await request('https://webexapis.com/v1/endpoint', { method: 'GET', headers: {} });
+ */
+async function request(url, options = {}) {
+  // TODO: Fix this issue (which is being tracked in node_fetch) https://github.com/node-fetch/node-fetch/issues/1809
+  const fetch = (await Promise.resolve().then(() => _interopRequireWildcard(require('node-fetch')))).default;
+  const controller = new AbortController();
+  const timeout = options.timeout || 30000; // Default 30s timeout
+
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  const optionsWithHeaders = {
+    ...options,
+    signal: controller.signal,
+    headers: {
+      Trackingid: `${_constants.BYODS_PACKAGE_NAME}_${(0, _crypto.randomUUID)()}`,
+      'User-Agent': _constants.USER_AGENT,
+      ...options.headers
+    }
+  };
+  try {
+    const response = await fetch(url, optionsWithHeaders);
+    if (!response.ok) {
+      throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
+    }
+
+    // Handle 204 No Content responses
+    if (response.status === 204) {
+      return {
+        data: {},
+        status: response.status
+      };
+    }
+    const data = await response.json();
+    return {
+      data,
+      status: response.status
+    };
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+/**
+ * Makes an HTTP GET request.
+ * @param {string} url - The URL for the request.
+ * @param {HttpRequestInit} [options=\{\}] - The request options.
+ * @returns {Promise<ApiResponse<T>>} - The API response.
+ * @example
+ * const response = await get('https://webexapis.com/v1/endpoint', { headers: {} });
+ */
+async function get(url, options = {}) {
+  return httpUtils.request(url, {
+    ...options,
+    method: 'GET'
+  });
+}
+
+/**
+ * Makes an HTTP POST request.
+ * @param {string} url - The URL for the request.
+ * @param {HttpRequestInit} [options=\{\}] - The request options.
+ * @returns {Promise<ApiResponse<T>>} - The API response.
+ * @example
+ * const response = await post('https://webexapis.com/v1/endpoint', { headers: {} });
+ */
+async function post(url, options = {}) {
+  return httpUtils.request(url, {
+    ...options,
+    method: 'POST'
+  });
+}
+
+/**
+ * Makes an HTTP PUT request.
+ * @param {string} url - The URL for the request.
+ * @param {HttpRequestInit} [options=\{\}] - The request options.
+ * @returns {Promise<ApiResponse<T>>} - The API response.
+ * @example
+ * const response = await put('https://webexapis.com/v1/endpoint', { headers: {} });
+ */
+async function put(url, options = {}) {
+  return httpUtils.request(url, {
+    ...options,
+    method: 'PUT'
+  });
+}
+
+/**
+ * Makes an HTTP DELETE request.
+ * @param {string} url - The URL for the request.
+ * @param {HttpRequestInit} [options=\{\}] - The request options.
+ * @returns {Promise<ApiResponse<T>>} - The API response.
+ * @example
+ * const response = await del('https://webexapis.com/v1/endpoint', { headers: {} });
+ */
+async function del(url, options = {}) {
+  return httpUtils.request(url, {
+    ...options,
+    method: 'DELETE'
+  });
+}
+
+/**
+ * Makes an HTTP PATCH request.
+ * @param {string} url - The URL for the request.
+ * @param {HttpRequestInit} [options=\{\}] - The request options.
+ * @returns {Promise<ApiResponse<T>>} - The API response.
+ * @example
+ * const response = await patch('https://webexapis.com/v1/endpoint', { headers: {} });
+ */
+async function patch(url, options = {}) {
+  return httpUtils.request(url, {
+    ...options,
+    method: 'PATCH'
+  });
+}
+const httpUtils = exports.httpUtils = {
+  request,
+  get,
+  post,
+  put,
+  del,
+  patch
+};

package/dist/index.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BYODS", {
+  enumerable: true,
+  get: function () {
+    return _byods.default;
+  }
+});
+Object.defineProperty(exports, "BaseClient", {
+  enumerable: true,
+  get: function () {
+    return _baseClient.default;
+  }
+});
+Object.defineProperty(exports, "DataSourceClient", {
+  enumerable: true,
+  get: function () {
+    return _dataSourceClient.default;
+  }
+});
+Object.defineProperty(exports, "InMemoryTokenStorageAdapter", {
+  enumerable: true,
+  get: function () {
+    return _tokenStorageAdapter.InMemoryTokenStorageAdapter;
+  }
+});
+Object.defineProperty(exports, "LOGGER", {
+  enumerable: true,
+  get: function () {
+    return _types.LOGGER;
+  }
+});
+Object.defineProperty(exports, "TokenManager", {
+  enumerable: true,
+  get: function () {
+    return _tokenManager.default;
+  }
+});
+var _byods = _interopRequireDefault(require("./byods"));
+var _tokenManager = _interopRequireDefault(require("./token-manager"));
+var _baseClient = _interopRequireDefault(require("./base-client"));
+var _dataSourceClient = _interopRequireDefault(require("./data-source-client"));
+var _tokenStorageAdapter = require("./token-storage-adapter");
+var _types = require("./Logger/types");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/dist/token-manager/index.js

@@ -0,0 +1,232 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _constants = require("../constants");
+var _httpUtils = require("../http-utils");
+var _ExtendedError = _interopRequireDefault(require("../Errors/catalog/ExtendedError"));
+var _types = require("../Errors/types");
+var _Logger = _interopRequireDefault(require("../Logger"));
+var _tokenStorageAdapter = require("../token-storage-adapter");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * The token manager for the BYoDS SDK.
+ */
+class TokenManager {
+  /**
+   * Creates an instance of TokenManager.
+   *
+   * @param clientId - The client ID of the service app.
+   * @param clientSecret - The client secret of the service app.
+   * @param baseUrl - The base URL for the API. Defaults to `PRODUCTION_BASE_URL`.
+   * @example
+   * const tokenManager = new TokenManager('your-client-id', 'your-client-secret');
+   */
+  constructor(clientId, clientSecret, baseUrl = _constants.PRODUCTION_BASE_URL, tokenStorageAdapter = new _tokenStorageAdapter.InMemoryTokenStorageAdapter(), loggerConfig = _constants.DEFAULT_LOGGER_CONFIG) {
+    if (!clientId || !clientSecret) {
+      throw new Error('clientId and clientSecret are required');
+    }
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.baseUrl = baseUrl;
+    this.loggerConfig = loggerConfig;
+    this.serviceAppId = Buffer.from(`${_constants.APPLICATION_ID_PREFIX}${clientId}`).toString('base64');
+    this.tokenStorageAdapter = tokenStorageAdapter;
+    _Logger.default.setLogger(this.loggerConfig.level, _constants.BYODS_TOKEN_MANAGER_MODULE);
+  }
+
+  /**
+   * Update the tokens and their expiration times.
+   * @param {TokenResponse} data - The token response data.
+   * @param {string} orgId - The organization ID.
+   * @returns {void}
+   * @example
+   * await tokenManager.updateServiceAppToken(tokenResponse, 'org-id');
+   */
+  async updateServiceAppToken(data, orgId) {
+    const serviceAppToken = {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token,
+      expiresAt: new Date(Date.now() + data.expires_in * 1000),
+      // Adding 1000 here to represent milliseconds
+      refreshAccessTokenExpiresAt: new Date(Date.now() + data.refresh_token_expires_in * 1000) // Adding 1000 here to represent milliseconds
+    };
+
+    await this.tokenStorageAdapter.setToken(orgId, {
+      orgId,
+      serviceAppToken
+    });
+  }
+
+  /**
+   * Get the service app ID.
+   * @returns {string}
+   * @example
+   * const serviceAppId = tokenManager.getServiceAppId();
+   */
+  getServiceAppId() {
+    return this.serviceAppId;
+  }
+
+  /**
+   * Get the service app authorization data for a given organization ID.
+   * @param {string} orgId - The organization ID.
+   * @returns {Promise<OrgServiceAppAuthorization>}
+   * @example
+   * const authorization = await tokenManager.getOrgServiceAppAuthorization('org-id');
+   */
+  async getOrgServiceAppAuthorization(orgId) {
+    try {
+      let token = await this.getTokenFromAdapter(orgId);
+      const currentTime = new Date();
+      if (token.serviceAppToken.expiresAt <= currentTime) {
+        await this.saveServiceAppRegistrationData(orgId, token.serviceAppToken.refreshToken);
+        token = await this.getTokenFromAdapter(orgId); // Fetch the refreshed token
+      }
+
+      return token;
+    } catch (error) {
+      _Logger.default.error(new _ExtendedError.default('Error fetching token', _types.ERROR_TYPE.TOKEN_ERROR), {
+        file: _constants.BYODS_TOKEN_MANAGER_MODULE,
+        method: 'getOrgServiceAppAuthorization'
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * List all stored tokens.
+   * @returns {Promise<OrgServiceAppAuthorization[]>} List of tokens
+   * @example
+   * const tokens = await tokenManager.listTokens();
+   */
+  async listTokens() {
+    return this.tokenStorageAdapter.listTokens();
+  }
+
+  /**
+   * Delete a token for a given orgId.
+   * @param {string} orgId - The organization ID.
+   * @returns {Promise<void>}
+   * @example
+   * await tokenManager.deleteToken('org-id');
+   */
+  async deleteToken(orgId) {
+    await this.tokenStorageAdapter.deleteToken(orgId);
+  }
+
+  /**
+   * Remove all tokens stored in the TokenStorageAdapter.
+   * @returns {Promise<void>}
+   * @example
+   * await tokenManager.resetTokens();
+   */
+  async resetTokens() {
+    await this.tokenStorageAdapter.resetTokens();
+  }
+
+  /**
+   * Retrieve a new service app token using the service app owner's personal access token(PAT).
+   * @param {string} orgId - The organization ID.
+   * @param {string} personalAccessToken - The service app owner's personal access token or token from an integration that has the scope `spark:applications_token`.
+   * @returns {Promise<void>}
+   * await tokenManager.getServiceAppTokenUsingPAT('org-id', 'personal-access-token');
+   */
+  async getServiceAppTokenUsingPAT(orgId, personalAccessToken, headers = {}) {
+    try {
+      const response = await _httpUtils.httpUtils.post(`${this.baseUrl}/access_token`, {
+        headers: {
+          Authorization: `Bearer ${personalAccessToken}`,
+          'Content-Type': 'application/json',
+          ...headers
+        },
+        body: JSON.stringify({
+          targetOrgId: orgId,
+          clientId: this.clientId,
+          clientSecret: this.clientSecret
+        })
+      });
+      await this.updateServiceAppToken(response.data, orgId);
+    } catch (error) {
+      _Logger.default.error(new _ExtendedError.default('Error retrieving token after authorization', _types.ERROR_TYPE.TOKEN_ERROR), {
+        file: _constants.BYODS_TOKEN_MANAGER_MODULE,
+        method: 'getServiceAppTokenUsingPAT'
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Refresh the access token using the refresh token.
+   * @param {string} orgId - The organization ID.
+   * @returns {Promise<void>}
+   * await tokenManager.refreshServiceAppAccessToken('org-id');
+   */
+  async refreshServiceAppAccessToken(orgId, headers = {}) {
+    if (!orgId) {
+      throw new Error('orgId not provided');
+    }
+    let serviceAppAuthorization;
+    try {
+      serviceAppAuthorization = await this.getTokenFromAdapter(orgId);
+    } catch (error) {
+      _Logger.default.error(new _ExtendedError.default('Error fetching token', _types.ERROR_TYPE.TOKEN_ERROR), {
+        file: _constants.BYODS_TOKEN_MANAGER_MODULE,
+        method: 'refreshServiceAppAccessToken'
+      });
+      throw error;
+    }
+    const refreshToken = serviceAppAuthorization?.serviceAppToken.refreshToken;
+    if (!refreshToken) {
+      throw new Error(`Refresh token was not found for org:${orgId}`);
+    }
+    await this.saveServiceAppRegistrationData(orgId, refreshToken, headers);
+  }
+
+  /**
+   * Save the service app registration using the provided refresh token.
+   * After saving, it can be fetched by using the {@link getOrgServiceAppAuthorization} method.
+   * @param {string} orgId - The organization ID.
+   * @param {string} refreshToken - The refresh token.
+   * @returns {Promise<void>}
+   * @example
+   * await tokenManager.saveServiceAppRegistrationData('org-id', 'refresh-token');
+   */
+  async saveServiceAppRegistrationData(orgId, refreshToken, headers = {}) {
+    try {
+      const response = await _httpUtils.httpUtils.post(`${this.baseUrl}/access_token`, {
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded',
+          // https://developer.webex.com/docs/login-with-webex#access-token-endpoint
+          ...headers
+        },
+        body: new URLSearchParams({
+          grant_type: 'refresh_token',
+          client_id: this.clientId,
+          client_secret: this.clientSecret,
+          refresh_token: refreshToken
+        }).toString()
+      });
+      await this.updateServiceAppToken(response.data, orgId);
+    } catch (error) {
+      _Logger.default.error(new _ExtendedError.default('Error saving service app registration', _types.ERROR_TYPE.REGISTRATION_ERROR), {
+        file: _constants.BYODS_TOKEN_MANAGER_MODULE,
+        method: 'saveServiceAppRegistration'
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Proxy for extracting the token from the token adapter
+   * @param {string} orgId - The organization ID.
+   * @returns {Promise<OrgServiceAppAuthorization>}
+   * @private
+   */
+  async getTokenFromAdapter(orgId) {
+    return this.tokenStorageAdapter.getToken(orgId);
+  }
+}
+exports.default = TokenManager;