@asgardeo/node 0.0.1

package/dist/index.js

@@ -0,0 +1,759 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+import fetch, { Headers, Request, Response } from "cross-fetch";
+
+// src/__legacy__/core/authentication.ts
+import {
+  AsgardeoAuthClient,
+  AsgardeoAuthException
+} from "@asgardeo/javascript";
+
+// src/__legacy__/stores/memory-cache-store.ts
+import cache from "memory-cache";
+var MemoryCacheStore = class {
+  async setData(key, value) {
+    cache.put(key, value);
+  }
+  async getData(key) {
+    return cache.get(key) ?? "{}";
+  }
+  async removeData(key) {
+    cache.del(key);
+  }
+};
+
+// src/__legacy__/utils/session-utils.ts
+import { validate as uuidValidate, version as uuidVersion, v4 as uuidv4 } from "uuid";
+
+// src/__legacy__/constants/uuid-config.ts
+var UUID_VERSION = 4;
+
+// src/__legacy__/constants/logger-config.ts
+var LOGGER_CONFIG = {
+  bgGreen: "\x1B[42m",
+  bgRed: "\x1B[41m",
+  bgWhite: "\x1B[47m",
+  bgYellow: "\x1B[43m",
+  fgBlack: "\x1B[30m",
+  fgGreen: "\x1B[32m",
+  fgRed: "\x1B[31m",
+  fgWhite: "\x1B[37m",
+  fgYellow: "\x1B[33m",
+  reset: "\x1B[0m"
+};
+
+// src/__legacy__/utils/session-utils.ts
+var SessionUtils = class {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+  }
+  static createUUID() {
+    const generated_uuid = uuidv4();
+    return generated_uuid;
+  }
+  static validateUUID(uuid) {
+    if (uuidValidate(uuid) && uuidVersion(uuid) === UUID_VERSION) {
+      return Promise.resolve(true);
+    } else {
+      return Promise.resolve(false);
+    }
+  }
+  static validateSession(sessionData) {
+    const currentTime = Date.now();
+    const expiryTimeStamp = sessionData.created_at + parseInt(sessionData.expires_in) * 60 * 1e3;
+    if (currentTime < expiryTimeStamp) {
+      return Promise.resolve(true);
+    } else {
+      Logger.warn("Expired Session");
+      return Promise.resolve(false);
+    }
+  }
+};
+
+// src/__legacy__/utils/logger-utils.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["OFF"] = 4] = "OFF";
+  return LogLevel2;
+})(LogLevel || {});
+var Logger = class {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+  }
+  static debug(message) {
+    if (LogLevel[this.LOG_LEVEL] <= 0 /* DEBUG */)
+      console.log(
+        LOGGER_CONFIG.bgGreen,
+        LOGGER_CONFIG.fgBlack,
+        "DEBUG",
+        LOGGER_CONFIG.reset,
+        LOGGER_CONFIG.fgGreen,
+        message,
+        LOGGER_CONFIG.reset
+      );
+  }
+  static info(message) {
+    if (LogLevel[this.LOG_LEVEL] <= 1 /* INFO */)
+      console.log(
+        LOGGER_CONFIG.bgWhite,
+        LOGGER_CONFIG.fgBlack,
+        "INFO",
+        LOGGER_CONFIG.reset,
+        LOGGER_CONFIG.fgWhite,
+        message,
+        LOGGER_CONFIG.reset
+      );
+  }
+  static warn(message) {
+    if (LogLevel[this.LOG_LEVEL] <= 2 /* WARN */)
+      console.log(
+        LOGGER_CONFIG.bgYellow,
+        LOGGER_CONFIG.fgBlack,
+        "WARNING",
+        LOGGER_CONFIG.reset,
+        LOGGER_CONFIG.fgYellow,
+        message,
+        LOGGER_CONFIG.reset
+      );
+  }
+  static error(message) {
+    if (LogLevel[this.LOG_LEVEL] <= 3 /* ERROR */)
+      console.log(
+        LOGGER_CONFIG.bgRed,
+        LOGGER_CONFIG.fgBlack,
+        "ERROR",
+        LOGGER_CONFIG.reset,
+        LOGGER_CONFIG.fgRed,
+        message,
+        LOGGER_CONFIG.reset
+      );
+  }
+};
+__publicField(Logger, "LOG_LEVEL", process.env["LOG_LEVEL"] ?? LogLevel[4 /* OFF */]);
+
+// src/__legacy__/utils/crypto-utils.ts
+import base64url from "base64url";
+import sha256 from "fast-sha256";
+import * as jose from "jose";
+import randombytes from "secure-random-bytes";
+var NodeCryptoUtils = class {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+  }
+  /**
+   * Get URL encoded string.
+   *
+   * @returns {string} base 64 url encoded value.
+   */
+  base64URLEncode(value) {
+    return base64url.encode(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  }
+  base64URLDecode(value) {
+    return base64url.decode(value).toString();
+  }
+  hashSha256(data) {
+    return Buffer.from(sha256(new TextEncoder().encode(data)));
+  }
+  generateRandomBytes(length) {
+    return randombytes(length);
+  }
+  async verifyJwt(idToken, jwk, algorithms, clientID, issuer, subject, clockTolerance) {
+    const key = await jose.importJWK(jwk);
+    return jose.jwtVerify(idToken, key, {
+      algorithms,
+      audience: clientID,
+      clockTolerance,
+      issuer,
+      subject
+    }).then(() => {
+      return Promise.resolve(true);
+    });
+  }
+};
+
+// src/__legacy__/core/authentication.ts
+var AsgardeoNodeCore = class _AsgardeoNodeCore {
+  constructor(config, store) {
+    __publicField(this, "_auth");
+    __publicField(this, "_cryptoUtils");
+    __publicField(this, "_store");
+    __publicField(this, "_dataLayer");
+    if (!store) {
+      this._store = new MemoryCacheStore();
+    } else {
+      this._store = store;
+    }
+    this._cryptoUtils = new NodeCryptoUtils();
+    this._auth = new AsgardeoAuthClient();
+    this._auth.initialize(config, this._store, this._cryptoUtils);
+    this._dataLayer = this._auth.getDataLayer();
+    Logger.debug("Initialized AsgardeoAuthClient successfully");
+  }
+  async signIn(authURLCallback, userID, authorizationCode, sessionState, state, signInConfig) {
+    if (!userID) {
+      return Promise.reject(
+        new AsgardeoAuthException(
+          "NODE-AUTH_CORE-SI-NF01",
+          "No user ID was provided.",
+          "Unable to sign in the user as no user ID was provided."
+        )
+      );
+    }
+    if (await this.isAuthenticated(userID)) {
+      const sessionData = await this._dataLayer.getSessionData(userID);
+      return Promise.resolve({
+        accessToken: sessionData.access_token,
+        createdAt: sessionData.created_at,
+        expiresIn: sessionData.expires_in,
+        idToken: sessionData.id_token,
+        refreshToken: sessionData.refresh_token ?? "",
+        scope: sessionData.scope,
+        tokenType: sessionData.token_type
+      });
+    }
+    if (!authorizationCode || !state) {
+      if (!authURLCallback || typeof authURLCallback !== "function") {
+        return Promise.reject(
+          new AsgardeoAuthException(
+            "NODE-AUTH_CORE-SI-NF02",
+            "Invalid AuthURLCallback function.",
+            "The AuthURLCallback is not defined or is not a function."
+          )
+        );
+      }
+      const authURL = await this.getAuthURL(userID, signInConfig);
+      authURLCallback(authURL);
+      return Promise.resolve({
+        accessToken: "",
+        createdAt: 0,
+        expiresIn: "",
+        idToken: "",
+        refreshToken: "",
+        scope: "",
+        session: "",
+        tokenType: ""
+      });
+    }
+    return this.requestAccessToken(authorizationCode, sessionState ?? "", userID, state);
+  }
+  async getAuthURL(userId, signInConfig) {
+    const authURL = await this._auth.getAuthorizationURL(signInConfig, userId);
+    if (authURL) {
+      return Promise.resolve(authURL.toString());
+    } else {
+      return Promise.reject(
+        new AsgardeoAuthException(
+          "NODE-AUTH_CORE-GAU-NF01",
+          "Getting Authorization URL failed.",
+          "No authorization URL was returned by the Asgardeo Auth JS SDK."
+        )
+      );
+    }
+  }
+  async requestAccessToken(authorizationCode, sessionState, userId, state) {
+    return this._auth.requestAccessToken(authorizationCode, sessionState, state, userId);
+  }
+  async getIDToken(userId) {
+    const is_logged_in = await this.isAuthenticated(userId);
+    if (!is_logged_in) {
+      return Promise.reject(
+        new AsgardeoAuthException(
+          "NODE-AUTH_CORE-GIT-NF01",
+          "The user is not logged in.",
+          "No session ID was found for the requested user. User is not logged in."
+        )
+      );
+    }
+    const idToken = await this._auth.getIDToken(userId);
+    if (idToken) {
+      return Promise.resolve(idToken);
+    } else {
+      return Promise.reject(
+        new AsgardeoAuthException(
+          "NODE-AUTH_CORE-GIT-NF02",
+          "Requesting ID Token Failed",
+          "No ID Token was returned by the Asgardeo Auth JS SDK."
+        )
+      );
+    }
+  }
+  async refreshAccessToken(userId) {
+    return this._auth.refreshAccessToken(userId);
+  }
+  async isAuthenticated(userId) {
+    try {
+      if (!await this._auth.isAuthenticated(userId)) {
+        return Promise.resolve(false);
+      }
+      if (await SessionUtils.validateSession(await this._dataLayer.getSessionData(userId))) {
+        return Promise.resolve(true);
+      }
+      const refreshed_token = await this.refreshAccessToken(userId);
+      if (refreshed_token) {
+        return Promise.resolve(true);
+      }
+      this._dataLayer.removeSessionData(userId);
+      this._dataLayer.getTemporaryData(userId);
+      return Promise.resolve(false);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  async signOut(userId) {
+    const signOutURL = await this._auth.getSignOutURL(userId);
+    if (!signOutURL) {
+      return Promise.reject(
+        new AsgardeoAuthException(
+          "NODE-AUTH_CORE-SO-NF01",
+          "Signing out the user failed.",
+          "Could not obtain the sign-out URL from the server."
+        )
+      );
+    }
+    return Promise.resolve(signOutURL);
+  }
+  async getBasicUserInfo(userId) {
+    return this._auth.getBasicUserInfo(userId);
+  }
+  async getOIDCServiceEndpoints() {
+    return this._auth.getOIDCServiceEndpoints();
+  }
+  async getDecodedIDToken(userId) {
+    return this._auth.getDecodedIDToken(userId);
+  }
+  async getAccessToken(userId) {
+    return this._auth.getAccessToken(userId);
+  }
+  async requestCustomGrant(config, userId) {
+    return this._auth.requestCustomGrant(config, userId);
+  }
+  async updateConfig(config) {
+    return this._auth.updateConfig(config);
+  }
+  async revokeAccessToken(userId) {
+    return this._auth.revokeAccessToken(userId);
+  }
+  static didSignOutFail(signOutRedirectURL) {
+    return _AsgardeoNodeCore.didSignOutFail(signOutRedirectURL);
+  }
+  static isSignOutSuccessful(signOutRedirectURL) {
+    return _AsgardeoNodeCore.isSignOutSuccessful(signOutRedirectURL);
+  }
+  getDataLayer() {
+    return this._dataLayer;
+  }
+};
+
+// src/__legacy__/client.ts
+var AsgardeoNodeClient = class _AsgardeoNodeClient {
+  /**
+    * This is the constructor method that returns an instance of the `AsgardeoNodeClient` class.
+    *
+    * @param {AuthClientConfig<T>} config - The configuration object.
+    * @param {Store} store - The store object.
+    *
+    * @example
+    * ```
+    * const _store: Store = new DataStore();
+    * const _config = {
+           signInRedirectURL: "http://localhost:3000/sign-in",
+           signOutRedirectURL: "http://localhost:3000/dashboard",
+           clientID: "client ID",
+           serverOrigin: "https://api.asgardeo.io/t/<org_name>"
+       };
+    * const auth = new AsgardeoNodeClient(_config,_store);
+    * ```
+    *
+    * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#constructor
+    * @preserve
+    */
+  constructor() {
+    __publicField(this, "_authCore");
+  }
+  async initialize(config, store) {
+    this._authCore = new AsgardeoNodeCore(config, store);
+    return Promise.resolve(true);
+  }
+  /**
+   * This method logs in a user. If the authorization code is not available it will resolve with the
+   * authorization URL to authorize the user.
+   * @param {string} authorizationCode - The authorization code obtained from Asgardeo after a user signs in.
+   * @param {String} sessionState - The session state obtained from Asgardeo after a user signs in.
+   * @param {string} userID - (Optional) A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   * @param {string} state - The state parameter in the redirect URL.
+   *
+   * @return {Promise<URLResponse | NodeTokenResponse>} - A Promise that resolves with the
+   * [`URLResponse`](#URLResponse) object or a Promise that resolves with
+   * the [`NodeTokenResponse`](#NodeTokenResponse) object.
+   *
+   * @example
+   * ```
+   * authClient.signIn(req.query.code, req.query.session_state).then(response => {
+   *   //URL property will available if the user has not been authenticated already
+   *   if (response.hasOwnProperty('url')) {
+   *       res.redirect(response.url)
+   *   } else {
+   *       //Set the cookie
+   *       res.cookie('ASGARDEO_SESSION_ID', response.session, { maxAge: 900000, httpOnly: true, SameSite: true });
+   *       res.status(200).send(response)
+   *   }
+   *});
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#signIn
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  async signIn(authURLCallback, userId, authorizationCode, sessionState, state, signInConfig) {
+    return this._authCore.signIn(authURLCallback, userId, authorizationCode, sessionState, state, signInConfig);
+  }
+  /**
+   * This method clears all session data and returns the sign-out URL.
+   * @param {string} userId - The userId of the user. (If you are using ExpressJS,
+   * you may get this from the request cookies)
+   *
+   * @return {Promise<string>} - A Promise that resolves with the sign-out URL.
+   *
+   * @example
+   * ```
+   * const signOutUrl = await auth.signOut(userId);
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#signOut
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  async signOut(userId) {
+    return this._authCore.signOut(userId);
+  }
+  /**
+   * This method returns a boolean value indicating if the user is authenticated or not.
+   * @param {string} userId - The userId of the user.
+   * (If you are using ExpressJS, you may get this from the request cookies)
+   *
+   * @return { Promise<boolean>} -A boolean value that indicates of the user is authenticated or not.
+   *
+   * @example
+   * ```
+   * const isAuth = await authClient.isAuthenticated("a2a2972c-51cd-5e9d-a9ae-058fae9f7927");
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#isAuthenticated
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  async isAuthenticated(userId) {
+    return this._authCore.isAuthenticated(userId);
+  }
+  /**
+   * This method returns the id token.
+   * @param {string} userId - The userId of the user.
+   * (If you are using ExpressJS, you may get this from the request cookies)
+   *
+   * @return {Promise<string>} -A Promise that resolves with the ID Token.
+   *
+   * @example
+   * ```
+   * const isAuth = await authClient.getIDToken("a2a2972c-51cd-5e9d-a9ae-058fae9f7927");
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getIDToken
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  async getIDToken(userId) {
+    return this._authCore.getIDToken(userId);
+  }
+  /**
+   * This method returns an object containing basic user information obtained from the id token.
+   * @param {string} userId - The userId of the user.
+   * (If you are using ExpressJS, you may get this from the request cookies)
+   *
+   * @return {Promise<string>} -A Promise that resolves with the
+   * An object containing basic user information obtained from the id token.
+   *
+   * @example
+   * ```
+   * const basicInfo = await authClient.getBasicUserInfo("a2a2972c-51cd-5e9d-a9ae-058fae9f7927");
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getBasicUserInfo
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  async getBasicUserInfo(userId) {
+    return this._authCore.getBasicUserInfo(userId);
+  }
+  /**
+   * This method returns an object containing the OIDC service endpoints returned by the `.well-known` endpoint.
+   * @return {Promise<OIDCEndpoints>} -A Promise that resolves with
+   * an object containing the OIDC service endpoints returned by the `.well-known` endpoint.
+   *
+   * @example
+   * ```
+   * const oidcEndpoints = await auth.getOIDCServiceEndpoints();
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getOIDCServiceEndpoints
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  async getOIDCServiceEndpoints() {
+    return this._authCore.getOIDCServiceEndpoints();
+  }
+  /**
+   * This method returns the decoded ID token payload.
+   * @param {string} userId - The userId of the user.
+   * (If you are using ExpressJS, you may get this from the request cookies)
+   *
+   * @return {Promise<IdTokenPayload>} -A Promise that resolves with
+   * an object containing the decoded ID token payload.
+   *
+   * @example
+   * ```
+   * const decodedIDTokenPayload = await auth.getDecodedIDToken("a2a2972c-51cd-5e9d-a9ae-058fae9f7927");
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getDecodedIDToken
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  async getDecodedIDToken(userId) {
+    return this._authCore.getDecodedIDToken(userId);
+  }
+  /**
+   * This method returns the access token.
+   * @param {string} userId - The userId of the user.
+   * (If you are using ExpressJS, you may get this from the request cookies)
+   *
+   * @return {Promise<string>} -A Promise that resolves with
+   * the access token stored in the store
+   *
+   * @example
+   * ```
+   *const accessToken = await auth.getAccessToken("a2a2972c-51cd-5e9d-a9ae-058fae9f7927");
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getAccessToken
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  async getAccessToken(userId) {
+    return this._authCore.getAccessToken(userId);
+  }
+  /**
+       * This method returns Promise that resolves with the token information 
+       * or the response returned by the server depending on the configuration passed.
+       * @param {CustomGrantConfig} config - The config object contains attributes that would be used 
+       * to configure the custom grant request.
+       *
+       * @param {string} userId - The userId of the user.
+       * (If you are using ExpressJS, you may get this from the request cookies)
+       * 
+       * @return {Promise<TokenResponse | FetchResponse>} -A Promise that resolves with the token information 
+       * or the response returned by the server depending on the configuration passed.
+       *
+       * @example
+       * ```
+       * const config = {
+       *      attachToken: false,
+       *      data: {
+       *          client_id: "{{clientID}}",
+       *          grant_type: "account_switch",
+       *          scope: "{{scope}}",
+       *          token: "{{token}}",
+       *      },
+       *      id: "account-switch",
+       *      returnResponse: true,
+       *      returnsSession: true,
+       *      signInRequired: true
+       * }
+  
+       * auth.requestCustomGrant(config).then((response)=>{
+       *     console.log(response);
+       * }).catch((error)=>{
+       *     console.error(error);
+       * });
+       * ```
+       *
+       * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#requestCustomGrant
+       *
+       * @memberof AsgardeoNodeClient
+       *
+       */
+  async requestCustomGrant(config, userId) {
+    return this._authCore.requestCustomGrant(config, userId);
+  }
+  /**
+   * This method can be used to update the configurations passed into the constructor of the AsgardeoAuthClient.
+   * @param {AuthClientConfig<T>} config - The config object containing the attributes
+   * that can be used to configure the SDK
+   *
+   * @return {Promise<void>} -A Promise that resolves with a void.
+   *
+   * @example
+   * ```
+   * const updateConfig = await auth.updateConfig({
+   *       signOutRedirectURL: "http://localhost:3000/sign-out"
+   *   });
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#updateConfig
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  async updateConfig(config) {
+    return this._authCore.updateConfig(config);
+  }
+  /**
+   * This method returns a Promise that resolves with the response returned by the server.
+   * @param {string} userId - The userId of the user.
+   * (If you are using ExpressJS, you may get this from the request cookies)
+   *
+   * @return {Promise<FetchResponse>} -A Promise that resolves with the response returned by the server.
+   *
+   * @example
+   * ```
+   * const revokeToken = await auth.revokeAccessToken("a2a2972c-51cd-5e9d-a9ae-058fae9f7927");
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#revokeAccessToken
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  async revokeAccessToken(userId) {
+    return this._authCore.revokeAccessToken(userId);
+  }
+  /**
+   * This method refreshes the access token and returns a Promise that resolves with the new access
+   * token and other relevant data.
+   *
+   * @param {string} userId - A unique ID of the user to be authenticated. This is useful in multi-user
+   * scenarios where each user should be uniquely identified.
+   *
+   * @returns {Promise<TokenResponse>} - A Promise that resolves with the token response.
+   *
+   * @example
+   * ```
+   * const tokenResponse = await auth.refreshAccessToken("a2a2972c-51cd-5e9d-a9ae-058fae9f7927")
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#refreshAccessToken
+   *
+   * @memberof AsgardeoNodeClient
+   */
+  refreshAccessToken(userId) {
+    return this._authCore.refreshAccessToken(userId);
+  }
+  /**
+   * This method returns if the user has been successfully signed out or not.
+   * @param {string} signOutRedirectURL - The URL to which the user is redirected to
+   * after signing out from the server.
+   *
+   * @return {boolean} - A boolean value indicating if the user has been signed out or not.
+   *
+   * @example
+   * ```
+   * const isSignedOut = auth.isSignOutSuccessful(<signout_url>);;
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#isSignOutSuccessful
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  static isSignOutSuccessful(signOutRedirectURL) {
+    return _AsgardeoNodeClient.isSignOutSuccessful(signOutRedirectURL);
+  }
+  /**
+   * This method returns if sign-out failed or not
+   * @param {string} signOutRedirectURL - The URL to which the user is redirected to
+   * after signing out from the server.
+   *
+   * @return {boolean} - A boolean value indicating if sign-out failed or not.
+   *
+   * @example
+   * ```
+   * const isSignedOut = auth.isSignOutSuccessful(<signout_url>);
+   * ```
+   *
+   * @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#didSignOutFail
+   *
+   * @memberof AsgardeoNodeClient
+   *
+   */
+  static didSignOutFail(signOutRedirectURL) {
+    return _AsgardeoNodeClient.didSignOutFail(signOutRedirectURL);
+  }
+  async getDataLayer() {
+    return this._authCore.getDataLayer();
+  }
+};
+
+// src/constants/CookieConfig.ts
+var CookieConfig = class {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+  }
+};
+__publicField(CookieConfig, "SESSION_COOKIE_NAME", "ASGARDEO_SESSION_ID");
+__publicField(CookieConfig, "DEFAULT_MAX_AGE", 3600);
+__publicField(CookieConfig, "DEFAULT_HTTP_ONLY", true);
+__publicField(CookieConfig, "DEFAULT_SAME_SITE", "lax");
+__publicField(CookieConfig, "DEFAULT_SECURE", true);
+var CookieConfig_default = CookieConfig;
+
+// src/utils/generateSessionId.ts
+var generateSessionId = () => (/* @__PURE__ */ new Date()).getTime().toString(36) + Math.random().toString(36).substring(2);
+var generateSessionId_default = generateSessionId;
+
+// src/utils/getSessionCookieOptions.ts
+var getSessionCookieOptions = (options) => ({
+  ...options,
+  httpOnly: options.httpOnly ?? CookieConfig_default.DEFAULT_HTTP_ONLY,
+  maxAge: options.maxAge ?? CookieConfig_default.DEFAULT_MAX_AGE,
+  sameSite: options.sameSite ?? CookieConfig_default.DEFAULT_SAME_SITE,
+  secure: options.secure ?? CookieConfig_default.DEFAULT_SECURE
+});
+var getSessionCookieOptions_default = getSessionCookieOptions;
+
+// src/AsgardeoNodeClient.ts
+import { AsgardeoJavaScriptClient } from "@asgardeo/javascript";
+var AsgardeoNodeClient2 = class extends AsgardeoJavaScriptClient {
+};
+var AsgardeoNodeClient_default = AsgardeoNodeClient2;
+
+// src/index.ts
+export * from "@asgardeo/javascript";
+if (!globalThis.fetch) {
+  globalThis.fetch = fetch;
+  globalThis.Headers = Headers;
+  globalThis.Request = Request;
+  globalThis.Response = Response;
+}
+export {
+  AsgardeoNodeClient_default as AsgardeoNodeClient,
+  CookieConfig_default as CookieConfig,
+  AsgardeoNodeClient as LegacyAsgardeoNodeClient,
+  Logger,
+  generateSessionId_default as generateSessionId,
+  getSessionCookieOptions_default as getSessionCookieOptions
+};
+//# sourceMappingURL=index.js.map