b5-api-client 0.0.26 → 0.0.28

package/src/auth/FirebaseLoginService.ts

@@ -14,15 +14,41 @@ import {
     isSignInWithEmailLink,
     sendSignInLinkToEmail,
     signInWithEmailLink,
-    Auth
+    Auth,
+    applyActionCode
 } from "firebase/auth";
-import { getMessaging, getToken, onMessage, MessagePayload } from "firebase/messaging";
-import { CreateUserRequest, KioscoinUser } from "../types";
+import { getMessaging, getToken, onMessage } from "firebase/messaging";
+import { CreateUserRequest, KioscoinUser, UpdateUserSettingsRequest } from "../types";
 import P2PMarketplaceAPIClient from "../P2PMarketplaceAPIClient";
+import { AuthTokenProvider } from "./AuthTokenProvider";
 import { FirebaseLoginServiceConfig, LoginService } from "./LoginService";
 import { userContext } from './UserContext';
 
 
+const DEFAULT_EMAIL_VERIFICATION_PAGE =
+    process.env.NEXT_PUBLIC_EMAIL_VERIFICATION_URL ??
+    "http://localhost:3000/auth/email-verified";
+
+const trimTrailingSlash = (value: string): string => value.replace(/\/+$/, "");
+
+const appendQueryParams = (
+    base: string,
+    params: Record<string, string | undefined>
+): string => {
+    const query = Object.entries(params)
+        .filter(([, value]) => value !== undefined && value !== null)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value as string)}`)
+        .join("&");
+
+    if (!query) {
+        return base;
+    }
+
+    const separator = base.includes("?") ? "&" : "?";
+    return `${base}${separator}${query}`;
+};
+
+
 // Auth provider type for better type safety
 export enum AuthProvider {
     EMAIL = 'EMAIL',
@@ -31,24 +57,6 @@ export enum AuthProvider {
     TWITTER = 'TWITTER'
 }
 
-// Immutable auth state class
-export class AuthState {
-    private constructor(
-        public readonly isAuthenticated: boolean,
-        public readonly user: UserData | null,
-        public readonly provider: AuthProvider | null
-    ) { }
-
-    static authenticated(user: UserData, provider: AuthProvider): AuthState {
-        return new AuthState(true, user, provider);
-    }
-
-    static unauthenticated(): AuthState {
-        return new AuthState(false, null, null);
-    }
-}
-
-// Enhanced UserData class with additional safety
 export class UserData {
     private constructor(
         public readonly id: string,
@@ -119,23 +127,44 @@ export interface FirebaseConfig {
     measurementId?: string;
 }
 
-export class FirebaseUnifiedService implements LoginService {
+export class FirebaseService implements LoginService {
     private app: ReturnType<typeof initializeApp> | null = null;
     private messaging: ReturnType<typeof getMessaging> | null = null;
     private auth: Auth | null = null;
     private readonly actionCodeSettings: { url: string; handleCodeInApp: boolean };
+    private readonly emailVerificationUrl: string;
+    private readonly emailVerificationContinueUrl?: string;
     private client: P2PMarketplaceAPIClient;
-
-    constructor(client: P2PMarketplaceAPIClient, config?: FirebaseLoginServiceConfig) {
-        this.client = client;
-        this.actionCodeSettings = config?.actionCodeSettings ?? {
-            url: 'http://localhost:3000/auth/verify-email',
-            handleCodeInApp: true,
+    private readonly initializationPromise: Promise<void>;
+
+    constructor(backendClient: P2PMarketplaceAPIClient, firebaseLoginConfig?: FirebaseLoginServiceConfig) {
+        this.client = backendClient;
+        const fallbackVerificationPage = firebaseLoginConfig?.emailVerificationUrl ?? DEFAULT_EMAIL_VERIFICATION_PAGE;
+        this.emailVerificationUrl = trimTrailingSlash(fallbackVerificationPage);
+        this.emailVerificationContinueUrl = firebaseLoginConfig?.emailVerificationContinueUrl;
+        const configuredActionSettings = firebaseLoginConfig?.actionCodeSettings;
+        const defaultActionUrl =
+            configuredActionSettings?.url ??
+            process.env.REACT_APP_EMAIL_LINK_URL ??
+            process.env.NEXT_PUBLIC_EMAIL_LINK_URL
+
+        this.actionCodeSettings = {
+            url: defaultActionUrl ?? "http://localhost:3000/auth/verify-email",
+            handleCodeInApp: configuredActionSettings?.handleCodeInApp ?? true,
         };
-        this.initializeFirebase();
+
+        // Set the auth token provider first (before initialization)
+        // It will gracefully return null until auth is ready
+        this.client.setAuthTokenProvider(this.buildAuthTokenProvider());
+
+        // Start initialization (this will fetch config, which needs to work without auth)
+        this.initializationPromise = this.initializeFirebase();
     }
 
     private async initializeFirebase() {
+        if (this.app) {
+            return;
+        }
         try {
             const firebaseConfig = await this.fetchFirebaseConfig();
             this.app = initializeApp(firebaseConfig);
@@ -145,6 +174,47 @@ export class FirebaseUnifiedService implements LoginService {
         }
     }
 
+    private async ensureAuthInstance(): Promise<Auth | null> {
+        try {
+            await this.initializationPromise;
+        } catch (_error) {
+            return null;
+        }
+
+        return this.auth;
+    }
+
+    private buildAuthTokenProvider(): AuthTokenProvider {
+        return {
+            getToken: async () => {
+                // Check if auth is available without waiting for initialization
+                // This prevents circular dependency during initial config fetch
+                if (!this.auth) {
+                    return null;
+                }
+                const currentUser = this.auth.currentUser;
+                if (!currentUser) {
+                    return null;
+                }
+                return currentUser.getIdToken();
+            },
+            refreshToken: async () => {
+                // For token refresh, we need to ensure auth is initialized
+                const auth = await this.ensureAuthInstance();
+                const currentUser = auth?.currentUser;
+                if (!currentUser) {
+                    return null;
+                }
+                const refreshedToken = await currentUser.getIdToken(true);
+                userContext.updateUser({ idToken: refreshedToken });
+                return refreshedToken;
+            },
+            onRefreshFailure: (error) => {
+                console.error("Failed to refresh Firebase ID token:", error);
+            }
+        };
+    }
+
     private async fetchFirebaseConfig(): Promise<FirebaseConfig> {
         try {
             const response = await this.client.getConfig<{ firebase: FirebaseConfig }>();
@@ -155,6 +225,63 @@ export class FirebaseUnifiedService implements LoginService {
         }
     }
 
+    private buildEmailVerificationSettings(loginId: string) {
+        return {
+            url: this.buildEmailVerificationUrl(loginId),
+            handleCodeInApp: false,
+        };
+    }
+
+    private buildEmailVerificationUrl(loginId: string): string {
+        return appendQueryParams(this.emailVerificationUrl, {
+            loginId,
+            continueUrl: this.emailVerificationContinueUrl,
+        });
+    }
+
+    private async ensureBackendVerification(
+        firebaseUser: User,
+        backendUser: KioscoinUser,
+        idToken: string
+    ): Promise<KioscoinUser> {
+        const firebaseVerified = firebaseUser.emailVerified;
+        const backendVerified = backendUser.settings?.hasVerified ?? false;
+
+        if (!firebaseVerified || backendVerified) {
+            return backendUser;
+        }
+
+        if (!backendUser.id) {
+            console.warn("Missing backend user id when attempting to mark verification status.");
+            return backendUser;
+        }
+
+        const settingsUpdate: UpdateUserSettingsRequest["settings"] = {
+            paymentMethods: (backendUser.settings?.paymentMethods ?? []).map((method) => ({ ...method })),
+            hasVerified: true,
+        };
+
+        const preferredToken = backendUser.settings?.preferredTokenCode;
+        if (preferredToken !== undefined && preferredToken !== null) {
+            settingsUpdate.preferredTokenCode = preferredToken;
+        }
+
+        const request: UpdateUserSettingsRequest = {
+            userId: backendUser.id,
+            settings: settingsUpdate,
+        };
+
+        try {
+            const response = await this.client.updateUserSettings(request, {
+                Authorization: `Bearer ${idToken}`,
+            });
+            return response.users?.[0] ?? backendUser;
+        } catch (error) {
+            console.error("Failed to update backend verification status:", error);
+            return backendUser;
+        }
+    }
+
     // Messaging methods
     public async requestNotificationPermission(): Promise<string | null> {
         if (!this.app) {
@@ -210,23 +337,35 @@ export class FirebaseUnifiedService implements LoginService {
     // Authentication methods
     async signInWithEmail(email: string, password: string): Promise<AuthResult> {
         try {
-            if (!this.auth) {
+            const auth = await this.ensureAuthInstance();
+            if (!auth) {
                 console.error("Firebase Auth not initialized");
                 return AuthResult.failure("Firebase Auth not initialized");
             }
-            const userCredential = await signInWithEmailAndPassword(this.auth, email, password);
+            const userCredential = await signInWithEmailAndPassword(auth, email, password);
             const idToken = await userCredential.user.getIdToken();
             const backendUser = await this.getUserFromBackend(userCredential.user.uid, idToken);
 
             if (backendUser) {
-                const authResult = this._createSuccessAuthResult(userCredential.user, backendUser, AuthProvider.EMAIL, idToken);
+                const syncedBackendUser = await this.ensureBackendVerification(
+                    userCredential.user,
+                    backendUser,
+                    idToken
+                );
+                const authResult = this._createSuccessAuthResult(
+                    userCredential.user,
+                    syncedBackendUser,
+                    AuthProvider.EMAIL,
+                    idToken
+                );
                 // Update UserContext
                 userContext.setUser({
                     id: userCredential.user.uid,
-                    username: backendUser.username || '',
+                    username: syncedBackendUser.username || '',
                     email: userCredential.user.email || '',
-                    idToken: idToken,
-                    isAdmin: backendUser.admin || false
+                    idToken,
+                    isAdmin: syncedBackendUser.admin || false,
+                    isEmailVerified: userCredential.user.emailVerified
                 });
                 return authResult;
             } else {
@@ -244,16 +383,17 @@ export class FirebaseUnifiedService implements LoginService {
 
     async createUserWithEmail(email: string, password: string, username: string): Promise<AuthResult> {
         try {
-            if (!this.auth) {
+            const auth = await this.ensureAuthInstance();
+            if (!auth) {
                 return AuthResult.failure("Firebase Auth not initialized");
             }
 
             // First create the user in Firebase
-            const userCredential = await createUserWithEmailAndPassword(this.auth, email, password);
+            const userCredential = await createUserWithEmailAndPassword(auth, email, password);
             const user = userCredential.user;
             const idToken = await user.getIdToken();
             // Send email verification
-            await sendEmailVerification(user);
+            await sendEmailVerification(user, this.buildEmailVerificationSettings(user.uid));
 
             const backendUser = await this.createUserInBackend(user.uid, username, idToken);
 
@@ -270,20 +410,22 @@ export class FirebaseUnifiedService implements LoginService {
 
     async signInWithGoogle(): Promise<AuthResult> {
         try {
-            if (!this.auth) {
+            const auth = await this.ensureAuthInstance();
+            if (!auth) {
                 return AuthResult.failure("Firebase Auth not initialized");
             }
 
             const provider = new GoogleAuthProvider();
-            const userCredential = await signInWithPopup(this.auth, provider);
+            const userCredential = await signInWithPopup(auth, provider);
             const user = userCredential.user;
+            const idToken = await user.getIdToken();
 
             // Get or create user in your Kotlin backend
-            const backendUser = await this.getUserFromBackend(user.uid, user.displayName || '');
-            const idToken = await user.getIdToken();
+            const backendUser = await this.getUserFromBackend(user.uid, idToken);
             if (backendUser) {
+                const syncedBackendUser = await this.ensureBackendVerification(user, backendUser, idToken);
                 // Use the new helper method
-                return this._createSuccessAuthResult(user, backendUser, AuthProvider.GOOGLE, idToken);
+                return this._createSuccessAuthResult(user, syncedBackendUser, AuthProvider.GOOGLE, idToken);
             } else {
                 return AuthResult.failure('Failed to get or create user in backend');
             }
@@ -295,20 +437,22 @@ export class FirebaseUnifiedService implements LoginService {
 
     async signInWithFacebook(): Promise<AuthResult> {
         try {
-            if (!this.auth) {
+            const auth = await this.ensureAuthInstance();
+            if (!auth) {
                 return AuthResult.failure("Firebase Auth not initialized");
             }
 
             const provider = new FacebookAuthProvider();
-            const userCredential = await signInWithPopup(this.auth, provider);
+            const userCredential = await signInWithPopup(auth, provider);
             const user = userCredential.user;
+            const idToken = await user.getIdToken();
 
             // Get or create user in your Kotlin backend
-            const backendUser = await this.getUserFromBackend(user.uid, user.displayName || '');
-            const idToken = await user.getIdToken();
+            const backendUser = await this.getUserFromBackend(user.uid, idToken);
             if (backendUser) {
+                const syncedBackendUser = await this.ensureBackendVerification(user, backendUser, idToken);
                 // Use the new helper method
-                return this._createSuccessAuthResult(user, backendUser, AuthProvider.FACEBOOK, idToken);
+                return this._createSuccessAuthResult(user, syncedBackendUser, AuthProvider.FACEBOOK, idToken);
             } else {
                 return AuthResult.failure('Failed to get or create user in backend');
             }
@@ -320,20 +464,22 @@ export class FirebaseUnifiedService implements LoginService {
 
     async signInWithTwitter(): Promise<AuthResult> {
         try {
-            if (!this.auth) {
+            const auth = await this.ensureAuthInstance();
+            if (!auth) {
                 return AuthResult.failure("Firebase Auth not initialized");
             }
 
             const provider = new TwitterAuthProvider();
-            const userCredential = await signInWithPopup(this.auth, provider);
+            const userCredential = await signInWithPopup(auth, provider);
             const user = userCredential.user;
+            const idToken = await user.getIdToken();
 
             // Get or create user in your Kotlin backend
-            const backendUser = await this.getUserFromBackend(user.uid, user.displayName || '');
-            const idToken = await user.getIdToken();
+            const backendUser = await this.getUserFromBackend(user.uid, idToken);
             if (backendUser) {
+                const syncedBackendUser = await this.ensureBackendVerification(user, backendUser, idToken);
                 // Use the new helper method
-                return this._createSuccessAuthResult(user, backendUser, AuthProvider.TWITTER, idToken);
+                return this._createSuccessAuthResult(user, syncedBackendUser, AuthProvider.TWITTER, idToken);
             } else {
                 return AuthResult.failure('Failed to get or create user in backend');
             }
@@ -345,13 +491,14 @@ export class FirebaseUnifiedService implements LoginService {
 
     async sendEmailVerification(): Promise<boolean> {
         try {
-            if (!this.auth) {
+            const auth = await this.ensureAuthInstance();
+            if (!auth) {
                 return false;
             }
 
-            const user = this.auth.currentUser;
+            const user = auth.currentUser;
             if (user) {
-                await sendEmailVerification(user);
+                await sendEmailVerification(user, this.buildEmailVerificationSettings(user.uid));
                 return true;
             }
             return false;
@@ -363,11 +510,12 @@ export class FirebaseUnifiedService implements LoginService {
 
     async sendPasswordResetEmail(email: string): Promise<boolean> {
         try {
-            if (!this.auth) {
+            const auth = await this.ensureAuthInstance();
+            if (!auth) {
                 return false;
             }
 
-            await sendPasswordResetEmail(this.auth, email);
+            await sendPasswordResetEmail(auth, email);
             return true;
         } catch (error) {
             console.error('Error sending password reset email:', error);
@@ -377,11 +525,13 @@ export class FirebaseUnifiedService implements LoginService {
 
     async signOut(): Promise<void> {
         try {
-            if (!this.auth) {
+            const auth = await this.ensureAuthInstance();
+            if (!auth) {
+                userContext.clearUser();
                 return;
             }
 
-            await signOut(this.auth);
+            await signOut(auth);
             // Clear UserContext
             userContext.clearUser();
         } catch (error) {
@@ -398,11 +548,12 @@ export class FirebaseUnifiedService implements LoginService {
 
     async sendSignInLinkToEmail(email: string): Promise<boolean> {
         try {
-            if (!this.auth) {
+            const auth = await this.ensureAuthInstance();
+            if (!auth) {
                 return false;
             }
 
-            await sendSignInLinkToEmail(this.auth, email, this.actionCodeSettings);
+            await sendSignInLinkToEmail(auth, email, this.actionCodeSettings);
             // Save the email locally to use it later when the user clicks the link
             window.localStorage.setItem('emailForSignIn', email);
             return true;
@@ -421,26 +572,29 @@ export class FirebaseUnifiedService implements LoginService {
 
     async signInWithEmailLink(email: string): Promise<AuthResult> {
         try {
-            if (!this.auth) {
+            const auth = await this.ensureAuthInstance();
+            if (!auth) {
                 return AuthResult.failure("Firebase Auth not initialized");
             }
 
-            if (!this.isSignInWithEmailLink()) {
+            if (!isSignInWithEmailLink(auth, window.location.href)) {
                 return AuthResult.failure("Invalid sign-in link");
             }
 
-            const userCredential = await signInWithEmailLink(this.auth, email, window.location.href);
+            const userCredential = await signInWithEmailLink(auth, email, window.location.href);
             const user = userCredential.user;
 
             // Clear the email from localStorage
             window.localStorage.removeItem('emailForSignIn');
 
-            // Get or create user in your Kotlin backend
-            const backendUser = await this.getUserFromBackend(user.uid, user.displayName || '');
             const idToken = await user.getIdToken();
+
+            // Get or create user in your Kotlin backend
+            const backendUser = await this.getUserFromBackend(user.uid, idToken);
             if (backendUser) {
+                const syncedBackendUser = await this.ensureBackendVerification(user, backendUser, idToken);
                 // Use the new helper method
-                return this._createSuccessAuthResult(user, backendUser, AuthProvider.EMAIL, idToken);
+                return this._createSuccessAuthResult(user, syncedBackendUser, AuthProvider.EMAIL, idToken);
             } else {
                 return AuthResult.failure('Failed to get or create user in backend');
             }
@@ -454,6 +608,15 @@ export class FirebaseUnifiedService implements LoginService {
         return window.localStorage.getItem('emailForSignIn');
     }
 
+    async applyEmailVerificationCode(oobCode: string): Promise<void> {
+        const auth = await this.ensureAuthInstance();
+        if (!auth) {
+            throw new Error("Firebase Auth not initialized");
+        }
+
+        await applyActionCode(auth, oobCode);
+    }
+
     // Helper method to create success AuthResult
     private _createSuccessAuthResult(
         user: User,
@@ -473,10 +636,10 @@ export class FirebaseUnifiedService implements LoginService {
     }
 
     // Backend integration methods
-    private async getUserFromBackend(userId: string, loginId: string): Promise<KioscoinUser | null> {
+    private async getUserFromBackend(userId: string, authToken: string): Promise<KioscoinUser | null> {
         try {
             const response = await this.client.getUser(userId, {
-                Authorization: `Bearer ${loginId}`,
+                Authorization: `Bearer ${authToken}`,
             });
             return response.users[0];
         } catch (error) {

package/src/auth/LoginService.ts

@@ -1,5 +1,5 @@
 import P2PMarketplaceAPIClient from "../P2PMarketplaceAPIClient";
-import { AuthResult } from "./FirebaseLoginService";
+import { AuthResult, FirebaseService } from "./FirebaseLoginService";
 
 export type LoginProvider = 'firebase' | 'custom';
 
@@ -21,13 +21,14 @@ export interface FirebaseLoginServiceConfig {
         url: string;
         handleCodeInApp: boolean;
     };
+    emailVerificationUrl?: string;
+    emailVerificationContinueUrl?: string;
 }
 
 export function createLoginService(config: LoginServiceConfig): LoginService {
     const { provider, apiClient } = config;
     if (provider === 'firebase') {
-        const { FirebaseUnifiedService } = require('../FirebaseLoginService');
-        return new FirebaseUnifiedService(apiClient, config.firebase);
+        return new FirebaseService(apiClient, config.firebase);
     }
     throw new Error(`Unsupported login provider: ${provider}`);
 }

package/src/auth/UserContext.ts

@@ -5,6 +5,7 @@ export interface User {
     email: string;
     idToken: string;
     isAdmin: boolean;
+    isEmailVerified: boolean;
 }
 
 // Define the UserContext interface

package/src/index.ts

@@ -1,6 +1,6 @@
 export { default as P2PMarketplaceAPIClient } from './P2PMarketplaceAPIClient';
 export { generateSecretAndHash } from './cryptoUtils'
 export * from './types';
-export { FirebaseUnifiedService } from './auth/FirebaseLoginService';
+export { FirebaseService, AuthProvider, UserData, AuthResult } from './auth/FirebaseLoginService';
 export { createLoginService } from './auth/LoginService';
 export { userContext } from './auth/UserContext';

package/src/types.ts

@@ -1,3 +1,5 @@
+import { AxiosRequestConfig } from "axios";
+
 export type OrderType = 'SELL' | 'BUY';
 
 export type OrderStatus =
@@ -76,8 +78,9 @@ export interface UsersResponse {
 }
 
 export interface UserSettings {
-    preferredTokenCode?: string;
+    preferredTokenCode?: string | null;
     paymentMethods: PaymentMethod[];
+    hasVerified?: boolean;
 }
 
 export interface UpdateUserSettingsRequest {
@@ -85,6 +88,10 @@ export interface UpdateUserSettingsRequest {
     settings: UserSettings;
 }
 
+export interface VerifyEmailRequest {
+    loginId: string;
+}
+
 export interface PaymentMethod {
     type: string;
     alias?: string;