b5-api-client 0.0.22 → 0.0.24

package/dist/auth/FirebaseLoginService.d.ts

@@ -0,0 +1,76 @@
+import { User } from "firebase/auth";
+import { KioscoinUser } from "../types";
+import P2PMarketplaceAPIClient from "../P2PMarketplaceAPIClient";
+import { FirebaseLoginServiceConfig, LoginService } from "./LoginService";
+export declare enum AuthProvider {
+    EMAIL = "EMAIL",
+    GOOGLE = "GOOGLE",
+    FACEBOOK = "FACEBOOK",
+    TWITTER = "TWITTER"
+}
+export declare class AuthState {
+    readonly isAuthenticated: boolean;
+    readonly user: UserData | null;
+    readonly provider: AuthProvider | null;
+    private constructor();
+    static authenticated(user: UserData, provider: AuthProvider): AuthState;
+    static unauthenticated(): AuthState;
+}
+export declare class UserData {
+    readonly id: string;
+    readonly email: string;
+    readonly username: string;
+    readonly isEmailVerified: boolean;
+    readonly idToken: string | null;
+    private constructor();
+    static create(id: string, email: string, username: string, isEmailVerified: boolean, idToken: string | null): UserData;
+    withEmailVerified(): UserData;
+}
+export declare class AuthResult {
+    readonly success: boolean;
+    readonly user: KioscoinUser | null;
+    readonly userData: UserData | null;
+    readonly error: string | null;
+    readonly provider: AuthProvider | null;
+    private constructor();
+    static success(user: KioscoinUser, userData: UserData, provider: AuthProvider): AuthResult;
+    static failure(error: string): AuthResult;
+}
+export interface FirebaseConfig {
+    apiKey: string;
+    authDomain: string;
+    projectId: string;
+    storageBucket: string;
+    messagingSenderId: string;
+    appId: string;
+    measurementId?: string;
+}
+export declare class FirebaseUnifiedService implements LoginService {
+    private app;
+    private messaging;
+    private auth;
+    private readonly actionCodeSettings;
+    private client;
+    constructor(client: P2PMarketplaceAPIClient, config?: FirebaseLoginServiceConfig);
+    private initializeFirebase;
+    private fetchFirebaseConfig;
+    requestNotificationPermission(): Promise<string | null>;
+    fetchToken(): Promise<string | null>;
+    onMessageListener(callback: (payload: any) => void): void;
+    signInWithEmail(email: string, password: string): Promise<AuthResult>;
+    createUserWithEmail(email: string, password: string, username: string): Promise<AuthResult>;
+    signInWithGoogle(): Promise<AuthResult>;
+    signInWithFacebook(): Promise<AuthResult>;
+    signInWithTwitter(): Promise<AuthResult>;
+    sendEmailVerification(): Promise<boolean>;
+    sendPasswordResetEmail(email: string): Promise<boolean>;
+    signOut(): Promise<void>;
+    getCurrentUser(): User | null;
+    sendSignInLinkToEmail(email: string): Promise<boolean>;
+    isSignInWithEmailLink(): boolean;
+    signInWithEmailLink(email: string): Promise<AuthResult>;
+    getEmailForSignIn(): string | null;
+    private _createSuccessAuthResult;
+    private getUserFromBackend;
+    private createUserInBackend;
+}

package/dist/auth/FirebaseLoginService.js

