nexabase-console 2.0.1 → 2.0.3

package/dist/auth/Auth.js

@@ -2,71 +2,384 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthService = exports.Auth = void 0;
 const persistence_1 = require("./persistence");
-const NexaError_1 = require("../errors/NexaError");
+const NexaAuthError_1 = require("./NexaAuthError");
 class Auth {
     constructor(projectId, client, initialToken) {
-        this.token = null;
+        this.emulatorUrl = null;
+        this.currentSession = null;
+        this.listeners = new Set();
+        // Single concurrent token refresh mutex / request deduplication
+        this.refreshPromise = null;
+        this.refreshTimer = null;
         this.projectId = projectId;
         this.client = client;
         this.persistence = new persistence_1.AuthPersistence(projectId);
-        this.token = initialToken || this.persistence.getSavedToken();
+        // Initial session restoration
+        this.initSession().catch((err) => {
+            console.warn('⚡ Session restore failed:', err);
+        });
+        // Multi-tab auth state synchronization via StorageEvent
+        if (typeof window !== 'undefined' && window.addEventListener) {
+            window.addEventListener('storage', (event) => {
+                if (event.key === `nexa_session_${this.projectId}`) {
+                    this.handleStorageChange(event.newValue);
+                }
+            });
+        }
+    }
+    // --- Emulator Integration ---
+    connectAuthEmulator(url) {
+        this.emulatorUrl = url;
+        console.log(`🔌 Auth connected to emulator at ${url}`);
+    }
+    get emulator() {
+        return this.emulatorUrl;
+    }
+    // --- Initial Session Restore ---
+    async initSession() {
+        const saved = await this.persistence.getSession();
+        if (!saved) {
+            this.notifyListeners(null);
+            return;
+        }
+        const now = Date.now();
+        // Check if access token is valid or close to expiration (buffer 60 seconds)
+        if (saved.accessTokenExpiresAt > now + 60000) {
+            this.currentSession = saved;
+            this.scheduleAutoRefresh();
+            this.notifyListeners(saved.user);
+        }
+        else if (saved.refreshTokenExpiresAt > now) {
+            // Access token expired, attempt refresh
+            try {
+                await this.refreshAccessToken(saved.refreshToken);
+            }
+            catch {
+                await this.signOut();
+            }
+        }
+        else {
+            // Refresh token expired
+            await this.signOut();
+        }
+    }
+    // --- Auth State Listeners ---
+    onAuthStateChanged(callback) {
+        this.listeners.add(callback);
+        // Fire callback immediately with current state
+        callback(this.currentUser);
+        return () => {
+            this.listeners.delete(callback);
+        };
+    }
+    notifyListeners(user) {
+        this.listeners.forEach((cb) => {
+            try {
+                cb(user);
+            }
+            catch (e) {
+                console.error('Error in auth listener:', e);
+            }
+        });
+    }
+    async handleStorageChange(newValue) {
+        if (!newValue) {
+            this.currentSession = null;
+            this.clearAutoRefresh();
+            this.notifyListeners(null);
+            return;
+        }
+        try {
+            const parsed = JSON.parse(newValue);
+            this.currentSession = parsed;
+            this.scheduleAutoRefresh();
+            this.notifyListeners(parsed.user);
+        }
+        catch {
+            await this.signOut();
+        }
+    }
+    // --- User Getters ---
+    get currentUser() {
+        return this.currentSession?.user || null;
     }
     getToken() {
-        return this.token;
+        return this.currentSession?.accessToken || null;
     }
     setToken(token) {
-        this.token = token;
+        if (this.currentSession) {
+            this.currentSession.accessToken = token || '';
+        }
+    }
+    // --- Single Flight Token Refresh (Mutex / Request Deduplication) ---
+    async getIdToken(forceRefresh = false) {
+        if (!this.currentSession) {
+            throw new NexaAuthError_1.NexaAuthError('auth/unauthenticated', 'User belum login.');
+        }
+        const now = Date.now();
+        const isExpired = this.currentSession.accessTokenExpiresAt <= now + 60000;
+        if (forceRefresh || isExpired) {
+            const session = await this.refreshAccessTokenDeduplicated();
+            return session.accessToken;
+        }
+        return this.currentSession.accessToken;
+    }
+    async getIdTokenResult(forceRefresh = false) {
+        const token = await this.getIdToken(forceRefresh);
+        const claims = this.parseJwtClaims(token);
+        return {
+            token,
+            expirationTime: new Date(claims.exp * 1000).toISOString(),
+            authTime: new Date(claims.auth_time * 1000).toISOString(),
+            issuedAtTime: new Date(claims.iat * 1000).toISOString(),
+            signInProvider: claims.provider_id || 'password',
+            claims
+        };
+    }
+    parseJwtClaims(token) {
+        try {
+            const base64Url = token.split('.')[1];
+            const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+            const jsonPayload = decodeURIComponent(atob(base64)
+                .split('')
+                .map((c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2))
+                .join(''));
+            return JSON.parse(jsonPayload);
+        }
+        catch {
+            return {};
+        }
+    }
+    // Deduplicated token refresh (Concurrent Request Safety)
+    refreshAccessTokenDeduplicated() {
+        if (this.refreshPromise) {
+            return this.refreshPromise; // Return active in-flight request
+        }
+        if (!this.currentSession?.refreshToken) {
+            return Promise.reject(new NexaAuthError_1.NexaAuthError('auth/invalid-refresh-token', 'Refresh token tidak ditemukan.'));
+        }
+        this.refreshPromise = this.refreshAccessToken(this.currentSession.refreshToken)
+            .finally(() => {
+            this.refreshPromise = null;
+        });
+        return this.refreshPromise;
+    }
+    async refreshAccessToken(refreshToken) {
+        const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/token/refresh`;
+        try {
+            const res = await this.client.post(endpoint, { refreshToken });
+            const session = res.data;
+            this.currentSession = session;
+            await this.persistence.saveSession(session);
+            this.scheduleAutoRefresh();
+            this.notifyListeners(session.user);
+            return session;
+        }
+        catch (err) {
+            await this.signOut();
+            throw new NexaAuthError_1.NexaAuthError(err.response?.data?.code || 'auth/session-expired', err.response?.data?.message || 'Sesi telah berakhir, silakan login kembali.', err.response?.status || 401);
+        }
+    }
+    scheduleAutoRefresh() {
+        this.clearAutoRefresh();
+        if (!this.currentSession)
+            return;
+        const expiresAt = this.currentSession.accessTokenExpiresAt;
+        const now = Date.now();
+        // Refresh 2 minutes before expiry
+        const delay = Math.max(1000, expiresAt - now - 120000);
+        this.refreshTimer = setTimeout(() => {
+            this.refreshAccessTokenDeduplicated().catch((err) => {
+                console.warn('⚠️ Auto token refresh failed:', err);
+            });
+        }, delay);
+    }
+    clearAutoRefresh() {
+        if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+    }
+    // --- Email & Password Auth ---
+    async createUserWithEmailAndPassword(email, password, name) {
+        try {
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/register`;
+            const res = await this.client.post(endpoint, { email, password, name });
+            const session = res.data;
+            this.currentSession = session;
+            await this.persistence.saveSession(session);
+            this.scheduleAutoRefresh();
+            this.notifyListeners(session.user);
+            return session;
+        }
+        catch (err) {
+            throw new NexaAuthError_1.NexaAuthError(err.response?.data?.code || 'auth/email-already-in-use', err.response?.data?.message || 'Gagal mendaftar pengguna baru.', err.response?.status || 400);
+        }
     }
     async signInWithEmailAndPassword(email, password) {
         try {
-            const res = await this.client.post(`/api/project/${this.projectId}/auth/login`, { email, password });
-            if (res.data.token) {
-                this.token = res.data.token;
-                this.persistence.saveSession(res.data.token, res.data.user);
-            }
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/login`;
+            const res = await this.client.post(endpoint, { email, password });
+            const session = res.data;
+            this.currentSession = session;
+            await this.persistence.saveSession(session);
+            this.scheduleAutoRefresh();
+            this.notifyListeners(session.user);
+            return session;
+        }
+        catch (err) {
+            throw new NexaAuthError_1.NexaAuthError(err.response?.data?.code || 'auth/invalid-credential', err.response?.data?.message || 'Email atau password salah.', err.response?.status || 401);
+        }
+    }
+    // --- OTP Auth ---
+    async sendOtp(email) {
+        try {
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/otp/send`;
+            const res = await this.client.post(endpoint, { email });
             return res.data;
         }
         catch (err) {
-            throw (0, NexaError_1.toNexaError)(err);
+            throw new NexaAuthError_1.NexaAuthError(err.response?.data?.code || 'auth/otp-rate-limit', err.response?.data?.message || 'Gagal mengirim OTP.', err.response?.status || 429);
         }
     }
