@thunderid/node 0.0.3 → 0.0.6

package/dist/cjs/index.cjs

@@ -27,8 +27,6 @@ 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");
@@ -37,8 +35,14 @@ let jose = require("jose");
 jose = __toESM(jose);
 let secure_random_bytes = require("secure-random-bytes");
 secure_random_bytes = __toESM(secure_random_bytes);
+let uuid = require("uuid");
+uuid = __toESM(uuid);
 
-//#region src/__legacy__/stores/memory-cache-store.ts
+//#region src/stores/MemoryCacheStore.ts
+/**
+* In-memory key-value store backed by `memory-cache`.
+* Used as the default storage when no custom store is provided to `ThunderIDNodeClient`.
+*/
 var MemoryCacheStore = class {
 	async setData(key, value) {
 		memory_cache.default.put(key, value);
@@ -50,97 +54,15 @@ var MemoryCacheStore = class {
 		memory_cache.default.del(key);
 	}
 };
+var MemoryCacheStore_default = MemoryCacheStore;
 
 //#endregion
-//#region src/__legacy__/constants/uuid-config.ts
+//#region src/utils/NodeCryptoUtils.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.
+* Node.js crypto utilities implementing the `Crypto` interface.
+* Uses `jose`, `base64url`, `fast-sha256`, and `secure-random-bytes`.
 */
-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, "");
 	}
@@ -164,40 +86,83 @@ var NodeCryptoUtils = class {
 		}).then(() => Promise.resolve(true));
 	}
 };
+var NodeCryptoUtils_default = NodeCryptoUtils;
 
 //#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");
+//#region src/utils/SessionUtils.ts
+const UUID_VERSION = 4;
+/**
+* Utility class for session validation and UUID management.
+*/
+var SessionUtils = class {
+	constructor() {}
+	/**
+	* Generates a new UUID v4 string.
+	*
+	* @returns A new UUID string.
+	*/
+	static createUUID() {
+		return (0, uuid.v4)();
+	}
+	/**
+	* Returns `true` if the given string is a valid UUID v4.
+	*
+	* @param uuid - The UUID string to validate.
+	*/
+	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);
 	}
