b5-api-client 0.0.24 → 0.0.25

package/dist/auth/FirebaseLoginService.d.ts

@@ -22,8 +22,9 @@ export declare class UserData {
     readonly username: string;
     readonly isEmailVerified: boolean;
     readonly idToken: string | null;
+    readonly isAdmin: boolean;
     private constructor();
-    static create(id: string, email: string, username: string, isEmailVerified: boolean, idToken: string | null): UserData;
+    static create(id: string, email: string, username: string, isEmailVerified: boolean, idToken: string | null, isAdmin: boolean): UserData;
     withEmailVerified(): UserData;
 }
 export declare class AuthResult {
@@ -32,6 +33,7 @@ export declare class AuthResult {
     readonly userData: UserData | null;
     readonly error: string | null;
     readonly provider: AuthProvider | null;
+    readonly isAdmin: boolean;
     private constructor();
     static success(user: KioscoinUser, userData: UserData, provider: AuthProvider): AuthResult;
     static failure(error: string): AuthResult;

package/dist/auth/FirebaseLoginService.js

@@ -39,35 +39,37 @@ class AuthState {
 exports.AuthState = AuthState;
 // Enhanced UserData class with additional safety
 class UserData {
-    constructor(id, email, username, isEmailVerified, idToken) {
+    constructor(id, email, username, isEmailVerified, idToken, isAdmin) {
         this.id = id;
         this.email = email;
         this.username = username;
         this.isEmailVerified = isEmailVerified;
         this.idToken = idToken;
+        this.isAdmin = isAdmin;
     }
-    static create(id, email, username, isEmailVerified, idToken) {
-        return new UserData(id, email, username, isEmailVerified, idToken);
+    static create(id, email, username, isEmailVerified, idToken, isAdmin) {
+        return new UserData(id, email, username, isEmailVerified, idToken, isAdmin);
     }
     withEmailVerified() {
-        return new UserData(this.id, this.email, this.username, true, this.idToken);
+        return new UserData(this.id, this.email, this.username, true, this.idToken, this.isAdmin);
     }
 }
 exports.UserData = UserData;
 // Enhanced AuthResult class
 class AuthResult {
-    constructor(success, user, userData, error, provider) {
+    constructor(success, user, userData, error, provider, isAdmin) {
         this.success = success;
         this.user = user;
         this.userData = userData;
         this.error = error;
         this.provider = provider;
+        this.isAdmin = isAdmin;
     }
     static success(user, userData, provider) {
-        return new AuthResult(true, user, userData, null, provider);
+        return new AuthResult(true, user, userData, null, provider, userData.isAdmin);
     }
     static failure(error) {
-        return new AuthResult(false, null, null, error, null);
+        return new AuthResult(false, null, null, error, null, false);
     }
 }
 exports.AuthResult = AuthResult;
@@ -181,7 +183,8 @@ class FirebaseUnifiedService {
                         id: userCredential.user.uid,
                         username: backendUser.username || '',
                         email: userCredential.user.email || '',
-                        idToken: idToken
+                        idToken: idToken,
+                        isAdmin: backendUser.admin || false
                     });
                     return authResult;
                 }
@@ -416,7 +419,7 @@ class FirebaseUnifiedService {
     }
     // Helper method to create success AuthResult
     _createSuccessAuthResult(user, backendUser, provider, idToken) {
-        const userData = UserData.create(user.uid, user.email || '', backendUser.username || '', user.emailVerified, idToken);
+        const userData = UserData.create(user.uid, user.email || '', backendUser.username || '', user.emailVerified, idToken, backendUser.admin || false);
         return AuthResult.success(backendUser, userData, provider);
     }
     // Backend integration methods

package/dist/auth/UserContext.d.ts

@@ -3,6 +3,7 @@ export interface User {
     username: string;
     email: string;
     idToken: string;
+    isAdmin: boolean;
 }
 export interface UserContext {
     user: User | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "b5-api-client",
-  "version": "0.0.24",
+  "version": "0.0.25",
   "description": "Escrow Backend API client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/auth/FirebaseLoginService.ts

@@ -55,7 +55,8 @@ export class UserData {
         public readonly email: string,
         public readonly username: string,
         public readonly isEmailVerified: boolean,
-        public readonly idToken: string | null
+        public readonly idToken: string | null,
+        public readonly isAdmin: boolean
     ) { }
 
     static create(
@@ -63,14 +64,16 @@ export class UserData {
         email: string,
         username: string,
         isEmailVerified: boolean,
-        idToken: string | null
+        idToken: string | null,
+        isAdmin: boolean
     ): UserData {
         return new UserData(
             id,
             email,
             username,
             isEmailVerified,
-            idToken
+            idToken,
+            isAdmin
         );
     }
 
@@ -80,7 +83,8 @@ export class UserData {
             this.email,
             this.username,
             true,
-            this.idToken
+            this.idToken,
+            this.isAdmin
         );
     }
 }
@@ -92,15 +96,16 @@ export class AuthResult {
         public readonly user: KioscoinUser | null,
         public readonly userData: UserData | null,
         public readonly error: string | null,
-        public readonly provider: AuthProvider | null
+        public readonly provider: AuthProvider | null,
+        public readonly isAdmin: boolean
     ) { }
 
     static success(user: KioscoinUser, userData: UserData, provider: AuthProvider): AuthResult {
-        return new AuthResult(true, user, userData, null, provider);
+        return new AuthResult(true, user, userData, null, provider, userData.isAdmin);
     }
 
     static failure(error: string): AuthResult {
-        return new AuthResult(false, null, null, error, null);
+        return new AuthResult(false, null, null, error, null, false);
     }
 }
 
@@ -220,7 +225,8 @@ export class FirebaseUnifiedService implements LoginService {
                     id: userCredential.user.uid,
                     username: backendUser.username || '',
                     email: userCredential.user.email || '',
-                    idToken: idToken
+                    idToken: idToken,
+                    isAdmin: backendUser.admin || false
                 });
                 return authResult;
             } else {
@@ -460,7 +466,8 @@ export class FirebaseUnifiedService implements LoginService {
             user.email || '',
             backendUser.username || '',
             user.emailVerified,
-            idToken
+            idToken,
+            backendUser.admin || false
         );
         return AuthResult.success(backendUser, userData, provider);
     }

package/src/auth/UserContext.ts

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

package/src/FirebaseLoginService.ts

@@ -1,496 +0,0 @@
-import { initializeApp } from "firebase/app";
-import {
-    getAuth,
-    signInWithEmailAndPassword,
-    createUserWithEmailAndPassword,
-    sendEmailVerification,
-    sendPasswordResetEmail,
-    signOut,
-    User,
-    GoogleAuthProvider,
-    FacebookAuthProvider,
-    TwitterAuthProvider,
-    signInWithPopup,
-    isSignInWithEmailLink,
-    sendSignInLinkToEmail,
-    signInWithEmailLink,
-    Auth
-} from "firebase/auth";
-import { getMessaging, getToken, onMessage, MessagePayload } from "firebase/messaging";
-import { CreateUserRequest, KioscoinUser } from "./types";
-import P2PMarketplaceAPIClient from "./P2PMarketplaceAPIClient";
-import { FirebaseLoginServiceConfig, LoginService } from "./auth/LoginService";
-import { userContext } from './auth/UserContext';
-
-
-// Auth provider type for better type safety
-export enum AuthProvider {
-    EMAIL = 'EMAIL',
-    GOOGLE = 'GOOGLE',
-    FACEBOOK = 'FACEBOOK',
-    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,
-        public readonly email: string,
-        public readonly username: string,
-        public readonly isEmailVerified: boolean,
-        public readonly idToken: string | null
-    ) { }
-
-    static create(
-        id: string,
-        email: string,
-        username: string,
-        isEmailVerified: boolean,
-        idToken: string | null
-    ): UserData {
-        return new UserData(
-            id,
-            email,
-            username,
-            isEmailVerified,
-            idToken
-        );
-    }
-
-    withEmailVerified(): UserData {
-        return new UserData(
-            this.id,
-            this.email,
-            this.username,
-            true,
-            this.idToken
-        );
-    }
-}
-
-// Enhanced AuthResult class
-export class AuthResult {
-    private constructor(
-        public readonly success: boolean,
-        public readonly user: KioscoinUser | null,
-        public readonly userData: UserData | null,
-        public readonly error: string | null,
-        public readonly provider: AuthProvider | null
-    ) { }
-
-    static success(user: KioscoinUser, userData: UserData, provider: AuthProvider): AuthResult {
-        return new AuthResult(true, user, userData, null, provider);
-    }
-
-    static failure(error: string): AuthResult {
-        return new AuthResult(false, null, null, error, null);
-    }
-}
-
-export interface FirebaseConfig {
-    apiKey: string;
-    authDomain: string;
-    projectId: string;
-    storageBucket: string;
-    messagingSenderId: string;
-    appId: string;
-    measurementId?: string;
-}
-
-export class FirebaseUnifiedService 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 client: P2PMarketplaceAPIClient;
-
-    constructor(client: P2PMarketplaceAPIClient, config?: FirebaseLoginServiceConfig) {
-        this.client = client;
-        this.actionCodeSettings = config?.actionCodeSettings ?? {
-            url: 'http://localhost:3000/auth/verify-email',
-            handleCodeInApp: true,
-        };
-        this.initializeFirebase();
-    }
-
-    private async initializeFirebase() {
-        try {
-            const firebaseConfig = await this.fetchFirebaseConfig();
-            this.app = initializeApp(firebaseConfig);
-            this.auth = getAuth(this.app);
-        } catch (error) {
-            console.error("Failed to initialize Firebase app:", error);
-        }
-    }
-
-    private async fetchFirebaseConfig(): Promise<FirebaseConfig> {
-        try {
-            const response = await this.client.getConfig<{ firebase: FirebaseConfig }>();
-            return response.config.firebase;
-        } catch (error) {
-            console.error("Error fetching Firebase configuration:", error);
-            throw new Error("Failed to initialize Firebase configuration");
-        }
-    }
-
-    // Messaging methods
-    public async requestNotificationPermission(): Promise<string | null> {
-        if (!this.app) {
-            await this.initializeFirebase();
-        }
-
-        if (!this.messaging) {
-            console.warn("Messaging is not available");
-            return null;
-        }
-
-        try {
-            const permission = await Notification.requestPermission();
-            if (permission === "granted") {
-                const token = await getToken(this.messaging, {
-                    vapidKey: process.env.REACT_APP_FIREBASE_VAPID_KEY,
-                });
-                return token;
-            }
-            return null;
-        } catch (error) {
-            console.error("Failed to get notification token:", error);
-            return null;
-        }
-    }
-    async fetchToken(): Promise<string | null> {
-        try {
-            if (!this.messaging && this.app) {
-                this.messaging = getMessaging(this.app);
-            }
-            if (this.messaging) {
-                const currentToken = await getToken(this.messaging);
-                return currentToken;
-            }
-            return null;
-        } catch (error) {
-            console.error("An error occurred while retrieving token. ", error);
-            return null;
-        }
-    }
-
-    onMessageListener(callback: (payload: any) => void) {
-        if (!this.messaging && this.app) {
-            this.messaging = getMessaging(this.app);
-        }
-        if (this.messaging) {
-            onMessage(this.messaging, callback);
-        } else {
-            console.error("Messaging is not initialized.");
-        }
-    }
-
-    // Authentication methods
-    async signInWithEmail(email: string, password: string): Promise<AuthResult> {
-        try {
-            if (!this.auth) {
-                console.error("Firebase Auth not initialized");
-                return AuthResult.failure("Firebase Auth not initialized");
-            }
-            const userCredential = await signInWithEmailAndPassword(this.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);
-                // Update UserContext
-                userContext.setUser({
-                    id: userCredential.user.uid,
-                    username: backendUser.username || '',
-                    email: userCredential.user.email || '',
-                    idToken: idToken
-                });
-                return authResult;
-            } else {
-                return AuthResult.failure('User not found in backend');
-            }
-        } catch (error: any) {
-            console.error('Detailed error signing in with email:', {
-                code: error.code,
-                message: error.message,
-                fullError: error
-            });
-            return AuthResult.failure(error.message || 'Authentication failed');
-        }
-    }
-
-    async createUserWithEmail(email: string, password: string, username: string): Promise<AuthResult> {
-        try {
-            if (!this.auth) {
-                return AuthResult.failure("Firebase Auth not initialized");
-            }
-
-            // First create the user in Firebase
-            const userCredential = await createUserWithEmailAndPassword(this.auth, email, password);
-            const user = userCredential.user;
-            const idToken = await user.getIdToken();
-            // Send email verification
-            await sendEmailVerification(user);
-
-            const backendUser = await this.createUserInBackend(user.uid, username, idToken);
-
-            if (backendUser) {
-                return this._createSuccessAuthResult(user, backendUser, AuthProvider.EMAIL, idToken);
-            } else {
-                return AuthResult.failure('Failed to create user in backend');
-            }
-        } catch (error: any) {
-            console.error('Error creating user with email:', error);
-            return AuthResult.failure(error.message || 'User creation failed');
-        }
-    }
-
-    async signInWithGoogle(): Promise<AuthResult> {
-        try {
-            if (!this.auth) {
-                return AuthResult.failure("Firebase Auth not initialized");
-            }
-
-            const provider = new GoogleAuthProvider();
-            const userCredential = await signInWithPopup(this.auth, provider);
-            const user = userCredential.user;
-
-            // Get or create user in your Kotlin backend
-            const backendUser = await this.getUserFromBackend(user.uid, user.displayName || '');
-            const idToken = await user.getIdToken();
-            if (backendUser) {
-                // Use the new helper method
-                return this._createSuccessAuthResult(user, backendUser, AuthProvider.GOOGLE, idToken);
-            } else {
-                return AuthResult.failure('Failed to get or create user in backend');
-            }
-        } catch (error: any) {
-            console.error('Error signing in with Google:', error);
-            return AuthResult.failure(error.message || 'Google authentication failed');
-        }
-    }
-
-    async signInWithFacebook(): Promise<AuthResult> {
-        try {
-            if (!this.auth) {
-                return AuthResult.failure("Firebase Auth not initialized");
-            }
-
-            const provider = new FacebookAuthProvider();
-            const userCredential = await signInWithPopup(this.auth, provider);
-            const user = userCredential.user;
-
-            // Get or create user in your Kotlin backend
-            const backendUser = await this.getUserFromBackend(user.uid, user.displayName || '');
-            const idToken = await user.getIdToken();
-            if (backendUser) {
-                // Use the new helper method
-                return this._createSuccessAuthResult(user, backendUser, AuthProvider.FACEBOOK, idToken);
-            } else {
-                return AuthResult.failure('Failed to get or create user in backend');
-            }
-        } catch (error: any) {
-            console.error('Error signing in with Facebook:', error);
-            return AuthResult.failure(error.message || 'Facebook authentication failed');
-        }
-    }
-
-    async signInWithTwitter(): Promise<AuthResult> {
-        try {
-            if (!this.auth) {
-                return AuthResult.failure("Firebase Auth not initialized");
-            }
-
-            const provider = new TwitterAuthProvider();
-            const userCredential = await signInWithPopup(this.auth, provider);
-            const user = userCredential.user;
-
-            // Get or create user in your Kotlin backend
-            const backendUser = await this.getUserFromBackend(user.uid, user.displayName || '');
-            const idToken = await user.getIdToken();
-            if (backendUser) {
-                // Use the new helper method
-                return this._createSuccessAuthResult(user, backendUser, AuthProvider.TWITTER, idToken);
-            } else {
-                return AuthResult.failure('Failed to get or create user in backend');
-            }
-        } catch (error: any) {
-            console.error('Error signing in with Twitter:', error);
-            return AuthResult.failure(error.message || 'Twitter authentication failed');
-        }
-    }
-
-    async sendEmailVerification(): Promise<boolean> {
-        try {
-            if (!this.auth) {
-                return false;
-            }
-
-            const user = this.auth.currentUser;
-            if (user) {
-                await sendEmailVerification(user);
-                return true;
-            }
-            return false;
-        } catch (error) {
-            console.error('Error sending email verification:', error);
-            return false;
-        }
-    }
-
-    async sendPasswordResetEmail(email: string): Promise<boolean> {
-        try {
-            if (!this.auth) {
-                return false;
-            }
-
-            await sendPasswordResetEmail(this.auth, email);
-            return true;
-        } catch (error) {
-            console.error('Error sending password reset email:', error);
-            return false;
-        }
-    }
-
-    async signOut(): Promise<void> {
-        try {
-            if (!this.auth) {
-                return;
-            }
-
-            await signOut(this.auth);
-            // Clear UserContext
-            userContext.clearUser();
-        } catch (error) {
-            console.error('Error signing out:', error);
-        }
-    }
-
-    getCurrentUser(): User | null {
-        if (!this.auth) {
-            return null;
-        }
-        return this.auth.currentUser;
-    }
-
-    async sendSignInLinkToEmail(email: string): Promise<boolean> {
-        try {
-            if (!this.auth) {
-                return false;
-            }
-
-            await sendSignInLinkToEmail(this.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;
-        } catch (error: any) {
-            console.error('Error sending sign-in link to email:', error);
-            return false;
-        }
-    }
-
-    isSignInWithEmailLink(): boolean {
-        if (!this.auth) {
-            return false;
-        }
-        return isSignInWithEmailLink(this.auth, window.location.href);
-    }
-
-    async signInWithEmailLink(email: string): Promise<AuthResult> {
-        try {
-            if (!this.auth) {
-                return AuthResult.failure("Firebase Auth not initialized");
-            }
-
-            if (!this.isSignInWithEmailLink()) {
-                return AuthResult.failure("Invalid sign-in link");
-            }
-
-            const userCredential = await signInWithEmailLink(this.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();
-            if (backendUser) {
-                // Use the new helper method
-                return this._createSuccessAuthResult(user, backendUser, AuthProvider.EMAIL, idToken);
-            } else {
-                return AuthResult.failure('Failed to get or create user in backend');
-            }
-        } catch (error: any) {
-            console.error('Error signing in with email link:', error);
-            return AuthResult.failure(error.message || 'Email link authentication failed');
-        }
-    }
-
-    getEmailForSignIn(): string | null {
-        return window.localStorage.getItem('emailForSignIn');
-    }
-
-    // Helper method to create success AuthResult
-    private _createSuccessAuthResult(
-        user: User,
-        backendUser: KioscoinUser,
-        provider: AuthProvider,
-        idToken: string
-    ): AuthResult {
-        const userData = UserData.create(
-            user.uid,
-            user.email || '',
-            backendUser.username || '',
-            user.emailVerified,
-            idToken
-        );
-        return AuthResult.success(backendUser, userData, provider);
-    }
-
-    // Backend integration methods
-    private async getUserFromBackend(userId: string, loginId: string): Promise<KioscoinUser | null> {
-        try {
-            const response = await this.client.getUser(userId, {
-                Authorization: `Bearer ${loginId}`,
-            });
-            return response.users[0];
-        } catch (error) {
-            console.error('Error getting user from backend:', error);
-            return null;
-        }
-    }
-
-    private async createUserInBackend(userId: string, username: string, idToken: string): Promise<KioscoinUser | null> {
-        try {
-            const createUserRequest: CreateUserRequest = {
-                id: userId,
-                username: username
-            }
-            const response = await this.client.createUser(createUserRequest, {
-                Authorization: `Bearer ${idToken}`
-            });
-            return response.users[0];
-        } catch (error) {
-            console.error('Error creating user in backend:', error);
-            return null;
-        }
-    }
-}