address review comments

Author: lashinijay

packages/javascript/package.json

@@ -55,7 +55,6 @@
   "dependencies": {
     "@asgardeo/i18n": "workspace:*",
     "tslib": "2.8.1",
-    "base64url": "^3.0.1",
     "jose": "^5.2.0"
   },
   "publishConfig": {

packages/javascript/src/AsgardeoJavaScriptClient.ts

@@ -16,237 +16,233 @@
  * under the License.
  */
 
-import {EmbeddedSignInFlowInitiateResponse} from "./models/embedded-signin-flow";
+import {AsgardeoAuthClient} from './__legacy__/client';
 import {AuthClientConfig} from './__legacy__/models/client-config';
-import {EmbeddedFlowExecuteRequestConfig} from "./models/embedded-flow";
-import {EmbeddedSignInFlowHandleResponse} from "./models/embedded-signin-flow";
-import {EmbeddedSignInFlowStatus} from "./models/embedded-signin-flow";
-import {Crypto} from "./models/crypto";
-import {AsgardeoAuthClient} from "./__legacy__/client";
-import StorageManager from "./StorageManager";
-import executeEmbeddedSignInFlow from "./api/executeEmbeddedSignInFlow";
+import executeEmbeddedSignInFlow from './api/executeEmbeddedSignInFlow';
+import initializeEmbeddedSignInFlow from './api/initializeEmbeddedSignInFlow';
+import {DefaultCacheStore} from './DefaultCacheStore';
+import {DefaultCrypto} from './DefaultCrypto';
+import {AgentConfig} from './models/agent';
+import {AuthCodeResponse} from './models/auth-code-response';
 import {AsgardeoClient} from './models/client';
 import {Config, SignInOptions, SignOutOptions, SignUpOptions} from './models/config';
-import {EmbeddedFlowExecuteRequestPayload, EmbeddedFlowExecuteResponse} from './models/embedded-flow';
+import {Crypto} from './models/crypto';
+import {
+  EmbeddedFlowExecuteRequestConfig,
+  EmbeddedFlowExecuteRequestPayload,
+  EmbeddedFlowExecuteResponse,
+} from './models/embedded-flow';
+import {
+  EmbeddedSignInFlowAuthenticator,
+  EmbeddedSignInFlowHandleResponse,
+  EmbeddedSignInFlowInitiateResponse,
+  EmbeddedSignInFlowStatus,
+} from './models/embedded-signin-flow';
 import {AllOrganizationsApiResponse, Organization} from './models/organization';
 import {Storage} from './models/store';
 import {TokenExchangeRequestConfig, TokenResponse} from './models/token';
 import {User, UserProfile} from './models/user';
-import initializeEmbeddedSignInFlow from './api/initializeEmbeddedSignInFlow';
-import {DefaultCacheStore} from './DefaultCacheStore';
-import {DefaultCrypto} from './DefaultCrypto';
-
-interface AgentConfig {
-  agentID: string;
-  agentSecret: string;
-}
+import StorageManager from './StorageManager';
 
-export interface AuthCodeResponse {
-  code: string;
-  state: string;
-  session_state: string;
-}
-
-/**
- * Base class for implementing Asgardeo clients.
- * This class provides the core functionality for managing user authentication and sessions.
- *
- * @typeParam T - Configuration type that extends Config.
- */
 class AsgardeoJavaScriptClient<T = Config> implements AsgardeoClient<T> {
-
   private cacheStore: Storage;
+
   private cryptoUtils: Crypto;
+
   private auth: AsgardeoAuthClient<T>;
+
   private storageManager: StorageManager<T>;
+
   private baseURL: string;
-  void: void;
-  
+
   constructor(config?: AuthClientConfig<T>, cacheStore?: Storage, cryptoUtils?: Crypto) {
     this.cacheStore = cacheStore ?? new DefaultCacheStore();
-    this.cryptoUtils =  cryptoUtils ?? new DefaultCrypto();
+    this.cryptoUtils = cryptoUtils ?? new DefaultCrypto();
     this.auth = new AsgardeoAuthClient();
-    this.auth.initialize(config, this.cacheStore, this.cryptoUtils);
-    this.storageManager = this.auth.getStorageManager();
 
-    this.baseURL = config.baseUrl ?? "";
+    if (config) {
+      this.auth.initialize(config, this.cacheStore, this.cryptoUtils);
+      this.storageManager = this.auth.getStorageManager();
+    }
+
+    this.baseURL = config?.baseUrl ?? '';
   }
 
-  switchOrganization(organization: Organization, sessionId?: string): Promise<TokenResponse | Response> {
-    throw new Error("Method not implemented.");
+  /* eslint-disable class-methods-use-this, @typescript-eslint/no-unused-vars */
+  switchOrganization(_organization: Organization, _sessionId?: string): Promise<TokenResponse | Response> {
+    throw new Error('Method not implemented.');
   }
 
-  initialize(config: T, storage?: Storage): Promise<boolean> {
-    throw new Error("Method not implemented.");
+  initialize(_config: T, _storage?: Storage): Promise<boolean> {
+    throw new Error('Method not implemented.');
   }
 
-  reInitialize(config: Partial<T>): Promise<boolean> {
-    throw new Error("Method not implemented.");
+  reInitialize(_config: Partial<T>): Promise<boolean> {
+    throw new Error('Method not implemented.');
   }
 
-  getUser(options?: any): Promise<User> {
-    throw new Error("Method not implemented.");
+  getUser(_options?: any): Promise<User> {
+    throw new Error('Method not implemented.');
   }
 
-  getAllOrganizations(options?: any, sessionId?: string): Promise<AllOrganizationsApiResponse> {
-    throw new Error("Method not implemented.");
+  getAllOrganizations(_options?: any, _sessionId?: string): Promise<AllOrganizationsApiResponse> {
+    throw new Error('Method not implemented.');
   }
 
-  getMyOrganizations(options?: any, sessionId?: string): Promise<Organization[]> {
-    throw new Error("Method not implemented.");
+  getMyOrganizations(_options?: any, _sessionId?: string): Promise<Organization[]> {
+    throw new Error('Method not implemented.');
   }
 
-  getCurrentOrganization(sessionId?: string): Promise<Organization | null> {
-    throw new Error("Method not implemented.");
+  getCurrentOrganization(_sessionId?: string): Promise<Organization | null> {
+    throw new Error('Method not implemented.');
   }
 
-  getUserProfile(options?: any): Promise<UserProfile> {
-    throw new Error("Method not implemented.");
+  getUserProfile(_options?: any): Promise<UserProfile> {
+    throw new Error('Method not implemented.');
   }
 
   isLoading(): boolean {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
 
   isSignedIn(): Promise<boolean> {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
 
-  updateUserProfile(payload: any, userId?: string): Promise<User> {
-    throw new Error("Method not implemented.");
+  updateUserProfile(_payload: any, _userId?: string): Promise<User> {
+    throw new Error('Method not implemented.');
   }
 
   getConfiguration(): T {
-    throw new Error("Method not implemented.");
+    throw new Error('Method not implemented.');
   }
 
-  exchangeToken(config: TokenExchangeRequestConfig, sessionId?: string): Promise<TokenResponse | Response> {
-    throw new Error("Method not implemented.");
+  exchangeToken(_config: TokenExchangeRequestConfig, _sessionId?: string): Promise<TokenResponse | Response> {
+    throw new Error('Method not implemented.');
   }
 
-  signInSilently(options?: SignInOptions): Promise<User | boolean> {
-    throw new Error("Method not implemented.");
+  signInSilently(_options?: SignInOptions): Promise<User | boolean> {
+    throw new Error('Method not implemented.');
   }
 
-  getAccessToken(sessionId?: string): Promise<string> {
-    throw new Error("Method not implemented.");
+  getAccessToken(_sessionId?: string): Promise<string> {
+    throw new Error('Method not implemented.');
   }
 
-  clearSession(sessionId?: string): void {
-    throw new Error("Method not implemented.");
+  clearSession(_sessionId?: string): void {
+    throw new Error('Method not implemented.');
   }
 
-  setSession(sessionData: Record<string, unknown>, sessionId?: string): Promise<void> {
-    throw new Error("Method not implemented.");
+  setSession(_sessionData: Record<string, unknown>, _sessionId?: string): Promise<void> {
+    throw new Error('Method not implemented.');
   }
 
-  decodeJwtToken<R = Record<string, unknown>>(token: string): Promise<R> {
-    throw new Error("Method not implemented.");
+  decodeJwtToken<R = Record<string, unknown>>(_token: string): Promise<R> {
+    throw new Error('Method not implemented.');
   }
 
-  signIn(options?: SignInOptions): Promise<User> {
-    throw new Error("Method not implemented.");
+  signIn(_options?: SignInOptions): Promise<User> {
+    throw new Error('Method not implemented.');
   }
 
-  signOut(options?: SignOutOptions, sessionIdOrAfterSignOut?: string | ((afterSignOutUrl: string) => void), afterSignOut?: (afterSignOutUrl: string) => void): Promise<string> {
-    throw new Error("Method not implemented.");
+  signOut(
+    _options?: SignOutOptions,
+    _sessionIdOrAfterSignOut?: string | ((afterSignOutUrl: string) => void),
+    _afterSignOut?: (afterSignOutUrl: string) => void,
+  ): Promise<string> {
+    throw new Error('Method not implemented.');
   }
 
   signUp(options?: SignUpOptions): Promise<void>;
 
   signUp(payload: EmbeddedFlowExecuteRequestPayload): Promise<EmbeddedFlowExecuteResponse>;
 
-  signUp(optionsOrPayload?: SignUpOptions | EmbeddedFlowExecuteRequestPayload): Promise<void | EmbeddedFlowExecuteResponse> {
-    throw new Error("Method not implemented.");
+  signUp(
+    _optionsOrPayload?: SignUpOptions | EmbeddedFlowExecuteRequestPayload,
+  ): Promise<void | EmbeddedFlowExecuteResponse> {
+    throw new Error('Method not implemented.');
   }
+  /* eslint-enable class-methods-use-this, @typescript-eslint/no-unused-vars */
 
-  // Get Agent Token. (AI agent acting on its own)
   public async getAgentToken(agentConfig: AgentConfig): Promise<TokenResponse> {
-    const customParam = {
-      response_mode: "direct",
+    const customParam: Record<string, string> = {
+      response_mode: 'direct',
     };
 
     const authorizeURL: URL = new URL(await this.auth.getSignInUrl(customParam));
 
     const authorizeResponse: EmbeddedSignInFlowInitiateResponse = await initializeEmbeddedSignInFlow({
-      url: `${authorizeURL.origin}${authorizeURL.pathname}`,
       payload: Object.fromEntries(authorizeURL.searchParams.entries()),
+      url: `${authorizeURL.origin}${authorizeURL.pathname}`,
     });
 
-    const usernamePasswordAuthenticator = authorizeResponse.nextStep.authenticators.find(
-      (auth) => auth.authenticator === "Username & Password",
-    );
+    const authenticatorName: string = agentConfig.authenticatorName ?? AgentConfig.DEFAULT_AUTHENTICATOR_NAME;
 
-    if (!usernamePasswordAuthenticator) {
-      console.error("Basic authenticator not found among authentication steps.");
-      return Promise.reject(new Error("Basic authenticator not found among authentication steps."));
+    const targetAuthenticator: EmbeddedSignInFlowAuthenticator | undefined =
+      authorizeResponse.nextStep.authenticators.find(
+        (auth: EmbeddedSignInFlowAuthenticator) => auth.authenticator === authenticatorName,
+      );
+
+    if (!targetAuthenticator) {
+      throw new Error(`Authenticator '${authenticatorName}' not found among authentication steps.`);
     }
 
     const authnRequest: EmbeddedFlowExecuteRequestConfig = {
       baseUrl: this.baseURL,
       payload: {
         flowId: authorizeResponse.flowId,
         selectedAuthenticator: {
-          authenticatorId: usernamePasswordAuthenticator.authenticatorId,
+          authenticatorId: targetAuthenticator.authenticatorId,
           params: {
-            username: agentConfig.agentID,
             password: agentConfig.agentSecret,
+            username: agentConfig.agentID,
           },
         },
       },
     };
 
     const authnResponse: EmbeddedSignInFlowHandleResponse = await executeEmbeddedSignInFlow(authnRequest);
 
-    if (authnResponse.flowStatus != EmbeddedSignInFlowStatus.SuccessCompleted) {
-      console.error("Agent Authentication Failed.");
-      return Promise.reject(new Error("Agent Authentication Failed."));
+    if (authnResponse.flowStatus !== EmbeddedSignInFlowStatus.SuccessCompleted) {
+      throw new Error('Agent authentication failed.');
     }
 
-    const tokenResponse = await this.auth.requestAccessToken(
+    return this.auth.requestAccessToken(
       authnResponse.authData['code'],
       authnResponse.authData['session_state'],
       authnResponse.authData['state'],
     );
-
-    return tokenResponse;
   }
 
-  // Build Authorize request for the OBO Flow
   public async getOBOSignInURL(agentConfig: AgentConfig): Promise<string> {
-    // The authorize request must include requested_actor parameter from the agent configs
-    const customParam = {
+    const customParam: Record<string, string> = {
       requested_actor: agentConfig.agentID,
     };
 
-    // Build authorize URL using AsgardeoAuthClient
     const authURL: string | undefined = await this.auth.getSignInUrl(customParam);
 
     if (authURL) {
-      return Promise.resolve(authURL.toString());
+      return authURL.toString();
     }
-    return Promise.reject(new Error("Could not build Authorize URL"));
+
+    throw new Error('Could not build Authorize URL');
   }
 
-  // Get OBO Token. (AI agent acting on behalf of a user)
   public async getOBOToken(agentConfig: AgentConfig, authCodeResponse: AuthCodeResponse): Promise<TokenResponse> {
-    // Get Agent Token
-    const agentToken = await this.getAgentToken(agentConfig);
+    const agentToken: TokenResponse = await this.getAgentToken(agentConfig);
 
-    // Pass Agent Token when requesting access token
-    const tokenRequestConfig = {
+    const tokenRequestConfig: {params: {actor_token: string}} = {
       params: {
         actor_token: agentToken.accessToken,
       },
     };
 
-    // Return OBO Token
-    return await this.auth.requestAccessToken(
+    return this.auth.requestAccessToken(
       authCodeResponse.code,
       authCodeResponse.session_state,
       authCodeResponse.state,
       undefined,
-      tokenRequestConfig
+      tokenRequestConfig,
     );
   }
 }