-    async createUserWithEmailAndPassword(email, password, name) {
+    async signInWithOtp(email, otp) {
         try {
-            const res = await this.client.post(`/api/project/${this.projectId}/users`, { email, password, name });
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/otp/login`;
+            const res = await this.client.post(endpoint, { email, otp });
+            const session = res.data;
+            this.currentSession = session;
+            await this.persistence.saveSession(session);
+            this.scheduleAutoRefresh();
+            this.notifyListeners(session.user);
+            return session;
+        }
+        catch (err) {
+            throw new NexaAuthError_1.NexaAuthError(err.response?.data?.code || 'auth/invalid-otp', err.response?.data?.message || 'Kode OTP tidak valid atau telah kedaluwarsa.', err.response?.status || 400);
+        }
+    }
+    // --- Password Reset & Verification ---
+    async sendPasswordResetEmail(email) {
+        try {
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/password-reset/send`;
+            const res = await this.client.post(endpoint, { email });
             return res.data;
         }
         catch (err) {
-            throw (0, NexaError_1.toNexaError)(err);
+            throw new NexaAuthError_1.NexaAuthError('auth/user-not-found', 'Permintaan reset password gagal.');
         }
     }
-    async sendOtp(email) {
+    async confirmPasswordReset(code, newPassword) {
         try {
-            const res = await this.client.post(`/api/project/${this.projectId}/auth/otp/send`, { email });
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/password-reset/confirm`;
+            const res = await this.client.post(endpoint, { code, newPassword });
             return res.data;
         }
         catch (err) {
-            throw (0, NexaError_1.toNexaError)(err);
+            throw new NexaAuthError_1.NexaAuthError('auth/invalid-credential', 'Kode reset password tidak valid.');
         }
     }
-    async signInWithOtp(email, otp, name) {
+    async sendEmailVerification() {
+        const token = await this.getIdToken();
         try {
-            const res = await this.client.post(`/api/project/${this.projectId}/auth/otp/login`, { email, otp, name });
-            if (res.data.token) {
-                this.token = res.data.token;
-                this.persistence.saveSession(res.data.token, res.data.user);
-            }
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/email/send-verification`;
+            const res = await this.client.post(endpoint, {}, {
+                headers: { Authorization: `Bearer ${token}` }
+            });
             return res.data;
         }
         catch (err) {
-            throw (0, NexaError_1.toNexaError)(err);
+            throw new NexaAuthError_1.NexaAuthError('auth/unauthenticated', 'Gagal mengirim email verifikasi.');
         }
     }
-    signOut() {
-        this.token = null;
-        this.persistence.clearSession();
+    // --- User Profile & Account Management ---
+    async updateProfile(update) {
+        const token = await this.getIdToken();
+        try {
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/profile`;
+            const res = await this.client.patch(endpoint, update, {
+                headers: { Authorization: `Bearer ${token}` }
+            });
+            const updatedUser = res.data;
+            if (this.currentSession) {
+                this.currentSession.user = updatedUser;
+                await this.persistence.saveSession(this.currentSession);
+                this.notifyListeners(updatedUser);
+            }
+            return updatedUser;
+        }
+        catch (err) {
+            throw new NexaAuthError_1.NexaAuthError('auth/invalid-argument', 'Gagal memperbarui profil.');
+        }
+    }
+    async updatePassword(newPassword) {
+        const token = await this.getIdToken();
+        try {
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/password/update`;
+            await this.client.post(endpoint, { newPassword }, {
+                headers: { Authorization: `Bearer ${token}` }
+            });
+        }
+        catch (err) {
+            throw new NexaAuthError_1.NexaAuthError(err.response?.data?.code || 'auth/requires-recent-login', 'Gagal memperbarui password. Silakan re-autentikasi.', err.response?.status || 401);
+        }
+    }
+    async deleteUser() {
+        const token = await this.getIdToken();
+        try {
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/user/delete`;
+            await this.client.delete(endpoint, {
+                headers: { Authorization: `Bearer ${token}` }
+            });
+            await this.signOut();
+        }
+        catch (err) {
+            throw new NexaAuthError_1.NexaAuthError('auth/requires-recent-login', 'Gagal menghapus akun.');
+        }
+    }
+    // --- Session Revocation & Sign Out ---
+    async revokeSession(sessionId) {
+        const token = await this.getIdToken();
+        try {
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/session/revoke`;
+            await this.client.post(endpoint, { sessionId }, {
+                headers: { Authorization: `Bearer ${token}` }
+            });
+        }
+        catch (err) {
+            throw new NexaAuthError_1.NexaAuthError('auth/invalid-argument', 'Gagal mereduksi sesi.');
+        }
+    }
+    async revokeAllSessions() {
+        const token = await this.getIdToken();
+        try {
+            const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/session/revoke-all`;
+            await this.client.post(endpoint, {}, {
+                headers: { Authorization: `Bearer ${token}` }
+            });
+            await this.signOut();
+        }
+        catch (err) {
+            throw new NexaAuthError_1.NexaAuthError('auth/invalid-argument', 'Gagal mereduksi seluruh sesi.');
+        }
+    }
+    async signOut() {
+        this.clearAutoRefresh();
+        const oldSession = this.currentSession;
+        this.currentSession = null;
+        if (oldSession) {
+            try {
+                const endpoint = this.emulatorUrl || `/api/project/${this.projectId}/auth/logout`;
+                await this.client.post(endpoint, { refreshToken: oldSession.refreshToken });
+            }
+            catch {
+                // Non-blocking logout network failure
+            }
+        }
+        await this.persistence.clearSession();
+        this.notifyListeners(null);
     }
     getCurrentUser() {
-        return this.persistence.getSavedUser();
+        return this.currentUser;
     }
 }
 exports.Auth = Auth;

package/dist/auth/NexaAuthError.d.ts

@@ -0,0 +1,5 @@
+export declare class NexaAuthError extends Error {
+    readonly code: string;
+    readonly status?: number;
+    constructor(code: string, message: string, status?: number);
+}

package/dist/auth/NexaAuthError.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NexaAuthError = void 0;
+class NexaAuthError extends Error {
+    constructor(code, message, status) {
+        super(message);
+        this.name = 'NexaAuthError';
+        this.code = code;
+        this.status = status;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(this, NexaAuthError);
+        }
+    }
+}
+exports.NexaAuthError = NexaAuthError;

package/dist/auth/authTypes.d.ts

@@ -1 +1,38 @@
-export type { User, AuthResponse } from '../types/index';
+import { Timestamp } from '../firestore/Timestamp';
+export interface User {
+    uid: string;
+    email: string | null;
+    emailVerified: boolean;
+    name: string | null;
+    photoURL: string | null;
+    phoneNumber: string | null;
+    disabled: boolean;
+    createdAt: Timestamp | string;
+    updatedAt: Timestamp | string;
+    lastLoginAt: Timestamp | string;
+}
+export interface AuthSession {
+    accessToken: string;
+    refreshToken: string;
+    accessTokenExpiresAt: number;
+    refreshTokenExpiresAt: number;
+    user: User;
+}
+export interface IdTokenResult {
+    token: string;
+    expirationTime: string;
+    authTime: string;
+    issuedAtTime: string;
+    signInProvider: string | null;
+    claims: Record<string, unknown>;
+}
+export interface UserProfileUpdate {
+    name?: string | null;
+    photoURL?: string | null;
+}
+export interface IAuthPersistence {
+    getSession(): Promise<AuthSession | null>;
+    saveSession(session: AuthSession): Promise<void>;
+    clearSession(): Promise<void>;
+}
+export type AuthStateCallback = (user: User | null) => void;

package/dist/auth/persistence.d.ts

@@ -1,9 +1,11 @@
-import { User } from './authTypes';
-export declare class AuthPersistence {
+import { AuthSession, IAuthPersistence } from './authTypes';
+export declare class AuthPersistence implements IAuthPersistence {
     private projectId;
+    private storageKey;
     constructor(projectId: string);
-    saveSession(token: string, user: User): void;
-    clearSession(): void;
+    getSession(): Promise<AuthSession | null>;
+    saveSession(session: AuthSession): Promise<void>;
+    clearSession(): Promise<void>;
     getSavedToken(): string | null;
-    getSavedUser(): User | null;
+    getSavedUser(): AuthSession['user'] | null;
 }

package/dist/auth/persistence.js

@@ -4,31 +4,60 @@ exports.AuthPersistence = void 0;
 class AuthPersistence {
     constructor(projectId) {
         this.projectId = projectId;
+        this.storageKey = `nexa_session_${projectId}`;
     }
-    saveSession(token, user) {
+    async getSession() {
+        if (typeof window === 'undefined' || !window.localStorage) {
+            return null;
+        }
+        try {
+            const item = localStorage.getItem(this.storageKey);
+            if (!item)
+                return null;
+            return JSON.parse(item);
+        }
+        catch {
+            return null;
+        }
+    }
+    async saveSession(session) {
         if (typeof window !== 'undefined' && window.localStorage) {
-            localStorage.setItem(`nexa_token_${this.projectId}`, token);
-            localStorage.setItem(`nexa_user_${this.projectId}`, JSON.stringify(user));
+            localStorage.setItem(this.storageKey, JSON.stringify(session));
         }
     }
-    clearSession() {
+    async clearSession() {
         if (typeof window !== 'undefined' && window.localStorage) {
-            localStorage.removeItem(`nexa_token_${this.projectId}`);
-            localStorage.removeItem(`nexa_user_${this.projectId}`);
+            localStorage.removeItem(this.storageKey);
         }
     }
+    // Helper backward compatibility
     getSavedToken() {
-        if (typeof window !== 'undefined' && window.localStorage) {
-            return localStorage.getItem(`nexa_token_${this.projectId}`);
+        if (typeof window === 'undefined' || !window.localStorage)
+            return null;
+        try {
+            const session = localStorage.getItem(this.storageKey);
+            if (!session)
+                return null;
+            const parsed = JSON.parse(session);
+            return parsed.accessToken || null;
+        }
+        catch {
+            return null;
         }
-        return null;
     }
     getSavedUser() {
-        if (typeof window !== 'undefined' && window.localStorage) {
-            const userStr = localStorage.getItem(`nexa_user_${this.projectId}`);
-            return userStr ? JSON.parse(userStr) : null;
+        if (typeof window === 'undefined' || !window.localStorage)
+            return null;
+        try {
+            const session = localStorage.getItem(this.storageKey);
+            if (!session)
+                return null;
+            const parsed = JSON.parse(session);
+            return parsed.user || null;
+        }
+        catch {
+            return null;
         }
-        return null;
     }
 }
 exports.AuthPersistence = AuthPersistence;

package/dist/facade/nexaSDK.d.ts

@@ -0,0 +1,93 @@
+import { NexaApp } from '../app/initializeApp';
+export interface NexaSDKOptions {
+    app?: NexaApp;
+    baseURL?: string;
+}
+export interface AdjustStockParams {
+    productId: string;
+    delta: number;
+    reason?: string;
+    referenceId?: string;
+}
+export interface ScanResiParams {
+    noResi: string;
+    orderId?: string;
+    courier?: string;
+}
+export interface CancelOrderParams {
+    orderId: string;
+    reason?: string;
+}
+export interface TransferParams {
+    fromUserId: string;
+    toUserId: string;
+    amount: number;
+    currency?: string;
+    note?: string;
+}
+export interface IncrementCounterParams {
+    docPath: string;
+    field: string;
+    amount?: number;
+}
+/**
+ * Universal NexaBase Client SDK Facade (Domain & Server-Authoritative Logic)
+ * Decouples client components & stores from raw primitives like getDocs/runTransaction.
+ */
+export declare class NexaSDKFacade {
+    private appInstance;
+    private customBaseURL;
+    constructor(options?: NexaSDKOptions);
+    private getApp;
+    private getBaseURL;
+    /**
+     * Universal Server-Authoritative Cloud Function Caller
+     */
+    call<T = any>(functionName: string, data?: any): Promise<T>;
+    products: {
+        /**
+         * Atomically adjust product stock in server with audit log trail
+         */
+        adjustStock: (params: AdjustStockParams) => Promise<any>;
+        /**
+         * Quick stock deduction helper
+         */
+        deductStock: (productId: string, qty: number, reason?: string) => Promise<any>;
+        /**
+         * Quick stock addition helper
+         */
+        addStock: (productId: string, qty: number, reason?: string) => Promise<any>;
+    };
+    orders: {
+        /**
+         * Scan tracking number (resi), update shipping status & auto-deduct stock atomically
+         */
+        scanResi: (params: ScanResiParams) => Promise<any>;
+        /**
+         * Cancel an order & automatically return deducted stock to inventory
+         */
+        cancelOrder: (params: CancelOrderParams) => Promise<any>;
+    };
+    finance: {
+        /**
+         * Atomic balance transfer between users with ledger record
+         */
+        transferBalance: (params: TransferParams) => Promise<any>;
+    };
+    utils: {
+        /**
+         * Atomic field incrementer on any Firestore document
+         */
+        increment: (params: IncrementCounterParams) => Promise<any>;
+    };
+}
+/**
+ * Singleton Default Facade Export
+ */
+export declare const nexaSDK: NexaSDKFacade;
+/**
+ * Factory function to create custom facade instance with specific NexaApp
+ */
+export declare function createNexaSDK(app?: NexaApp, options?: {
+    baseURL?: string;
+}): NexaSDKFacade;