b5-api-client 0.0.25 → 0.0.27

package/src/auth/FirebaseLoginService.ts

@@ -14,15 +14,40 @@ import {
     isSignInWithEmailLink,
     sendSignInLinkToEmail,
     signInWithEmailLink,
-    Auth
+    Auth,
+    applyActionCode
 } from "firebase/auth";
-import { getMessaging, getToken, onMessage, MessagePayload } from "firebase/messaging";
-import { CreateUserRequest, KioscoinUser } from "../types";
-import P2PMarketplaceAPIClient from "../P2PMarketplaceAPIClient";
+import { getMessaging, getToken, onMessage } from "firebase/messaging";
+import { CreateUserRequest, KioscoinUser, UpdateUserSettingsRequest } from "../types";
+import P2PMarketplaceAPIClient, { AuthTokenProvider } from "../P2PMarketplaceAPIClient";
 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',
@@ -124,18 +149,35 @@ export class FirebaseUnifiedService implements LoginService {
     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;
+    private readonly initializationPromise: Promise<void>;
 
     constructor(client: P2PMarketplaceAPIClient, config?: FirebaseLoginServiceConfig) {
         this.client = client;
-        this.actionCodeSettings = config?.actionCodeSettings ?? {
-            url: 'http://localhost:3000/auth/verify-email',
-            handleCodeInApp: true,
+        const fallbackVerificationPage = config?.emailVerificationUrl ?? DEFAULT_EMAIL_VERIFICATION_PAGE;
+        this.emailVerificationUrl = trimTrailingSlash(fallbackVerificationPage);
+        this.emailVerificationContinueUrl = config?.emailVerificationContinueUrl;
+        const configuredActionSettings = config?.actionCodeSettings;
+        const defaultActionUrl =
+            configuredActionSettings?.url ??
+            process.env.REACT_APP_EMAIL_LINK_URL ??
+            process.env.NEXT_PUBLIC_EMAIL_LINK_URL ??
+            "http://localhost:3000/auth/verify-email";
+
+        this.actionCodeSettings = {
+            url: defaultActionUrl,
+            handleCodeInApp: configuredActionSettings?.handleCodeInApp ?? true,
         };
-        this.initializeFirebase();
+        this.initializationPromise = this.initializeFirebase();
+        this.client.setAuthTokenProvider(this.buildAuthTokenProvider());
     }
 
     private async initializeFirebase() {
+        if (this.app) {
+            return;
+        }
         try {
             const firebaseConfig = await this.fetchFirebaseConfig();
             this.app = initializeApp(firebaseConfig);
@@ -145,6 +187,42 @@ 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 () => {
+                const auth = await this.ensureAuthInstance();
+                const currentUser = auth?.currentUser;
+                if (!currentUser) {
+                    return null;
+                }
+                return currentUser.getIdToken();
+            },
+            refreshToken: async () => {
+                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 +233,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 +345,34 @@ 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
                 });
                 return authResult;
             } else {
@@ -244,16 +390,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 +417,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 +444,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 +471,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 +498,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 +517,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 +532,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 +555,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 +579,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 +615,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 +643,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

@@ -21,6 +21,8 @@ export interface FirebaseLoginServiceConfig {
         url: string;
         handleCodeInApp: boolean;
     };
+    emailVerificationUrl?: string;
+    emailVerificationContinueUrl?: string;
 }
 
 export function createLoginService(config: LoginServiceConfig): LoginService {

package/src/types.ts

@@ -76,8 +76,9 @@ export interface UsersResponse {
 }
 
 export interface UserSettings {
-    preferredTokenCode?: string;
+    preferredTokenCode?: string | null;
     paymentMethods: PaymentMethod[];
+    hasVerified?: boolean;
 }
 
 export interface UpdateUserSettingsRequest {
@@ -85,6 +86,10 @@ export interface UpdateUserSettingsRequest {
     settings: UserSettings;
 }
 
+export interface VerifyEmailRequest {
+    loginId: string;
+}
+
 export interface PaymentMethod {
     type: string;
     alias?: string;
@@ -406,3 +411,53 @@ export interface KioscoinOperationResponse {
     error?: OperationError;
     order?: Order;
 }
+
+export type MessageContentType = 'TEXT' | 'ACTION' | 'EVENT' | 'NOTIFICATION';
+
+export interface MessageContentBase {
+    type: MessageContentType;
+}
+
+export interface MessageContentText extends MessageContentBase {
+    type: 'TEXT';
+    text: string;
+}
+
+export interface MessageContentAction extends MessageContentBase {
+    type: 'ACTION';
+    content: string;
+}
+
+export interface MessageContentEvent extends MessageContentBase {
+    type: 'EVENT';
+    event: OrderEvent;
+}
+
+export interface MessageContentNotification extends MessageContentBase {
+    type: 'NOTIFICATION';
+    notification: NotificationDto;
+}
+
+export type MessageContent =
+    | MessageContentText
+    | MessageContentAction
+    | MessageContentEvent
+    | MessageContentNotification;
+
+export interface Message {
+    sender: string;
+    timestamp: number;
+    content: MessageContent;
+}
+
+export interface NotificationDto {
+    id: string;
+    userId: string;
+    message: Message;
+    createdAt: string;
+    readAt?: string | null;
+}
+
+export interface NotificationsResponse {
+    notifications: NotificationDto[];
+}