@@ -0,0 +1,456 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseUnifiedService = exports.AuthResult = exports.UserData = exports.AuthState = exports.AuthProvider = void 0;
+const app_1 = require("firebase/app");
+const auth_1 = require("firebase/auth");
+const messaging_1 = require("firebase/messaging");
+const UserContext_1 = require("./UserContext");
+// Auth provider type for better type safety
+var AuthProvider;
+(function (AuthProvider) {
+    AuthProvider["EMAIL"] = "EMAIL";
+    AuthProvider["GOOGLE"] = "GOOGLE";
+    AuthProvider["FACEBOOK"] = "FACEBOOK";
+    AuthProvider["TWITTER"] = "TWITTER";
+})(AuthProvider = exports.AuthProvider || (exports.AuthProvider = {}));
+// Immutable auth state class
+class AuthState {
+    constructor(isAuthenticated, user, provider) {
+        this.isAuthenticated = isAuthenticated;
+        this.user = user;
+        this.provider = provider;
+    }
+    static authenticated(user, provider) {
+        return new AuthState(true, user, provider);
+    }
+    static unauthenticated() {
+        return new AuthState(false, null, null);
+    }
+}
+exports.AuthState = AuthState;
+// Enhanced UserData class with additional safety
+class UserData {
+    constructor(id, email, username, isEmailVerified, idToken) {
+        this.id = id;
+        this.email = email;
+        this.username = username;
+        this.isEmailVerified = isEmailVerified;
+        this.idToken = idToken;
+    }
+    static create(id, email, username, isEmailVerified, idToken) {
+        return new UserData(id, email, username, isEmailVerified, idToken);
+    }
+    withEmailVerified() {
+        return new UserData(this.id, this.email, this.username, true, this.idToken);
+    }
+}
+exports.UserData = UserData;
+// Enhanced AuthResult class
+class AuthResult {
+    constructor(success, user, userData, error, provider) {
+        this.success = success;
+        this.user = user;
+        this.userData = userData;
+        this.error = error;
+        this.provider = provider;
+    }
+    static success(user, userData, provider) {
+        return new AuthResult(true, user, userData, null, provider);
+    }
+    static failure(error) {
+        return new AuthResult(false, null, null, error, null);
+    }
+}
+exports.AuthResult = AuthResult;
+class FirebaseUnifiedService {
+    constructor(client, config) {
+        var _a;
+        this.app = null;
+        this.messaging = null;
+        this.auth = null;
+        this.client = client;
+        this.actionCodeSettings = (_a = config === null || config === void 0 ? void 0 : config.actionCodeSettings) !== null && _a !== void 0 ? _a : {
+            url: 'http://localhost:3000/auth/verify-email',
+            handleCodeInApp: true,
+        };
+        this.initializeFirebase();
+    }
+    initializeFirebase() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const firebaseConfig = yield this.fetchFirebaseConfig();
+                this.app = (0, app_1.initializeApp)(firebaseConfig);
+                this.auth = (0, auth_1.getAuth)(this.app);
+            }
+            catch (error) {
+                console.error("Failed to initialize Firebase app:", error);
+            }
+        });
+    }
+    fetchFirebaseConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.client.getConfig();
+                return response.config.firebase;
+            }
+            catch (error) {
+                console.error("Error fetching Firebase configuration:", error);
+                throw new Error("Failed to initialize Firebase configuration");
+            }
+        });
+    }
+    // Messaging methods
+    requestNotificationPermission() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.app) {
+                yield this.initializeFirebase();
+            }
+            if (!this.messaging) {
+                console.warn("Messaging is not available");
+                return null;
+            }
+            try {
+                const permission = yield Notification.requestPermission();
+                if (permission === "granted") {
+                    const token = yield (0, messaging_1.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;
+            }
+        });
+    }
+    fetchToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.messaging && this.app) {
+                    this.messaging = (0, messaging_1.getMessaging)(this.app);
+                }
+                if (this.messaging) {
+                    const currentToken = yield (0, messaging_1.getToken)(this.messaging);
+                    return currentToken;
+                }
+                return null;
+            }
+            catch (error) {
+                console.error("An error occurred while retrieving token. ", error);
+                return null;
+            }
+        });
+    }
+    onMessageListener(callback) {
+        if (!this.messaging && this.app) {
+            this.messaging = (0, messaging_1.getMessaging)(this.app);
+        }
+        if (this.messaging) {
+            (0, messaging_1.onMessage)(this.messaging, callback);
+        }
+        else {
+            console.error("Messaging is not initialized.");
+        }
+    }
+    // Authentication methods
+    signInWithEmail(email, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.auth) {
+                    console.error("Firebase Auth not initialized");
+                    return AuthResult.failure("Firebase Auth not initialized");
+                }
+                const userCredential = yield (0, auth_1.signInWithEmailAndPassword)(this.auth, email, password);
+                const idToken = yield userCredential.user.getIdToken();
+                const backendUser = yield this.getUserFromBackend(userCredential.user.uid, idToken);
+                if (backendUser) {
+                    const authResult = this._createSuccessAuthResult(userCredential.user, backendUser, AuthProvider.EMAIL, idToken);
+                    // Update UserContext
+                    UserContext_1.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) {
+                console.error('Detailed error signing in with email:', {
+                    code: error.code,
+                    message: error.message,
+                    fullError: error
+                });
+                return AuthResult.failure(error.message || 'Authentication failed');
+            }
+        });
+    }
+    createUserWithEmail(email, password, username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.auth) {
+                    return AuthResult.failure("Firebase Auth not initialized");
+                }
+                // First create the user in Firebase
+                const userCredential = yield (0, auth_1.createUserWithEmailAndPassword)(this.auth, email, password);
+                const user = userCredential.user;
+                const idToken = yield user.getIdToken();
+                // Send email verification
+                yield (0, auth_1.sendEmailVerification)(user);
+                const backendUser = yield 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) {
+                console.error('Error creating user with email:', error);
+                return AuthResult.failure(error.message || 'User creation failed');
+            }
+        });
+    }
+    signInWithGoogle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.auth) {
+                    return AuthResult.failure("Firebase Auth not initialized");
+                }
+                const provider = new auth_1.GoogleAuthProvider();
+                const userCredential = yield (0, auth_1.signInWithPopup)(this.auth, provider);
+                const user = userCredential.user;
+                // Get or create user in your Kotlin backend
+                const backendUser = yield this.getUserFromBackend(user.uid, user.displayName || '');
+                const idToken = yield 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) {
+                console.error('Error signing in with Google:', error);
+                return AuthResult.failure(error.message || 'Google authentication failed');
+            }
+        });
+    }
+    signInWithFacebook() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.auth) {
+                    return AuthResult.failure("Firebase Auth not initialized");
+                }
+                const provider = new auth_1.FacebookAuthProvider();
+                const userCredential = yield (0, auth_1.signInWithPopup)(this.auth, provider);
+                const user = userCredential.user;
+                // Get or create user in your Kotlin backend
+                const backendUser = yield this.getUserFromBackend(user.uid, user.displayName || '');
+                const idToken = yield 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) {
+                console.error('Error signing in with Facebook:', error);
+                return AuthResult.failure(error.message || 'Facebook authentication failed');
+            }
+        });
+    }
+    signInWithTwitter() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.auth) {
+                    return AuthResult.failure("Firebase Auth not initialized");
+                }
+                const provider = new auth_1.TwitterAuthProvider();
+                const userCredential = yield (0, auth_1.signInWithPopup)(this.auth, provider);
+                const user = userCredential.user;
+                // Get or create user in your Kotlin backend
+                const backendUser = yield this.getUserFromBackend(user.uid, user.displayName || '');
+                const idToken = yield 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) {
+                console.error('Error signing in with Twitter:', error);
+                return AuthResult.failure(error.message || 'Twitter authentication failed');
+            }
+        });
+    }
+    sendEmailVerification() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.auth) {
+                    return false;
+                }
+                const user = this.auth.currentUser;
+                if (user) {
+                    yield (0, auth_1.sendEmailVerification)(user);
+                    return true;
+                }
+                return false;
+            }
+            catch (error) {
+                console.error('Error sending email verification:', error);
+                return false;
+            }
+        });
+    }
+    sendPasswordResetEmail(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.auth) {
+                    return false;
+                }
+                yield (0, auth_1.sendPasswordResetEmail)(this.auth, email);
+                return true;
+            }
+            catch (error) {
+                console.error('Error sending password reset email:', error);
+                return false;
+            }
+        });
+    }
+    signOut() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.auth) {
+                    return;
+                }
+                yield (0, auth_1.signOut)(this.auth);
+                // Clear UserContext
+                UserContext_1.userContext.clearUser();
+            }
+            catch (error) {
+                console.error('Error signing out:', error);
+            }
+        });
+    }
+    getCurrentUser() {
+        if (!this.auth) {
+            return null;
+        }
+        return this.auth.currentUser;
+    }
+    sendSignInLinkToEmail(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.auth) {
+                    return false;
+                }
+                yield (0, auth_1.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) {
+                console.error('Error sending sign-in link to email:', error);
+                return false;
+            }
+        });
+    }
+    isSignInWithEmailLink() {
+        if (!this.auth) {
+            return false;
+        }
+        return (0, auth_1.isSignInWithEmailLink)(this.auth, window.location.href);
+    }
+    signInWithEmailLink(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!this.auth) {
+                    return AuthResult.failure("Firebase Auth not initialized");
+                }
+                if (!this.isSignInWithEmailLink()) {
+                    return AuthResult.failure("Invalid sign-in link");
+                }
+                const userCredential = yield (0, auth_1.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 = yield this.getUserFromBackend(user.uid, user.displayName || '');
+                const idToken = yield 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) {
+                console.error('Error signing in with email link:', error);
+                return AuthResult.failure(error.message || 'Email link authentication failed');
+            }
+        });
+    }
+    getEmailForSignIn() {
+        return window.localStorage.getItem('emailForSignIn');
+    }
+    // Helper method to create success AuthResult
+    _createSuccessAuthResult(user, backendUser, provider, idToken) {
+        const userData = UserData.create(user.uid, user.email || '', backendUser.username || '', user.emailVerified, idToken);
+        return AuthResult.success(backendUser, userData, provider);
+    }
+    // Backend integration methods
+    getUserFromBackend(userId, loginId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.client.getUser(userId, {
+                    Authorization: `Bearer ${loginId}`,
+                });
+                return response.users[0];
+            }
+            catch (error) {
+                console.error('Error getting user from backend:', error);
+                return null;
+            }
+        });
+    }
+    createUserInBackend(userId, username, idToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const createUserRequest = {
+                    id: userId,
+                    username: username
+                };
+                const response = yield this.client.createUser(createUserRequest, {
+                    Authorization: `Bearer ${idToken}`
+                });
+                return response.users[0];
+            }
+            catch (error) {
+                console.error('Error creating user in backend:', error);
+                return null;
+            }
+        });
+    }
+}
+exports.FirebaseUnifiedService = FirebaseUnifiedService;