-	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."));
+	/**
+	* Returns `true` if the session token is still within its validity window.
+	*
+	* @param sessionData - The session data to check.
+	*/
+	static validateSession(sessionData) {
+		const currentTime = Date.now();
+		const expiryTimeStamp = sessionData.created_at + parseInt(sessionData.expires_in, 10) * 60 * 1e3;
+		return Promise.resolve(currentTime < expiryTimeStamp);
+	}
+};
+var SessionUtils_default = SessionUtils;
+
+//#endregion
+//#region src/ThunderIDNodeClient.ts
+var ThunderIDNodeClient = class extends __thunderid_javascript.ThunderIDJavaScriptClient {
+	_nodeInstanceId = 0;
+	constructor(instanceId = 0) {
+		super(void 0, new NodeCryptoUtils_default());
+		this._nodeInstanceId = instanceId;
+	}
+	async initialize(config, storage) {
+		const merged = {
+			...config,
+			instanceId: this._nodeInstanceId
+		};
+		const store = storage ?? new MemoryCacheStore_default();
+		return super.initialize(merged, store);
+	}
+	getInstanceId() {
+		return this._nodeInstanceId;
+	}
+	async signIn(...args) {
+		const [authURLCallback, userId, authorizationCode, sessionState, state, signInConfig] = args;
+		if (!userId) return Promise.reject(new __thunderid_javascript.ThunderIDAuthException("NODE-AUTH_CLIENT-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);
+			const sessionData$1 = await this.getStorageManager().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
+				accessToken: sessionData$1.access_token,
+				createdAt: sessionData$1.created_at,
+				expiresIn: sessionData$1.expires_in,
+				idToken: sessionData$1.id_token,
+				refreshToken: sessionData$1.refresh_token ?? "",
+				scope: sessionData$1.scope,
+				tokenType: sessionData$1.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));
+			if (!authURLCallback || typeof authURLCallback !== "function") return Promise.reject(new __thunderid_javascript.ThunderIDAuthException("NODE-AUTH_CLIENT-SI-NF02", "Invalid AuthURLCallback function.", "The AuthURLCallback is not defined or is not a function."));
+			authURLCallback(await this.getSignInUrl(signInConfig, userId));
 			return Promise.resolve({
 				accessToken: "",
 				createdAt: 0,
@@ -205,460 +170,72 @@ var ThunderIDNodeCore = class ThunderIDNodeCore {
 				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);
+		await this.requestAccessToken(authorizationCode, sessionState ?? "", state, userId);
+		const sessionData = await this.getStorageManager().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
+		});
 	}
-	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 getSignInUrl(requestConfig, userId) {
+		const url = await super.getSignInUrl(requestConfig, userId);
+		if (!url) return Promise.reject(new __thunderid_javascript.ThunderIDAuthException("NODE-AUTH_CLIENT-GSIU-NF01", "Getting authorization URL failed.", "No authorization URL was returned."));
+		return url;
 	}
-	async refreshAccessToken(userId) {
-		return this.auth.refreshAccessToken(userId);
+	async signOut(...args) {
+		const userId = typeof args[0] === "string" ? args[0] : void 0;
+		const signOutUrl = await this.getSignOutUrl(userId);
+		if (!signOutUrl) return Promise.reject(new __thunderid_javascript.ThunderIDAuthException("NODE-AUTH_CLIENT-SO-NF01", "Signing out the user failed.", "Could not obtain the sign-out URL from the server."));
+		return signOutUrl;
 	}
 	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);
+			if (!await super.isSignedIn(userId)) return false;
+			const sm = this.getStorageManager();
+			const sessionData = await sm.getSessionData(userId);
+			if (await SessionUtils_default.validateSession(sessionData)) return true;
+			if (await this.refreshAccessToken(userId)) return true;
+			await sm.removeSessionData(userId);
+			return false;
+		} catch {
+			return false;
 		}
 	}
-	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 getIdToken(userId) {
+		if (!await this.isSignedIn(userId)) return Promise.reject(new __thunderid_javascript.ThunderIDAuthException("NODE-AUTH_CLIENT-GIT-NF01", "The user is not logged in.", "No session was found for the requested user."));
+		return super.getIdToken(userId);
 	}
-	async getConfigData() {
-		return this.storageManager.getConfigData();
+	async refreshAccessToken(userId) {
+		return super.refreshAccessToken(userId);
 	}
-	async getOpenIDProviderEndpoints() {
-		return this.auth.getOpenIDProviderEndpoints();
+	async revokeAccessToken(userId) {
+		return super.revokeAccessToken(userId);
 	}
 	async getDecodedIdToken(userId, idToken) {
-		return this.auth.getDecodedIdToken(userId, idToken);
+		return super.getDecodedIdToken(userId, idToken);
 	}
 	async getAccessToken(userId) {
-		return this.auth.getAccessToken(userId);
-	}
-	async exchangeToken(config, userId) {
-		return this.auth.exchangeToken(config, userId);
+		return super.getAccessToken(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);
+		return super.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();
+		return super.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);
+		return super.exchangeToken(config, userId);
 	}
 };
+var ThunderIDNodeClient_default = ThunderIDNodeClient;
 
 //#endregion
 //#region src/constants/CookieConfig.ts
@@ -697,46 +274,13 @@ 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) {
@@ -748,21 +292,10 @@ if (!globalThis.fetch) {
 
 //#endregion
 exports.CookieConfig = CookieConfig_default;
-Object.defineProperty(exports, 'CookieOptions', {
-  enumerable: true,
-  get: function () {
-    return CookieOptions;
-  }
-});
-exports.LegacyThunderIDNodeClient = ThunderIDNodeClient;
-exports.Logger = Logger;
+exports.MemoryCacheStore = MemoryCacheStore_default;
+exports.NodeCryptoUtils = NodeCryptoUtils_default;
+exports.SessionUtils = SessionUtils_default;
 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) {