@asgardeo/javascript 0.8.0 → 0.8.1

package/dist/index.d.ts

@@ -55,6 +55,8 @@ export { FlowMode } from './models/flow';
 export { AsgardeoClient } from './models/client';
 export { BaseConfig, Config, Preferences, ThemePreferences, I18nPreferences, WithPreferences, SignInOptions, SignOutOptions, SignUpOptions, } from './models/config';
 export { TokenResponse, IdToken, TokenExchangeRequestConfig } from './models/token';
+export { AgentConfig } from './models/agent';
+export { AuthCodeResponse } from './models/auth-code-response';
 export { Crypto, JWKInterface } from './models/crypto';
 export { OAuthResponseMode } from './models/oauth-response';
 export { AuthorizeRequestUrlParams, KnownExtendedAuthorizeRequestUrlParams, ExtendedAuthorizeRequestUrlParams, } from './models/oauth-request';
@@ -63,6 +65,8 @@ export { Storage, TemporaryStore } from './models/store';
 export { User, UserProfile } from './models/user';
 export { SessionData } from './models/session';
 export { Organization } from './models/organization';
+export { TranslationFn } from './models/v2/translation';
+export { ResolveVarsOptions } from './models/v2/vars';
 export { BrandingPreference, BrandingPreferenceConfig, BrandingLayout, BrandingTheme, ThemeVariant, ButtonsConfig, ColorsConfig, ColorVariants, BrandingOrganizationDetails, UrlsConfig, } from './models/branding-preference';
 export { Schema, SchemaAttribute, WellKnownSchemaIds, FlattenedSchema } from './models/scim2-schema';
 export { RecursivePartial } from './models/utility-types';
@@ -92,6 +96,8 @@ export { default as get } from './utils/get';
 export { default as removeTrailingSlash } from './utils/removeTrailingSlash';
 export { default as resolveFieldType } from './utils/resolveFieldType';
 export { default as resolveFieldName } from './utils/resolveFieldName';
+export { default as resolveMeta } from './utils/v2/resolveMeta';
+export { default as resolveVars } from './utils/v2/resolveVars';
 export { default as processOpenIDScopes } from './utils/processOpenIDScopes';
 export { default as withVendorCSSClassPrefix } from './utils/withVendorCSSClassPrefix';
 export { default as transformBrandingPreferenceToTheme } from './utils/transformBrandingPreferenceToTheme';

package/dist/index.js

