@thunderid/node 0.0.1

package/dist/cjs/index.cjs

@@ -0,0 +1,773 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let cross_fetch = require("cross-fetch");
+cross_fetch = __toESM(cross_fetch);
+let __thunderid_javascript = require("@thunderid/javascript");
+__thunderid_javascript = __toESM(__thunderid_javascript);
+let memory_cache = require("memory-cache");
+memory_cache = __toESM(memory_cache);
+let uuid = require("uuid");
+uuid = __toESM(uuid);
+let base64url = require("base64url");
+base64url = __toESM(base64url);
+let fast_sha256 = require("fast-sha256");
+fast_sha256 = __toESM(fast_sha256);
+let jose = require("jose");
+jose = __toESM(jose);
+let secure_random_bytes = require("secure-random-bytes");
+secure_random_bytes = __toESM(secure_random_bytes);
+
+//#region src/__legacy__/stores/memory-cache-store.ts
+var MemoryCacheStore = class {
+	async setData(key, value) {
+		memory_cache.default.put(key, value);
+	}
+	async getData(key) {
+		return memory_cache.default.get(key) ?? "{}";
+	}
+	async removeData(key) {
+		memory_cache.default.del(key);
+	}
+};
+
+//#endregion
+//#region src/__legacy__/constants/uuid-config.ts
+/**
+* Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+*
+* WSO2 LLC. licenses this file to you under the Apache License,
+* Version 2.0 (the "License"); you may not use this file except
+* in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied. See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+const UUID_VERSION = 4;
+
+//#endregion
+//#region src/__legacy__/constants/logger-config.ts
+const 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"
+};
+
+//#endregion
+//#region src/__legacy__/utils/session-utils.ts
+var SessionUtils = class {
+	constructor() {}
+	static createUUID() {
+		return (0, uuid.v4)();
+	}
+	static validateUUID(uuid$1) {
+		if ((0, uuid.validate)(uuid$1) && (0, uuid.version)(uuid$1) === UUID_VERSION) return Promise.resolve(true);
+		return Promise.resolve(false);
+	}
+	static validateSession(sessionData) {
+		if (Date.now() < sessionData.created_at + parseInt(sessionData.expires_in, 10) * 60 * 1e3) return Promise.resolve(true);
+		Logger.warn("Expired Session");
+		return Promise.resolve(false);
+	}
+};
+
+//#endregion
+//#region src/__legacy__/utils/logger-utils.ts
+var LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1[LogLevel$1["DEBUG"] = 0] = "DEBUG";
+	LogLevel$1[LogLevel$1["INFO"] = 1] = "INFO";
+	LogLevel$1[LogLevel$1["WARN"] = 2] = "WARN";
+	LogLevel$1[LogLevel$1["ERROR"] = 3] = "ERROR";
+	LogLevel$1[LogLevel$1["OFF"] = 4] = "OFF";
+	return LogLevel$1;
+}(LogLevel || {});
+var Logger = class {
+	static LOG_LEVEL = process.env["LOG_LEVEL"] ?? LogLevel[LogLevel.OFF];
+	constructor() {}
+	static debug(message) {
+		if (LogLevel[this.LOG_LEVEL] <= LogLevel.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] <= LogLevel.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] <= LogLevel.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] <= LogLevel.ERROR) console.log(LOGGER_CONFIG.bgRed, LOGGER_CONFIG.fgBlack, "ERROR", LOGGER_CONFIG.reset, LOGGER_CONFIG.fgRed, message, LOGGER_CONFIG.reset);
+	}
+};
+
+//#endregion
+//#region src/__legacy__/utils/crypto-utils.ts
+var NodeCryptoUtils = class {
+	constructor() {}
+	/**
+	* Get URL encoded string.
+	*
+	* @returns {string} base 64 url encoded value.
+	*/
+	base64URLEncode(value) {
+		return base64url.default.encode(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+	}
+	base64URLDecode(value) {
+		return base64url.default.decode(value).toString();
+	}
+	hashSha256(data) {
+		return Buffer.from((0, fast_sha256.default)(new TextEncoder().encode(data)));
+	}
+	generateRandomBytes(length) {
+		return (0, secure_random_bytes.default)(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(() => Promise.resolve(true));
+	}
+};
+
+//#endregion
+//#region src/__legacy__/core/authentication.ts
+var ThunderIDNodeCore = class ThunderIDNodeCore {
+	auth;
+	cryptoUtils;
+	store;
+	storageManager;
+	constructor(config, store) {
+		if (!store) this.store = new MemoryCacheStore();
+		else this.store = store;
+		this.cryptoUtils = new NodeCryptoUtils();
+		this.auth = new __thunderid_javascript.ThunderIDAuthClient();
+		this.auth.initialize(config, this.store, this.cryptoUtils);
+		this.storageManager = this.auth.getStorageManager();
+		Logger.debug("Initialized ThunderIDAuthClient successfully");
+	}
+	async signIn(authURLCallback, userId, authorizationCode, sessionState, state, signInConfig) {
+		if (!userId) return Promise.reject(new __thunderid_javascript.ThunderIDAuthException("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.isSignedIn(userId)) {
+			const sessionData = await this.storageManager.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 __thunderid_javascript.ThunderIDAuthException("NODE-AUTH_CORE-SI-NF02", "Invalid AuthURLCallback function.", "The AuthURLCallback is not defined or is not a function."));
+			authURLCallback(await this.getAuthURL(userId, signInConfig));
+			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.getSignInUrl(signInConfig, userId);
+		if (authURL) return Promise.resolve(authURL.toString());
+		return Promise.reject(new __thunderid_javascript.ThunderIDAuthException("NODE-AUTH_CORE-GAU-NF01", "Getting Authorization URL failed.", "No authorization URL was returned by the ThunderID Auth JS SDK."));
+	}
+	async requestAccessToken(authorizationCode, sessionState, userId, state) {
+		return this.auth.requestAccessToken(authorizationCode, sessionState, state, userId);
+	}
+	async getIdToken(userId) {
+		if (!await this.isSignedIn(userId)) return Promise.reject(new __thunderid_javascript.ThunderIDAuthException("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);
+		return Promise.reject(new __thunderid_javascript.ThunderIDAuthException("NODE-AUTH_CORE-GIT-NF02", "Requesting ID Token Failed", "No ID Token was returned by the ThunderID Auth JS SDK."));
+	}
+	async refreshAccessToken(userId) {
+		return this.auth.refreshAccessToken(userId);
+	}
+	async isSignedIn(userId) {
+		try {
+			if (!await this.auth.isSignedIn(userId)) return await Promise.resolve(false);
+			if (await SessionUtils.validateSession(await this.storageManager.getSessionData(userId))) return await Promise.resolve(true);
+			if (await this.refreshAccessToken(userId)) return await Promise.resolve(true);
+			this.storageManager.removeSessionData(userId);
+			this.storageManager.getTemporaryData(userId);
+			return await 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 __thunderid_javascript.ThunderIDAuthException("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 getUser(userId) {
+		return this.auth.getUser(userId);
+	}
+	async getConfigData() {
+		return this.storageManager.getConfigData();
+	}
+	async getOpenIDProviderEndpoints() {
+		return this.auth.getOpenIDProviderEndpoints();
+	}
+	async getDecodedIdToken(userId, idToken) {
+		return this.auth.getDecodedIdToken(userId, idToken);
+	}
+	async getAccessToken(userId) {
+		return this.auth.getAccessToken(userId);
+	}
+	async exchangeToken(config, userId) {
+		return this.auth.exchangeToken(config, userId);
+	}
+	async reInitialize(config) {
+		return this.auth.reInitialize(config);
+	}
+	async revokeAccessToken(userId) {
+		return this.auth.revokeAccessToken(userId);
+	}
+	static didSignOutFail(afterSignOutUrl) {
+		return ThunderIDNodeCore.didSignOutFail(afterSignOutUrl);
+	}
+	static isSignOutSuccessful(afterSignOutUrl) {
+		return ThunderIDNodeCore.isSignOutSuccessful(afterSignOutUrl);
+	}
+	getStorageManager() {
+		return this.storageManager;
+	}
+	async decodeJwtToken(token) {
+		return this.auth.decodeJwtToken(token);
+	}
+};
+
+//#endregion
+//#region src/__legacy__/client.ts
+/**
+* This class provides the necessary methods needed to implement authentication.
+*
+* @export
+* @class ThunderIDNodeClient
+*/
+var ThunderIDNodeClient = class ThunderIDNodeClient {
+	authCore;
+	/**
+	* This is the constructor method that returns an instance of the `ThunderIDNodeClient` class.
+	*
+	* @param {AuthClientConfig<T>} config - The configuration object.
+	* @param {Storage} store - The store object.
+	*
+	* @example
+	* ```
+	* const _store: Storage = new DataStore();
+	* const _config = {
+	afterSignInUrl: "http://localhost:3000/sign-in",
+	afterSignOutUrl: "http://localhost:3000/dashboard",
+	clientId: "client ID",
+	serverOrigin: "https://api.asgardeo.io/t/<org_name>"
+	};
+	* const auth = new ThunderIDNodeClient(_config,_store);
+	* ```
+	*
+	* @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#constructor
+	* @preserve
+	*/
+	constructor() {}
+	async initialize(config, store) {
+		this.authCore = new ThunderIDNodeCore(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 ThunderID after a user signs in.
+	* @param {String} sessionState - The session state obtained from ThunderID 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 ThunderIDNodeClient
+	*
+	*/
+	async signIn(authURLCallback, userId, authorizationCode, sessionState, state, signInConfig) {
+		return this.authCore.signIn(authURLCallback, userId, authorizationCode, sessionState, state, signInConfig);
+	}
+	/**
+	* Method to get the configuration data.
+	*
+	* @returns {Promise<AuthClientConfig<Config>>} - A promise that resolves with the configuration data.
+	*/
+	async getConfigData() {
+		return this.authCore.getConfigData();
+	}
+	/**
+	* 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 ThunderIDNodeClient
+	*
+	*/
+	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.isSignedIn("a2a2972c-51cd-5e9d-a9ae-058fae9f7927");
+	* ```
+	*
+	* @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#isSignedIn
+	*
+	* @memberof ThunderIDNodeClient
+	*
+	*/
+	async isSignedIn(userId) {
+		return this.authCore.isSignedIn(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 ThunderIDNodeClient
+	*
+	*/
+	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.getUser("a2a2972c-51cd-5e9d-a9ae-058fae9f7927");
+	* ```
+	*
+	* @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getUser
+	*
+	* @memberof ThunderIDNodeClient
+	*
+	*/
+	async getUser(userId) {
+		return this.authCore.getUser(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.getOpenIDProviderEndpoints();
+	* ```
+	*
+	* @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getOpenIDProviderEndpoints
+	*
+	* @memberof ThunderIDNodeClient
+	*
+	*/
+	async getOpenIDProviderEndpoints() {
+		return this.authCore.getOpenIDProviderEndpoints();
+	}
+	/**
+	* 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<IdToken>} -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 ThunderIDNodeClient
+	*
+	*/
+	async getDecodedIdToken(userId, idToken) {
+		return this.authCore.getDecodedIdToken(userId, idToken);
+	}
+	/**
+	* 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 ThunderIDNodeClient
+	*
+	*/
+	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 {TokenExchangeRequestConfig} 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 | Response>} -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.exchangeToken(config).then((response)=>{
+	*     console.log(response);
+	* }).catch((error)=>{
+	*     console.error(error);
+	* });
+	* ```
+	*
+	* @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#exchangeToken
+	*
+	* @memberof ThunderIDNodeClient
+	*
+	*/
+	async exchangeToken(config, userId) {
+		return this.authCore.exchangeToken(config, userId);
+	}
+	/**
+	* This method can be used to update the configurations passed into the constructor of the ThunderIDAuthClient.
+	* @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 reInitialize = await auth.reInitialize({
+	*       afterSignOutUrl: "http://localhost:3000/sign-out"
+	*   });
+	* ```
+	*
+	* @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#reInitialize
+	*
+	* @memberof ThunderIDNodeClient
+	*
+	*/
+	async reInitialize(config) {
+		return this.authCore.reInitialize(config);
+	}
+	async getSignInUrl(requestConfig, userId) {
+		return this.authCore.getAuthURL(userId, requestConfig);
+	}
+	/**
+	* 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<Response>} -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 ThunderIDNodeClient
+	*
+	*/
+	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 ThunderIDNodeClient
+	*/
+	refreshAccessToken(userId) {
+		return this.authCore.refreshAccessToken(userId);
+	}
+	/**
+	* This method returns if the user has been successfully signed out or not.
+	* @param {string} afterSignOutUrl - 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 ThunderIDNodeClient
+	*
+	*/
+	static isSignOutSuccessful(afterSignOutUrl) {
+		return ThunderIDNodeClient.isSignOutSuccessful(afterSignOutUrl);
+	}
+	/**
+	* This method returns if sign-out failed or not
+	* @param {string} afterSignOutUrl - 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 ThunderIDNodeClient
+	*
+	*/
+	static didSignOutFail(afterSignOutUrl) {
+		return ThunderIDNodeClient.didSignOutFail(afterSignOutUrl);
+	}
+	async getStorageManager() {
+		return this.authCore.getStorageManager();
+	}
+	async decodeJwtToken(token) {
+		return this.authCore.decodeJwtToken(token);
+	}
+};
+
+//#endregion
+//#region src/constants/CookieConfig.ts
+var CookieConfig = class {
+	static SESSION_COOKIE_NAME = `__${__thunderid_javascript.VendorConstants.VENDOR_PREFIX}__session`;
+	static TEMP_SESSION_COOKIE_NAME = `__${__thunderid_javascript.VendorConstants.VENDOR_PREFIX}__temp.session`;
+	static DEFAULT_MAX_AGE = 3600;
+	static DEFAULT_HTTP_ONLY = true;
+	static DEFAULT_SAME_SITE = "lax";
+	static DEFAULT_SECURE = true;
+	constructor() {}
+};
+var CookieConfig_default = CookieConfig;
+
+//#endregion
+//#region src/utils/generateSessionId.ts
+/**
+* Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+*
+* WSO2 LLC. licenses this file to you under the Apache License,
+* Version 2.0 (the "License"); you may not use this file except
+* in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied. See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+const generateSessionId = () => (/* @__PURE__ */ new Date()).getTime().toString(36) + Math.random().toString(36).substring(2);
+var generateSessionId_default = generateSessionId;
+
+//#endregion
+//#region src/utils/getSessionCookieOptions.ts
+/**
+* Creates a complete set of cookie options by merging provided options with defaults
+*
+* @param options - Partial cookie options to override defaults
+*
+* @returns Complete cookie options with all required fields
+*
+* @example
+* ```ts
+* // Use defaults with only maxAge override
+* const options = getSessionCookieOptions({ maxAge: 3600 });
+*
+* // Override multiple defaults
+* const options = getSessionCookieOptions({
+*   maxAge: 3600,
+*   secure: true,
+*   sameSite: 'strict'
+* });
+* ```
+*/
+const 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;
+
+//#endregion
+//#region src/ThunderIDNodeClient.ts
+/**
+* Base class for implementing ThunderID in Node.js based applications.
+* This class provides the core functionality for managing user authentication and sessions.
+*getConfigData
+* @typeParam T - Configuration type that extends ThunderIDNodeConfig.
+*/
+var ThunderIDNodeClient$1 = class extends __thunderid_javascript.ThunderIDJavaScriptClient {};
+var ThunderIDNodeClient_default = ThunderIDNodeClient$1;
+
+//#endregion
+//#region src/index.ts
+if (!globalThis.fetch) {
+	globalThis.fetch = cross_fetch.default;
+	globalThis.Headers = cross_fetch.Headers;
+	globalThis.Request = cross_fetch.Request;
+	globalThis.Response = cross_fetch.Response;
+}
+
+//#endregion
+exports.CookieConfig = CookieConfig_default;
+Object.defineProperty(exports, 'CookieOptions', {
+  enumerable: true,
+  get: function () {
+    return CookieOptions;
+  }
+});
+exports.LegacyThunderIDNodeClient = ThunderIDNodeClient;
+exports.Logger = Logger;
+exports.ThunderIDNodeClient = ThunderIDNodeClient_default;
+Object.defineProperty(exports, 'ThunderIDNodeConfig', {
+  enumerable: true,
+  get: function () {
+    return ThunderIDNodeConfig;
+  }
+});
+exports.generateSessionId = generateSessionId_default;
+exports.getSessionCookieOptions = getSessionCookieOptions_default;
+Object.keys(__thunderid_javascript).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return __thunderid_javascript[k]; }
+  });
+});