@asgardeo/node
Version:
Node.js runtime specific implementation of Asgardeo JavaScript SDK.
812 lines (794 loc) • 27.9 kB
JavaScript
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 __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
// src/index.ts
var index_exports = {};
__export(index_exports, {
AsgardeoNodeClient: () => AsgardeoNodeClient_default,
CookieConfig: () => CookieConfig_default,
LegacyAsgardeoNodeClient: () => AsgardeoNodeClient,
Logger: () => Logger,
generateSessionId: () => generateSessionId_default,
getSessionCookieOptions: () => getSessionCookieOptions_default
});
module.exports = __toCommonJS(index_exports);
var import_cross_fetch = __toESM(require("cross-fetch"), 1);
// src/__legacy__/core/authentication.ts
var import_javascript = require("@asgardeo/javascript");
// src/__legacy__/stores/memory-cache-store.ts
var import_memory_cache = __toESM(require("memory-cache"), 1);
var MemoryCacheStore = class {
async setData(key, value) {
import_memory_cache.default.put(key, value);
}
async getData(key) {
return import_memory_cache.default.get(key) ?? "{}";
}
async removeData(key) {
import_memory_cache.default.del(key);
}
};
// src/__legacy__/utils/session-utils.ts
var import_uuid = require("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 = (0, import_uuid.v4)();
return generated_uuid;
}
static validateUUID(uuid) {
if ((0, import_uuid.validate)(uuid) && (0, import_uuid.version)(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
var import_base64url = __toESM(require("base64url"), 1);
var import_fast_sha256 = __toESM(require("fast-sha256"), 1);
var jose = __toESM(require("jose"), 1);
var import_secure_random_bytes = __toESM(require("secure-random-bytes"), 1);
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 import_base64url.default.encode(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
}
base64URLDecode(value) {
return import_base64url.default.decode(value).toString();
}
hashSha256(data) {
return Buffer.from((0, import_fast_sha256.default)(new TextEncoder().encode(data)));
}
generateRandomBytes(length) {
return (0, import_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(() => {
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, "_storageManager");
if (!store) {
this._store = new MemoryCacheStore();
} else {
this._store = store;
}
this._cryptoUtils = new NodeCryptoUtils();
this._auth = new import_javascript.AsgardeoAuthClient();
this._auth.initialize(config, this._store, this._cryptoUtils);
this._storageManager = this._auth.getStorageManager();
Logger.debug("Initialized AsgardeoAuthClient successfully");
}
async signIn(authURLCallback, userId, authorizationCode, sessionState, state, signInConfig) {
if (!userId) {
return Promise.reject(
new import_javascript.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.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 import_javascript.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.getSignInUrl(signInConfig, userId);
if (authURL) {
return Promise.resolve(authURL.toString());
} else {
return Promise.reject(
new import_javascript.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.isSignedIn(userId);
if (!is_logged_in) {
return Promise.reject(
new import_javascript.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 import_javascript.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 isSignedIn(userId) {
try {
if (!await this._auth.isSignedIn(userId)) {
return Promise.resolve(false);
}
if (await SessionUtils.validateSession(await this._storageManager.getSessionData(userId))) {
return Promise.resolve(true);
}
const refreshed_token = await this.refreshAccessToken(userId);
if (refreshed_token) {
return Promise.resolve(true);
}
this._storageManager.removeSessionData(userId);
this._storageManager.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 import_javascript.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 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 _AsgardeoNodeCore.didSignOutFail(afterSignOutUrl);
}
static isSignOutSuccessful(afterSignOutUrl) {
return _AsgardeoNodeCore.isSignOutSuccessful(afterSignOutUrl);
}
getStorageManager() {
return this._storageManager;
}
};
// 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 {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 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);
}
/**
* 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 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.isSignedIn("a2a2972c-51cd-5e9d-a9ae-058fae9f7927");
* ```
*
* @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#isSignedIn
*
* @memberof AsgardeoNodeClient
*
*/
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 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.getUser("a2a2972c-51cd-5e9d-a9ae-058fae9f7927");
* ```
*
* @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#getUser
*
* @memberof AsgardeoNodeClient
*
*/
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 AsgardeoNodeClient
*
*/
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 AsgardeoNodeClient
*
*/
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 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 {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 AsgardeoNodeClient
*
*/
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 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 reInitialize = await auth.reInitialize({
* afterSignOutUrl: "http://localhost:3000/sign-out"
* });
* ```
*
* @link https://github.com/asgardeo/asgardeo-auth-js-sdk/tree/master#reInitialize
*
* @memberof AsgardeoNodeClient
*
*/
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 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} 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 AsgardeoNodeClient
*
*/
static isSignOutSuccessful(afterSignOutUrl) {
return _AsgardeoNodeClient.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 AsgardeoNodeClient
*
*/
static didSignOutFail(afterSignOutUrl) {
return _AsgardeoNodeClient.didSignOutFail(afterSignOutUrl);
}
async getStorageManager() {
return this._authCore.getStorageManager();
}
};
// src/constants/CookieConfig.ts
var import_javascript2 = require("@asgardeo/javascript");
var CookieConfig = class {
// eslint-disable-next-line @typescript-eslint/no-empty-function
constructor() {
}
};
__publicField(CookieConfig, "SESSION_COOKIE_NAME", `__${import_javascript2.VendorConstants.VENDOR_PREFIX}__session`);
__publicField(CookieConfig, "TEMP_SESSION_COOKIE_NAME", `__${import_javascript2.VendorConstants.VENDOR_PREFIX}__temp.session`);
__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
var import_javascript3 = require("@asgardeo/javascript");
var AsgardeoNodeClient2 = class extends import_javascript3.AsgardeoJavaScriptClient {
};
var AsgardeoNodeClient_default = AsgardeoNodeClient2;
// src/index.ts
__reExport(index_exports, require("@asgardeo/javascript"), module.exports);
if (!globalThis.fetch) {
globalThis.fetch = import_cross_fetch.default;
globalThis.Headers = import_cross_fetch.Headers;
globalThis.Request = import_cross_fetch.Request;
globalThis.Response = import_cross_fetch.Response;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
AsgardeoNodeClient,
CookieConfig,
LegacyAsgardeoNodeClient,
Logger,
generateSessionId,
getSessionCookieOptions,
...require("@asgardeo/javascript")
});
//# sourceMappingURL=index.js.map