nexabase-console 2.0.1 → 2.0.2

package/README.md

@@ -220,47 +220,120 @@ async function potongStokAman(productId, variantId, qtyBeli) {
 
 ---
 
-### 3. Autentikasi Pengguna & OTP Tanpa Sandi
+### 3. Autentikasi Pengguna & OTP Tanpa Sandi (SDK v2.0.0)
 
-#### Pendaftaran & Login Tradisional
+#### Inisialisasi Auth & Realtime State Listener
 ```javascript
-// Registrasi User Baru
+import { getAuth, NexaAuthError } from 'nexabase-console';
+
+const auth = getAuth(app);
+
+// Realtime Listener & Sync Sesi Multi-Tab via StorageEvent
+const unsubscribe = auth.onAuthStateChanged((user) => {
+  if (user) {
+    console.log("User terautentikasi:", user.uid, "| Email:", user.email);
+  } else {
+    console.log("User ter-logout / belum login");
+  }
+});
+```
+
+#### Pendaftaran & Login Email/Password
+```javascript
+// 1. Registrasi Akun Baru
 const register = async () => {
-  const user = await app.auth().createUserWithEmailAndPassword(
-    'test@example.com', 
-    'password123', 
-    'Andi Wijaya'
-  );
-  console.log("Registrasi Berhasil:", user);
+  try {
+    const session = await auth.createUserWithEmailAndPassword(
+      'budi@example.com', 
+      'Password123!', 
+      'Budi Santoso'
+    );
+    console.log("Registrasi Berhasil! UID:", session.user.uid);
+  } catch (err) {
+    if (err instanceof NexaAuthError && err.code === 'auth/email-already-in-use') {
+      console.error("Email sudah terdaftar.");
+    }
+  }
 };
 
-// Login User
+// 2. Login User (Dukungan Automatic Single-Flight Token Refresh)
 const login = async () => {
-  const authSession = await app.auth().signInWithEmailAndPassword(
-    'test@example.com', 
-    'password123'
-  );
-  console.log("Token Sesi JWT:", authSession.token);
-  console.log("Data Akun Pengguna:", authSession.user);
+  try {
+    const session = await auth.signInWithEmailAndPassword(
+      'budi@example.com', 
+      'Password123!'
+    );
+    console.log("Access Token JWT:", session.accessToken);
+    console.log("Refresh Token:", session.refreshToken);
+  } catch (err) {
+    if (err instanceof NexaAuthError && err.code === 'auth/invalid-credential') {
+      console.error("Email atau password salah.");
+    }
+  }
 };
 ```
 
-#### Login Passwordless dengan OTP (Email)
+#### Login Passwordless dengan OTP (Email 6-Digit)
 ```javascript
-// 1. Kirim OTP Ke Email Pengguna
+// 1. Kirim OTP Ke Email (Berlaku 5 Menit, Hash Single-Use)
 const sendMyOtp = async () => {
-  const res = await app.auth().sendOtp('test@example.com');
-  console.log("Kode OTP berhasil terkirim ke email Anda.");
+  const res = await auth.sendOtp('budi@example.com');
+  console.log("Kode OTP berhasil terkirim:", res.message);
 };
 
 // 2. Verifikasi OTP dari Input Pengguna
 const verifyMyOtp = async () => {
-  const otpCode = '123456'; // Kode 6 digit yang dikirim ke email
-  const authSession = await app.auth().signInWithOtp('test@example.com', otpCode, 'Andi Wijaya');
-  console.log("Login OTP Berhasil! Sesi JWT Aktif:", authSession.token);
+  try {
+    const otpCode = '123456'; // Kode 6 digit yang dikirim ke email
+    const session = await auth.signInWithOtp('budi@example.com', otpCode);
+    console.log("Login OTP Berhasil! Welcome:", session.user.email);
+  } catch (err) {
+    if (err instanceof NexaAuthError) {
+      if (err.code === 'auth/invalid-otp') console.error("OTP tidak valid.");
+      if (err.code === 'auth/expired-otp') console.error("OTP kedaluwarsa.");
+      if (err.code === 'auth/too-many-otp-attempts') console.error("Terlalu banyak percobaan.");
+    }
+  }
 };
 ```
 
+#### Mengambil ID Token untuk Request API / Server Verification
+```javascript
+// Mengambil token JWT (dengan auto-refresh jika hampir expired)
+const idToken = await auth.getIdToken(/* forceRefresh */ false);
+
+// Mengambil rincian klaim token (exp, authTime, claims)
+const tokenResult = await auth.getIdTokenResult();
+console.log("Token Kedaluwarsa:", tokenResult.expirationTime);
+```
+
+#### Update Profil, Reset Password & Sign Out
+```javascript
+// Update Profil
+await auth.updateProfile({ name: 'Budi Santoso, M.T.', photoURL: 'https://example.com/photo.jpg' });
+
+// Reset Password Email
+await auth.sendPasswordResetEmail('budi@example.com');
+
+// Revoke All Sessions
+await auth.revokeAllSessions();
+
+// === Opsi Logout Akun (Sign Out) ===
+// 1. Method Instance (Rekomendasi)
+await auth.signOut();
+
+// 2. Fungsi Standar Modular
+import { signOut } from 'nexabase-console';
+await signOut(auth);
+
+// 3. Namespace Helper
+import { NexabaseAuth } from 'nexabase-console';
+await NexabaseAuth.signOut(auth);
+
+// 4. Shortcut dari objek App
+await app.signOut();
+```
+
 ---
 
 ### 4. File Storage API

package/dist/app/NexaApp.d.ts

@@ -1,8 +1,9 @@
 import { AxiosInstance } from 'axios';
-import { NexaConfig, User, AuthResponse, DatabaseReference, StorageReference, UploadOptions, OfflineJob } from '../types/index';
+import { NexaConfig, DatabaseReference, StorageReference, UploadOptions, OfflineJob } from '../types/index';
 import { HttpClient } from '../transport/HttpClient';
 import { SSEClient } from '../transport/SSEClient';
 import { Auth } from '../auth/Auth';
+import { User as AuthUser, AuthSession } from '../auth/authTypes';
 import { IndexedDB } from '../persistence/IndexedDB';
 import { LocalStore } from '../persistence/LocalStore';
 import { MutationQueue } from '../persistence/MutationQueue';
@@ -44,15 +45,15 @@ export declare class NexaApp {
     _ensureFirestoreSSE(): void;
     _closeFirestoreSSEIfIdle(): void;
     _notifySnapshotCallbacks(path: string, actionType: string, payload: any): void;
-    signInWithEmailAndPassword(email: string, password: string): Promise<AuthResponse>;
-    createUserWithEmailAndPassword(email: string, password: string, name: string): Promise<User>;
+    signInWithEmailAndPassword(email: string, password: string): Promise<AuthSession>;
+    createUserWithEmailAndPassword(email: string, password: string, name?: string): Promise<AuthSession>;
     sendOtp(email: string): Promise<{
         success: boolean;
         message: string;
     }>;
-    signInWithOtp(email: string, otp: string, name?: string): Promise<AuthResponse>;
+    signInWithOtp(email: string, otp: string): Promise<AuthSession>;
     signOut(): void;
-    getCurrentUser(): User | null;
+    getCurrentUser(): AuthUser | null;
     ref(path: string): DatabaseReference;
     storageRef(path: string): StorageReference;
     uploadFile(path: string, file: File | Blob, options?: UploadOptions): Promise<{

package/dist/app/NexaApp.js

@@ -150,8 +150,8 @@ class NexaApp {
     async sendOtp(email) {
         return this.authService.sendOtp(email);
     }
-    async signInWithOtp(email, otp, name) {
-        const res = await this.authService.signInWithOtp(email, otp, name);
+    async signInWithOtp(email, otp) {
+        const res = await this.authService.signInWithOtp(email, otp);
         this.token = this.authService.getToken();
         return res;
     }

package/dist/app/initializeApp.d.ts

@@ -1,8 +1,14 @@
 import { NexaApp } from './NexaApp';
 import { NexaConfig } from '../types/index';
+import { Auth } from '../auth/Auth';
 export declare const NexaBase: {
     init: (config: NexaConfig) => NexaApp;
     initializeApp: (config: NexaConfig) => NexaApp;
 };
 export declare const initializeApp: (config: NexaConfig) => NexaApp;
 export declare const getFirestore: (app: NexaApp) => NexaApp;
+export declare const getAuth: (app: NexaApp) => Auth;
+export declare const signOut: (auth: Auth) => Promise<void>;
+export declare const NexabaseAuth: {
+    signOut: (auth: Auth) => Promise<void>;
+};

package/dist/app/initializeApp.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFirestore = exports.initializeApp = exports.NexaBase = void 0;
+exports.NexabaseAuth = exports.signOut = exports.getAuth = exports.getFirestore = exports.initializeApp = exports.NexaBase = void 0;
 const NexaApp_1 = require("./NexaApp");
 exports.NexaBase = {
     init: (config) => {
@@ -25,3 +25,16 @@ const getFirestore = (app) => {
     return app;
 };
 exports.getFirestore = getFirestore;
+const getAuth = (app) => {
+    return app.authService;
+};
+exports.getAuth = getAuth;
+const signOut = (auth) => {
+    return auth.signOut();
+};
+exports.signOut = signOut;
+exports.NexabaseAuth = {
+    signOut: (auth) => {
+        return auth.signOut();
+    }
+};

package/dist/auth/Auth.d.ts

@@ -1,21 +1,53 @@
 import { AxiosInstance } from 'axios';
-import { User, AuthResponse } from './authTypes';
+import { User, AuthSession, IdTokenResult, UserProfileUpdate, AuthStateCallback } from './authTypes';
 export declare class Auth {
     private projectId;
     private client;
-    private token;
     private persistence;
+    private emulatorUrl;
+    private currentSession;
+    private listeners;
+    private refreshPromise;
+    private refreshTimer;
     constructor(projectId: string, client: AxiosInstance, initialToken: string | null);
+    connectAuthEmulator(url: string): void;
+    get emulator(): string | null;
+    private initSession;
+    onAuthStateChanged(callback: AuthStateCallback): () => void;
+    private notifyListeners;
+    private handleStorageChange;
+    get currentUser(): User | null;
     getToken(): string | null;
     setToken(token: string | null): void;
-    signInWithEmailAndPassword(email: string, password: string): Promise<AuthResponse>;
-    createUserWithEmailAndPassword(email: string, password: string, name: string): Promise<User>;
+    getIdToken(forceRefresh?: boolean): Promise<string>;
+    getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult>;
+    private parseJwtClaims;
+    private refreshAccessTokenDeduplicated;
+    private refreshAccessToken;
+    private scheduleAutoRefresh;
+    private clearAutoRefresh;
+    createUserWithEmailAndPassword(email: string, password: string, name?: string): Promise<AuthSession>;
+    signInWithEmailAndPassword(email: string, password: string): Promise<AuthSession>;
     sendOtp(email: string): Promise<{
         success: boolean;
         message: string;
     }>;
-    signInWithOtp(email: string, otp: string, name?: string): Promise<AuthResponse>;
-    signOut(): void;
+    signInWithOtp(email: string, otp: string): Promise<AuthSession>;
+    sendPasswordResetEmail(email: string): Promise<{
+        success: boolean;
+    }>;
+    confirmPasswordReset(code: string, newPassword: string): Promise<{
+        success: boolean;
+    }>;
+    sendEmailVerification(): Promise<{
+        success: boolean;
+    }>;
+    updateProfile(update: UserProfileUpdate): Promise<User>;
+    updatePassword(newPassword: string): Promise<void>;
+    deleteUser(): Promise<void>;
+    revokeSession(sessionId?: string): Promise<void>;
+    revokeAllSessions(): Promise<void>;
+    signOut(): Promise<void>;
     getCurrentUser(): User | null;
 }
 export { Auth as AuthService };

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;

package/dist/facade/nexaSDK.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nexaSDK = exports.NexaSDKFacade = void 0;
+exports.createNexaSDK = createNexaSDK;
+const initializeApp_1 = require("../app/initializeApp");
+/**
+ * Universal NexaBase Client SDK Facade (Domain & Server-Authoritative Logic)
+ * Decouples client components & stores from raw primitives like getDocs/runTransaction.
+ */
+class NexaSDKFacade {
+    constructor(options) {
+        this.appInstance = null;
+        this.customBaseURL = '';
+        /* =========================================================================
+         * 1. PRODUCTS & INVENTORY DOMAIN
+         * ========================================================================= */
+        this.products = {
+            /**
+             * Atomically adjust product stock in server with audit log trail
+             */
+            adjustStock: async (params) => {
+                return this.call('adjustProductStock', params);
+            },
+            /**
+             * Quick stock deduction helper
+             */
+            deductStock: async (productId, qty, reason = 'sale') => {
+                return this.call('adjustProductStock', { productId, delta: -Math.abs(qty), reason });
+            },
+            /**
+             * Quick stock addition helper
+             */
+            addStock: async (productId, qty, reason = 'restock') => {
+                return this.call('adjustProductStock', { productId, delta: Math.abs(qty), reason });
+            }
+        };
+        /* =========================================================================
+         * 2. ORDERS & WAREHOUSE DOMAIN
+         * ========================================================================= */
+        this.orders = {
+            /**
+             * Scan tracking number (resi), update shipping status & auto-deduct stock atomically
+             */
+            scanResi: async (params) => {
+                return this.call('scanResiOrder', params);
+            },
+            /**
+             * Cancel an order & automatically return deducted stock to inventory
+             */
+            cancelOrder: async (params) => {
+                return this.call('cancelOrder', params);
+            }
+        };
+        /* =========================================================================
+         * 3. FINANCIAL & TRANSACTION DOMAIN
+         * ========================================================================= */
+        this.finance = {
+            /**
+             * Atomic balance transfer between users with ledger record
+             */
+            transferBalance: async (params) => {
+                return this.call('transferBalance', params);
+            }
+        };
+        /* =========================================================================
+         * 4. GENERAL PURPOSE UTILITIES
+         * ========================================================================= */
+        this.utils = {
+            /**
+             * Atomic field incrementer on any Firestore document
+             */
+            increment: async (params) => {
+                return this.call('incrementCounter', params);
+            }
+        };
+        if (options?.app)
+            this.appInstance = options.app;
+        if (options?.baseURL)
+            this.customBaseURL = options.baseURL;
+    }
+    getApp() {
+        if (this.appInstance)
+            return this.appInstance;
+        return (0, initializeApp_1.getApp)();
+    }
+    getBaseURL() {
+        if (this.customBaseURL)
+            return this.customBaseURL;
+        if (typeof window !== 'undefined')
+            return window.location.origin;
+        return 'http://localhost:3000';
+    }
+    /**
+     * Universal Server-Authoritative Cloud Function Caller
+     */
+    async call(functionName, data = {}) {
+        const app = this.getApp();
+        const projectId = app.options.projectId;
+        const apiKey = app.options.apiKey;
+        const url = `${this.getBaseURL()}/api/functions/${projectId}/${functionName}`;
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (apiKey) {
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(data)
+        });
+        const result = await response.json();
+        if (!response.ok || result.success === false) {
+            throw new Error(result.error || result.message || `Failed to execute function "${functionName}"`);
+        }
+        return result;
+    }
+}
+exports.NexaSDKFacade = NexaSDKFacade;
+/**
+ * Singleton Default Facade Export
+ */
+exports.nexaSDK = new NexaSDKFacade();
+/**
+ * Factory function to create custom facade instance with specific NexaApp
+ */
+function createNexaSDK(app, options) {
+    return new NexaSDKFacade({ app, baseURL: options?.baseURL });
+}

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from './app/NexaApp';
 export * from './auth/Auth';
 export * from './auth/authTypes';
 export * from './auth/persistence';
+export * from './auth/NexaAuthError';
 export * from './firestore/Firestore';
 export * from './firestore/DocumentReference';
 export * from './firestore/CollectionReference';

package/dist/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./app/NexaApp"), exports);
 __exportStar(require("./auth/Auth"), exports);
 __exportStar(require("./auth/authTypes"), exports);
 __exportStar(require("./auth/persistence"), exports);
+__exportStar(require("./auth/NexaAuthError"), exports);
 // Firestore
 __exportStar(require("./firestore/Firestore"), exports);
 __exportStar(require("./firestore/DocumentReference"), exports);

package/dist/storage/Storage.d.ts

@@ -9,4 +9,9 @@ export declare class Storage {
         path: string;
     }>;
     getDownloadURL(path: string): Promise<string>;
+    deleteFile(path: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
 }
+export declare const getStorage: (app: any) => Storage;

package/dist/storage/Storage.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Storage = void 0;
+exports.getStorage = exports.Storage = void 0;
 const UploadTask_1 = require("./UploadTask");
 const NexaError_1 = require("../errors/NexaError");
 class Storage {
@@ -37,5 +37,21 @@ class Storage {
             throw (0, NexaError_1.toNexaError)(err);
         }
     }
+    async deleteFile(path) {
+        try {
+            const res = await this.client.delete(`/api/project/${this.projectId}/storage/file?path=${encodeURIComponent(path)}`);
+            return res.data;
+        }
+        catch (err) {
+            throw (0, NexaError_1.toNexaError)(err);
+        }
+    }
 }
 exports.Storage = Storage;
+const getStorage = (app) => {
+    if (app && typeof app.storage === 'function') {
+        return app.storage();
+    }
+    throw new Error('Invalid NexaApp instance provided to getStorage()');
+};
+exports.getStorage = getStorage;

package/dist/storage/StorageReference.d.ts

@@ -9,5 +9,23 @@ export declare class StorageReferenceImpl implements IStorageReference {
         path: string;
     }>;
     getDownloadURL(): Promise<string>;
+    delete(): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
 }
 export declare const storageRef: (storage: Storage, path: string) => IStorageReference;
+export declare const ref: (storage: Storage, path: string) => IStorageReference;
+export declare const uploadBytes: (storageRef: IStorageReference, file: File | Blob, options?: UploadOptions) => Promise<{
+    url: string;
+    path: string;
+}>;
+export declare const uploadBytesResumable: (storageRef: IStorageReference, file: File | Blob, options?: UploadOptions) => Promise<{
+    url: string;
+    path: string;
+}>;
+export declare const getDownloadURL: (storageRef: IStorageReference) => Promise<string>;
+export declare const deleteObject: (storageRef: IStorageReference) => Promise<{
+    success: boolean;
+    message?: string;
+}>;

package/dist/storage/StorageReference.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.storageRef = exports.StorageReferenceImpl = void 0;
+exports.deleteObject = exports.getDownloadURL = exports.uploadBytesResumable = exports.uploadBytes = exports.ref = exports.storageRef = exports.StorageReferenceImpl = void 0;
 class StorageReferenceImpl {
     constructor(path, storage) {
         this.path = path;
@@ -12,9 +12,41 @@ class StorageReferenceImpl {
     async getDownloadURL() {
         return this.storage.getDownloadURL(this.path);
     }
+    async delete() {
+        return this.storage.deleteFile(this.path);
+    }
 }
 exports.StorageReferenceImpl = StorageReferenceImpl;
 const storageRef = (storage, path) => {
     return new StorageReferenceImpl(path, storage);
 };
 exports.storageRef = storageRef;
+const ref = (storage, path) => {
+    return new StorageReferenceImpl(path, storage);
+};
+exports.ref = ref;
+const uploadBytes = async (storageRef, file, options) => {
+    if (storageRef.upload) {
+        return storageRef.upload(file, options);
+    }
+    throw new Error('Invalid storage reference');
+};
+exports.uploadBytes = uploadBytes;
+const uploadBytesResumable = (storageRef, file, options) => {
+    return (0, exports.uploadBytes)(storageRef, file, options);
+};
+exports.uploadBytesResumable = uploadBytesResumable;
+const getDownloadURL = async (storageRef) => {
+    if (storageRef.getDownloadURL) {
+        return storageRef.getDownloadURL();
+    }
+    throw new Error('Invalid storage reference');
+};
+exports.getDownloadURL = getDownloadURL;
+const deleteObject = async (storageRef) => {
+    if (storageRef.delete) {
+        return storageRef.delete();
+    }
+    throw new Error('Invalid storage reference');
+};
+exports.deleteObject = deleteObject;

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import type { NexaApp } from '../app/NexaApp';
 import type { FieldPath } from '../firestore/FieldPath';
+import type { User } from '../auth/authTypes';
 export interface NexaConfig {
     projectId: string;
     apiKey?: string;
@@ -7,14 +8,6 @@ export interface NexaConfig {
     enablePersistence?: boolean;
     cacheStrategy?: 'network-first' | 'cache-first';
 }
-export interface User {
-    id: string;
-    email: string;
-    name?: string;
-    role?: string;
-    createdAt?: string;
-    [key: string]: any;
-}
 export interface AuthResponse {
     token: string;
     user: User;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexabase-console",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "SDK Client resmi untuk NexaBase: Platform Sinkronisasi NoSQL, Realtime, File Storage, & Autentikasi Offline-First.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",