package/dist/auth/LoginService.d.ts

@@ -0,0 +1,21 @@
+import P2PMarketplaceAPIClient from "../P2PMarketplaceAPIClient";
+import { AuthResult } from "./FirebaseLoginService";
+export type LoginProvider = 'firebase' | 'custom';
+export interface LoginService {
+    signInWithEmail(email: string, password: string): Promise<AuthResult>;
+    createUserWithEmail(email: string, password: string, username: string): Promise<AuthResult>;
+    sendPasswordResetEmail(email: string): Promise<boolean>;
+    signOut(): Promise<void>;
+}
+export interface LoginServiceConfig {
+    provider: LoginProvider;
+    apiClient: P2PMarketplaceAPIClient;
+    firebase?: FirebaseLoginServiceConfig;
+}
+export interface FirebaseLoginServiceConfig {
+    actionCodeSettings?: {
+        url: string;
+        handleCodeInApp: boolean;
+    };
+}
+export declare function createLoginService(config: LoginServiceConfig): LoginService;

package/dist/auth/LoginService.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLoginService = void 0;
+function createLoginService(config) {
+    const { provider, apiClient } = config;
+    if (provider === 'firebase') {
+        const { FirebaseUnifiedService } = require('../FirebaseLoginService');
+        return new FirebaseUnifiedService(apiClient, config.firebase);
+    }
+    throw new Error(`Unsupported login provider: ${provider}`);
+}
+exports.createLoginService = createLoginService;