@@ -673,8 +673,9 @@ var IsomorphicCrypto = class {
    *
    * @returns - code challenge.
    */
-  getCodeChallenge(verifier) {
-    return this.cryptoUtils.base64URLEncode(this.cryptoUtils.hashSha256(verifier));
+  async getCodeChallenge(verifier) {
+    const hashed = await this.cryptoUtils.hashSha256(verifier);
+    return this.cryptoUtils.base64URLEncode(hashed);
   }
   /**
    * Get JWK used for the id_token
@@ -894,6 +895,31 @@ var StorageManager = class _StorageManager {
 };
 var StorageManager_default = StorageManager;
 
+// src/utils/deepMerge.ts
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && Object.prototype.toString.call(value) === "[object Object]";
+var deepMerge = (target, ...sources) => {
+  if (!target || typeof target !== "object") {
+    throw new Error("Target must be an object");
+  }
+  const result = { ...target };
+  sources.forEach((source) => {
+    if (!source || typeof source !== "object") {
+      return;
+    }
+    Object.keys(source).forEach((key) => {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+      if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+        result[key] = deepMerge(targetValue, sourceValue);
+      } else if (sourceValue !== void 0) {
+        result[key] = sourceValue;
+      }
+    });
+  });
+  return result;
+};
+var deepMerge_default = deepMerge;
+
 // src/utils/extractPkceStorageKeyFromState.ts
 var extractPkceStorageKeyFromState = (state) => {
   const index = parseInt(state.split("request_")[1], 10);
@@ -1134,7 +1160,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
       let codeChallenge;
       if (configData.enablePKCE) {
         codeVerifier = this.cryptoHelper?.getCodeVerifier();
-        codeChallenge = this.cryptoHelper?.getCodeChallenge(codeVerifier);
+        codeChallenge = await this.cryptoHelper?.getCodeChallenge(codeVerifier);
         await this.storageManager.setTemporaryDataParameter(pkceKey, codeVerifier, userId);
       }
       if (authRequestConfig["client_secret"]) {
@@ -1901,7 +1927,9 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async reInitialize(config) {
-    await this.storageManager.setConfigData(config);
+    const currentConfig = this.storageManager.getConfigData();
+    const newConfig = deepMerge_default(currentConfig, config);
+    await this.storageManager.setConfigData(newConfig);
     await this.loadOpenIDProviderConfiguration(true);
   }
   static async clearSession(userId) {
@@ -3267,10 +3295,14 @@ var EmbeddedFlowComponentType2 = /* @__PURE__ */ ((EmbeddedFlowComponentType3) =
   EmbeddedFlowComponentType3["Block"] = "BLOCK";
   EmbeddedFlowComponentType3["Divider"] = "DIVIDER";
   EmbeddedFlowComponentType3["EmailInput"] = "EMAIL_INPUT";
+  EmbeddedFlowComponentType3["Icon"] = "ICON";
+  EmbeddedFlowComponentType3["Image"] = "IMAGE";
   EmbeddedFlowComponentType3["OtpInput"] = "OTP_INPUT";
   EmbeddedFlowComponentType3["PasswordInput"] = "PASSWORD_INPUT";
   EmbeddedFlowComponentType3["PhoneInput"] = "PHONE_INPUT";
+  EmbeddedFlowComponentType3["RichText"] = "RICH_TEXT";
   EmbeddedFlowComponentType3["Select"] = "SELECT";
+  EmbeddedFlowComponentType3["Stack"] = "STACK";
   EmbeddedFlowComponentType3["Text"] = "TEXT";
   EmbeddedFlowComponentType3["TextInput"] = "TEXT_INPUT";
   return EmbeddedFlowComponentType3;
@@ -3327,6 +3359,12 @@ var FlowMode = /* @__PURE__ */ ((FlowMode2) => {
   return FlowMode2;
 })(FlowMode || {});
 
+// src/models/agent.ts
+var AgentConfig;
+((AgentConfig2) => {
+  AgentConfig2.DEFAULT_AUTHENTICATOR_NAME = "Username & Password";
+})(AgentConfig || (AgentConfig = {}));
+
 // src/models/scim2-schema.ts
 var WellKnownSchemaIds = /* @__PURE__ */ ((WellKnownSchemaIds2) => {
   WellKnownSchemaIds2["Core"] = "urn:ietf:params:scim:schemas:core:2.0";
@@ -3353,8 +3391,225 @@ var FieldType = /* @__PURE__ */ ((FieldType2) => {
   return FieldType2;
 })(FieldType || {});
 
+// src/DefaultCacheStore.ts
+var DefaultCacheStore = class {
+  constructor() {
+    __publicField(this, "cache");
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get length() {
+    return this.cache.size;
+  }
+  getItem(key) {
+    return this.cache.get(key) ?? null;
+  }
+  setItem(key, value) {
+    this.cache.set(key, value);
+  }
+  removeItem(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  key(index) {
+    const keys = Array.from(this.cache.keys());
+    return keys[index] ?? null;
+  }
+  async setData(key, value) {
+    this.cache.set(key, value);
+  }
+  async getData(key) {
+    return this.cache.get(key) ?? "{}";
+  }
+  async removeData(key) {
+    this.cache.delete(key);
+  }
+};
+
+// src/DefaultCrypto.ts
+import * as jose from "jose";
+var DefaultCrypto = class {
+  // eslint-disable-next-line class-methods-use-this
+  base64URLDecode(value) {
+    const decodedArray = jose.base64url.decode(value);
+    return new TextDecoder().decode(decodedArray);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  base64URLEncode(value) {
+    return jose.base64url.encode(value);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  generateRandomBytes(length) {
+    return crypto.getRandomValues(new Uint8Array(length));
+  }
+  // eslint-disable-next-line class-methods-use-this
+  async hashSha256(data) {
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(data);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", dataBuffer);
+    return new Uint8Array(hashBuffer);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  async verifyJwt(idToken, jwk, algorithms, clientId, issuer, subject, clockTolerance, validateJwtIssuer = true) {
+    const key = await jose.importJWK(jwk);
+    await jose.jwtVerify(idToken, key, {
+      algorithms,
+      audience: clientId,
+      clockTolerance,
+      issuer: validateJwtIssuer ? issuer : void 0,
+      subject
+    });
+    return true;
+  }
+};
+
 // src/AsgardeoJavaScriptClient.ts
 var AsgardeoJavaScriptClient = class {
+  constructor(config, cacheStore, cryptoUtils) {
+    __publicField(this, "cacheStore");
+    __publicField(this, "cryptoUtils");
+    __publicField(this, "auth");
+    __publicField(this, "storageManager");
+    __publicField(this, "baseURL");
+    this.cacheStore = cacheStore ?? new DefaultCacheStore();
+    this.cryptoUtils = cryptoUtils ?? new DefaultCrypto();
+    this.auth = new AsgardeoAuthClient();
+    if (config) {
+      this.auth.initialize(config, this.cacheStore, this.cryptoUtils);
+      this.storageManager = this.auth.getStorageManager();
+    }
+    this.baseURL = config?.baseUrl ?? "";
+  }
+  /* eslint-disable class-methods-use-this, @typescript-eslint/no-unused-vars */
+  switchOrganization(_organization, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  initialize(_config, _storage) {
+    throw new Error("Method not implemented.");
+  }
+  reInitialize(_config) {
+    throw new Error("Method not implemented.");
+  }
+  getUser(_options) {
+    throw new Error("Method not implemented.");
+  }
+  getAllOrganizations(_options, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  getMyOrganizations(_options, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  getCurrentOrganization(_sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  getUserProfile(_options) {
+    throw new Error("Method not implemented.");
+  }
+  isLoading() {
+    throw new Error("Method not implemented.");
+  }
+  isSignedIn() {
+    throw new Error("Method not implemented.");
+  }
+  updateUserProfile(_payload, _userId) {
+    throw new Error("Method not implemented.");
+  }
+  getConfiguration() {
+    throw new Error("Method not implemented.");
+  }
+  exchangeToken(_config, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  signInSilently(_options) {
+    throw new Error("Method not implemented.");
+  }
+  getAccessToken(_sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  clearSession(_sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  setSession(_sessionData, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  decodeJwtToken(_token) {
+    throw new Error("Method not implemented.");
+  }
+  signIn(_options) {
+    throw new Error("Method not implemented.");
+  }
+  signOut(_options, _sessionIdOrAfterSignOut, _afterSignOut) {
+    throw new Error("Method not implemented.");
+  }
+  signUp(_optionsOrPayload) {
+    throw new Error("Method not implemented.");
+  }
+  /* eslint-enable class-methods-use-this, @typescript-eslint/no-unused-vars */
+  async getAgentToken(agentConfig) {
+    const customParam = {
+      response_mode: "direct"
+    };
+    const authorizeURL = new URL(await this.auth.getSignInUrl(customParam));
+    const authorizeResponse = await initializeEmbeddedSignInFlow_default({
+      payload: Object.fromEntries(authorizeURL.searchParams.entries()),
+      url: `${authorizeURL.origin}${authorizeURL.pathname}`
+    });
+    const authenticatorName = agentConfig.authenticatorName ?? AgentConfig.DEFAULT_AUTHENTICATOR_NAME;
+    const targetAuthenticator = authorizeResponse.nextStep.authenticators.find(
+      (auth) => auth.authenticator === authenticatorName
+    );
+    if (!targetAuthenticator) {
+      throw new Error(`Authenticator '${authenticatorName}' not found among authentication steps.`);
+    }
+    const authnRequest = {
+      baseUrl: this.baseURL,
+      payload: {
+        flowId: authorizeResponse.flowId,
+        selectedAuthenticator: {
+          authenticatorId: targetAuthenticator.authenticatorId,
+          params: {
+            password: agentConfig.agentSecret,
+            username: agentConfig.agentID
+          }
+        }
+      }
+    };
+    const authnResponse = await executeEmbeddedSignInFlow_default(authnRequest);
+    if (authnResponse.flowStatus !== "SUCCESS_COMPLETED" /* SuccessCompleted */) {
+      throw new Error("Agent authentication failed.");
+    }
+    return this.auth.requestAccessToken(
+      authnResponse.authData["code"],
+      authnResponse.authData["session_state"],
+      authnResponse.authData["state"]
+    );
+  }
+  async getOBOSignInURL(agentConfig) {
+    const customParam = {
+      requested_actor: agentConfig.agentID
+    };
+    const authURL = await this.auth.getSignInUrl(customParam);
+    if (authURL) {
+      return authURL.toString();
+    }
+    throw new Error("Could not build Authorize URL");
+  }
+  async getOBOToken(agentConfig, authCodeResponse) {
+    const agentToken = await this.getAgentToken(agentConfig);
+    const tokenRequestConfig = {
+      params: {
+        actor_token: agentToken.accessToken
+      }
+    };
+    return this.auth.requestAccessToken(
+      authCodeResponse.code,
+      authCodeResponse.session_state,
+      authCodeResponse.state,
+      void 0,
+      tokenRequestConfig
+    );
+  }
 };
 var AsgardeoJavaScriptClient_default = AsgardeoJavaScriptClient;
 
@@ -3948,9 +4203,9 @@ var arrayBufferToBase64url = (buffer) => {
 var arrayBufferToBase64url_default = arrayBufferToBase64url;
 
 // src/utils/base64urlToArrayBuffer.ts
-var base64urlToArrayBuffer = (base64url) => {
-  const padding = "=".repeat((4 - base64url.length % 4) % 4);
-  const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/") + padding;
+var base64urlToArrayBuffer = (base64url2) => {
+  const padding = "=".repeat((4 - base64url2.length % 4) % 4);
+  const base64 = base64url2.replace(/-/g, "+").replace(/_/g, "/") + padding;
   const binaryString = atob(base64);
   const bytes = new Uint8Array(binaryString.length);
   for (let i = 0; i < binaryString.length; i += 1) {
@@ -3988,31 +4243,6 @@ var formatDate = (dateString) => {
 };
 var formatDate_default = formatDate;
 
-// src/utils/deepMerge.ts
-var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && Object.prototype.toString.call(value) === "[object Object]";
-var deepMerge = (target, ...sources) => {
-  if (!target || typeof target !== "object") {
-    throw new Error("Target must be an object");
-  }
-  const result = { ...target };
-  sources.forEach((source) => {
-    if (!source || typeof source !== "object") {
-      return;
-    }
-    Object.keys(source).forEach((key) => {
-      const sourceValue = source[key];
-      const targetValue = result[key];
-      if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
-        result[key] = deepMerge(targetValue, sourceValue);
-      } else if (sourceValue !== void 0) {
-        result[key] = sourceValue;
-      }
-    });
-  });
-  return result;
-};
-var deepMerge_default = deepMerge;
-
 // src/utils/logger.ts
 var PREFIX = "\u{1F6E1}\uFE0F Asgardeo";
 var DEFAULT_CONFIG = {
@@ -4644,6 +4874,48 @@ var resolveFieldName = (field) => {
 };
 var resolveFieldName_default = resolveFieldName;
 
+// src/utils/v2/resolveMeta.ts
+function resolveMeta(path, meta) {
+  const value = path.split(".").reduce((current, part) => {
+    if (current == null || typeof current !== "object") {
+      return void 0;
+    }
+    const obj = current;
+    const snakePart = part.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+    return part in obj ? obj[part] : obj[snakePart];
+  }, meta);
+  return value != null ? String(value) : "";
+}
+
+// src/utils/v2/resolveVars.ts
+function resolveVars(text, { t, meta }) {
+  if (!text) {
+    return "";
+  }
+  return text.replace(/\{\{(.+?)\}\}/g, (match, content) => {
+    const trimmed = content.trim();
+    const tMatch = trimmed.match(/^t\((.+)\)$/);
+    if (tMatch) {
+      let key = tMatch[1].trim();
+      if (key.startsWith('"') && key.endsWith('"') || key.startsWith("'") && key.endsWith("'")) {
+        key = key.slice(1, -1);
+      }
+      return t(key.replace(/:/g, "."));
+    }
+    if (meta) {
+      const metaMatch = trimmed.match(/^meta\((.+)\)$/);
+      if (metaMatch) {
+        let path = metaMatch[1].trim();
+        if (path.startsWith('"') && path.endsWith('"') || path.startsWith("'") && path.endsWith("'")) {
+          path = path.slice(1, -1);
+        }
+        return resolveMeta(path, meta);
+      }
+    }
+    return match;
+  });
+}
+
 // src/utils/withVendorCSSClassPrefix.ts
 var withVendorCSSClassPrefix = (className) => `${VendorConstants_default.VENDOR_PREFIX}-${className}`;
 var withVendorCSSClassPrefix_default = withVendorCSSClassPrefix;
@@ -4786,6 +5058,7 @@ var transformBrandingPreferenceToTheme = (brandingPreference, forceTheme) => {
 };
 var transformBrandingPreferenceToTheme_default = transformBrandingPreferenceToTheme;
 export {
+  AgentConfig,
   ApplicationNativeAuthenticationConstants_default as ApplicationNativeAuthenticationConstants,
   AsgardeoAPIError,
   AsgardeoAuthClient,
@@ -4870,6 +5143,8 @@ export {
   removeTrailingSlash_default as removeTrailingSlash,
   resolveFieldName_default as resolveFieldName,
   resolveFieldType_default as resolveFieldType,
+  resolveMeta,
+  resolveVars,
   set_default as set,
   transformBrandingPreferenceToTheme_default as transformBrandingPreferenceToTheme,
   updateMeProfile_default as updateMeProfile,