package/dist/auth/UserContext.d.ts

@@ -0,0 +1,20 @@
+export interface User {
+    id: string;
+    username: string;
+    email: string;
+    idToken: string;
+}
+export interface UserContext {
+    user: User | null;
+    setUser: (user: User | null) => void;
+    updateUser: (updates: Partial<User>) => void;
+    clearUser: () => void;
+}
+export declare class UserContextImpl implements UserContext {
+    private _user;
+    get user(): User | null;
+    setUser(user: User | null): void;
+    updateUser(updates: Partial<User>): void;
+    clearUser(): void;
+}
+export declare const userContext: UserContextImpl;

package/dist/auth/UserContext.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userContext = exports.UserContextImpl = void 0;
+// Implement the UserContext class
+class UserContextImpl {
+    constructor() {
+        this._user = null;
+    }
+    get user() {
+        return this._user;
+    }
+    setUser(user) {
+        this._user = user;
+    }
+    updateUser(updates) {
+        if (this._user) {
+            this._user = Object.assign(Object.assign({}, this._user), updates);
+        }
+    }
+    clearUser() {
+        this._user = null;
+    }
+}
+exports.UserContextImpl = UserContextImpl;
+// Singleton instance of UserContext
+exports.userContext = new UserContextImpl();

package/dist/index.d.ts

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

package/dist/index.js

@@ -17,9 +17,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateSecretAndHash = exports.P2PMarketplaceAPIClient = void 0;
+exports.userContext = exports.createLoginService = exports.FirebaseUnifiedService = exports.generateSecretAndHash = exports.P2PMarketplaceAPIClient = void 0;
 var P2PMarketplaceAPIClient_1 = require("./P2PMarketplaceAPIClient");
 Object.defineProperty(exports, "P2PMarketplaceAPIClient", { enumerable: true, get: function () { return __importDefault(P2PMarketplaceAPIClient_1).default; } });
 var cryptoUtils_1 = require("./cryptoUtils");
 Object.defineProperty(exports, "generateSecretAndHash", { enumerable: true, get: function () { return cryptoUtils_1.generateSecretAndHash; } });
 __exportStar(require("./types"), exports);
+var FirebaseLoginService_1 = require("./auth/FirebaseLoginService");
+Object.defineProperty(exports, "FirebaseUnifiedService", { enumerable: true, get: function () { return FirebaseLoginService_1.FirebaseUnifiedService; } });
+var LoginService_1 = require("./auth/LoginService");
+Object.defineProperty(exports, "createLoginService", { enumerable: true, get: function () { return LoginService_1.createLoginService; } });
+var UserContext_1 = require("./auth/UserContext");
+Object.defineProperty(exports, "userContext", { enumerable: true, get: function () { return UserContext_1.userContext; } });