@techfinityedge/koolbase-react-native 2.3.0 → 3.0.0

package/README.md

@@ -16,9 +16,9 @@ Auth, database, storage, realtime, functions, feature flags, remote config, vers
 3. Add the SDK:
 
 ```bash
-npm install @techfinityedge/koolbase-react-native@^2.0.0
+npm install @techfinityedge/koolbase-react-native@^3.0.0
 # or
-yarn add @techfinityedge/koolbase-react-native@^2.0.0
+yarn add @techfinityedge/koolbase-react-native@^3.0.0
 ```
 
 **4. Initialize at app startup:**
@@ -36,6 +36,13 @@ That's it. Every feature below is now available via `Koolbase.*`.
 
 ---
 
+> **Auth is automatic (v3+).** Database, storage, and functions calls
+> authenticate as the currently signed-in user — nothing to pass, no manual
+> wiring. Log in (or restore a session) and every request carries that
+> identity. `owner`/`authenticated` collections require an active session.
+
+---
+
 ## Authentication
 
 Email + password, Apple Sign-In, Google Sign-In, and phone + OTP — out of the box.
@@ -323,6 +330,30 @@ Koolbase.codePush.applyDirectives();
 
 ---
 
+### Mandatory updates
+
+Mark a bundle **mandatory** in the dashboard (or via `PATCH /mandatory`) when every device must apply it before continuing — surfaced as a push callback and a pollable flag:
+
+```typescript
+await Koolbase.initialize({
+  publicKey: 'pk_live_xxxx',
+  baseUrl: 'https://api.koolbase.com',
+  // Fires the moment a mandatory bundle is staged for the next launch
+  onMandatoryUpdate: ({ version }) => {
+    showRestartRequiredDialog(version);
+  },
+});
+
+// Or poll it — e.g. on app resume — before letting the user proceed
+if (Koolbase.codePush.hasMandatoryUpdate) {
+  showRestartRequiredDialog();
+}
+```
+
+A mandatory bundle still activates on the next cold launch like any other; the callback and flag just let you prompt the user to restart now instead of waiting.
+
+---
+
 ## Logic Engine
 
 Define conditional app behavior as data in your Runtime Bundle — no code changes required.
@@ -442,7 +473,7 @@ try {
 
 ## What's included
 
-- Authentication: email + password, Apple Sign-In, phone + OTP
+- Authentication: email + password, Apple Sign-In, Google Sign-In, phone + OTP
 - Database with offline-first cache, realtime subscriptions, and populate
 - Storage with download URLs
 - Realtime subscriptions over WebSocket

package/dist/auth.d.ts

@@ -132,6 +132,14 @@ export declare class KoolbaseAuth {
     unlock(token: string): Promise<void>;
     get currentUser(): KoolbaseUser | null;
     get accessToken(): string | null;
+    /**
+     * Currently-valid access token for data-plane requests, refreshing
+     * (via refresh()) if the cached one is near expiry. Returns null when no
+     * session exists or refresh fails — callers then go api-key-only and the
+     * server treats it as having no end-user identity. The db/storage/functions
+     * clients pull from this per request so identity follows the live session.
+     */
+    validAccessToken(): Promise<string | null>;
     setSession(session: KoolbaseSession | null): Promise<void>;
     /**
      * @deprecated v1.9.0: Server endpoint /v1/sdk/auth/oauth not yet

package/dist/auth.js

@@ -497,6 +497,23 @@ class KoolbaseAuth {
     get accessToken() {
         return this.session?.accessToken ?? null;
     }
+    /**
+     * Currently-valid access token for data-plane requests, refreshing
+     * (via refresh()) if the cached one is near expiry. Returns null when no
+     * session exists or refresh fails — callers then go api-key-only and the
+     * server treats it as having no end-user identity. The db/storage/functions
+     * clients pull from this per request so identity follows the live session.
+     */
+    async validAccessToken() {
+        if (!this.session)
+            return null;
+        try {
+            return await this._ensureValidToken();
+        }
+        catch {
+            return null;
+        }
+    }
     async setSession(session) {
         if (session) {
             await this.setSessionInternal(session);

package/dist/code-push.d.ts

@@ -23,11 +23,13 @@ export interface BundleManifest {
     signature: string;
     size_bytes: number;
     payload: BundlePayload;
+    mandatory?: boolean;
 }
 export declare class KoolbaseCodePush {
     private config;
     private channel;
     private activeManifest;
+    private mandatoryPending;
     constructor(config: KoolbaseConfig, channel?: string);
     init(options: {
         appVersion: string;
@@ -40,6 +42,12 @@ export declare class KoolbaseCodePush {
     private download;
     private handleRollback;
     get hasActiveBundle(): boolean;
+    /**
+     * True when a mandatory bundle has been staged this session and is awaiting
+     * application (it activates on the next cold launch). Gate your UI on this to
+     * prompt the user to restart so the required update takes effect.
+     */
+    get hasMandatoryUpdate(): boolean;
     get manifest(): BundleManifest | null;
     getBundleConfig(key: string): unknown | undefined;
     getBundleFlag(key: string): boolean | undefined;

package/dist/code-push.js

@@ -72,6 +72,7 @@ async function extractManifestFromZip(data) {
 class KoolbaseCodePush {
     constructor(config, channel = 'stable') {
         this.activeManifest = null;
+        this.mandatoryPending = false;
         // ─── Directive handling ──────────────────────────────────────────────────
         this.directiveHandlers = new Map();
         this.config = config;
@@ -178,9 +179,21 @@ class KoolbaseCodePush {
                 console.warn('[KoolbaseCodePush] manifest extraction failed');
                 return;
             }
+            // Carry the mandatory flag from the check response onto the staged manifest
+            manifest.mandatory = ref.mandatory;
             // Store as pending — activates on next launch
             await async_storage_1.default.setItem(STORAGE_KEY_PENDING, JSON.stringify(manifest));
             console.log(`[KoolbaseCodePush] bundle v${manifest.version} ready for next launch`);
+            if (ref.mandatory) {
+                this.mandatoryPending = true;
+                console.log('[KoolbaseCodePush] staged bundle is mandatory — notifying app');
+                try {
+                    this.config.onMandatoryUpdate?.({ version: manifest.version, bundleId: manifest.bundle_id });
+                }
+                catch (cbErr) {
+                    console.warn('[KoolbaseCodePush] onMandatoryUpdate handler threw:', cbErr);
+                }
+            }
         }
         catch (e) {
             console.warn('[KoolbaseCodePush] download error:', e);
@@ -197,6 +210,14 @@ class KoolbaseCodePush {
     get hasActiveBundle() {
         return this.activeManifest !== null;
     }
+    /**
+     * True when a mandatory bundle has been staged this session and is awaiting
+     * application (it activates on the next cold launch). Gate your UI on this to
+     * prompt the user to restart so the required update takes effect.
+     */
+    get hasMandatoryUpdate() {
+        return this.mandatoryPending;
+    }
     get manifest() {
         return this.activeManifest;
     }

package/dist/database.d.ts

@@ -2,9 +2,10 @@ import { KoolbaseConfig, KoolbaseRecord, QueryOptions, QueryResult, UpsertResult
 export declare class KoolbaseDatabase {
     private config;
     private getUserId;
+    private getToken;
     private syncEngine;
-    constructor(config: KoolbaseConfig, getUserId: () => string | null);
-    private get headers();
+    constructor(config: KoolbaseConfig, getUserId: () => string | null, getToken: () => Promise<string | null>);
+    private buildHeaders;
     private request;
     private runQuery;
     query(collection: string, options?: QueryOptions): Promise<QueryResult>;

package/dist/database.js

@@ -9,24 +9,27 @@ function generateId() {
     return 'local_' + Math.random().toString(36).slice(2) + Date.now().toString(36);
 }
 class KoolbaseDatabase {
-    constructor(config, getUserId) {
+    constructor(config, getUserId, getToken) {
         this.config = config;
         this.getUserId = getUserId;
-        this.syncEngine = new sync_engine_1.SyncEngine(config, getUserId);
+        this.getToken = getToken;
+        this.syncEngine = new sync_engine_1.SyncEngine(config, getUserId, getToken);
         this.syncEngine.start();
     }
-    get headers() {
-        const userId = this.getUserId();
+    // getUserId is kept only for local cache keys / offline metadata; request
+    // identity now comes solely from the verified access token.
+    async buildHeaders() {
+        const token = await this.getToken();
         return {
             'Content-Type': 'application/json',
             'x-api-key': this.config.publicKey,
-            ...(userId ? { 'x-user-id': userId } : {}),
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
         };
     }
     async request(method, path, body) {
         const res = await fetch(`${this.config.baseUrl}${path}`, {
             method,
-            headers: this.headers,
+            headers: await this.buildHeaders(),
             body: body ? JSON.stringify(body) : undefined,
         });
         const data = await res.json();
@@ -117,7 +120,7 @@ class KoolbaseDatabase {
     async upsert(collection, match, data) {
         const res = await fetch(`${this.config.baseUrl}/v1/sdk/db/upsert`, {
             method: 'POST',
-            headers: this.headers,
+            headers: await this.buildHeaders(),
             body: JSON.stringify({ collection, match, data }),
         });
         const body = await res.json();
@@ -146,7 +149,7 @@ class KoolbaseDatabase {
     async deleteWhere(collection, filters) {
         const res = await fetch(`${this.config.baseUrl}/v1/sdk/db/delete-where`, {
             method: 'POST',
-            headers: this.headers,
+            headers: await this.buildHeaders(),
             body: JSON.stringify({ collection, filters }),
         });
         const body = await res.json();
@@ -194,7 +197,7 @@ class KoolbaseDatabase {
             recordId,
         });
         // Try network
-        const res = await fetch(`${this.config.baseUrl}/v1/sdk/db/records/${recordId}`, { method: 'DELETE', headers: this.headers });
+        const res = await fetch(`${this.config.baseUrl}/v1/sdk/db/records/${recordId}`, { method: 'DELETE', headers: await this.buildHeaders(), });
         if (!res.ok && res.status !== 204) {
             // Queued for sync — will retry when online
         }

package/dist/functions.d.ts

@@ -2,7 +2,7 @@ import { KoolbaseConfig, FunctionInvokeResult, DeployOptions, DeployResult } fro
 export declare class KoolbaseFunctions {
     private config;
     private getUserAccessToken?;
-    constructor(config: KoolbaseConfig, getUserAccessToken?: () => string | null);
+    constructor(config: KoolbaseConfig, getUserAccessToken?: () => Promise<string | null>);
     deploy(options: DeployOptions): Promise<DeployResult>;
     invoke(name: string, body?: Record<string, unknown>): Promise<FunctionInvokeResult>;
 }

package/dist/functions.js

@@ -45,7 +45,7 @@ class KoolbaseFunctions {
             'Content-Type': 'application/json',
             'x-api-key': this.config.publicKey,
         };
-        const userToken = this.getUserAccessToken?.();
+        const userToken = await this.getUserAccessToken?.();
         if (userToken) {
             headers['Authorization'] = `Bearer ${userToken}`;
         }

package/dist/index.js

@@ -67,10 +67,10 @@ exports.Koolbase = {
         if (_initialized)
             return;
         _auth = new auth_1.KoolbaseAuth(config);
-        _db = new database_1.KoolbaseDatabase(config, () => _auth?.currentUser?.id ?? null);
-        _storage = new storage_1.KoolbaseStorage(config, () => _auth?.accessToken ?? null);
+        _db = new database_1.KoolbaseDatabase(config, () => _auth?.currentUser?.id ?? null, () => _auth?.validAccessToken() ?? Promise.resolve(null));
+        _storage = new storage_1.KoolbaseStorage(config, () => _auth?.validAccessToken() ?? Promise.resolve(null));
         _realtime = new realtime_1.KoolbaseRealtime(config);
-        _functions = new functions_1.KoolbaseFunctions(config, () => _auth?.accessToken ?? null);
+        _functions = new functions_1.KoolbaseFunctions(config, () => _auth?.validAccessToken() ?? Promise.resolve(null));
         _flags = new flags_1.KoolbaseFlags(config, 'rn-device');
         _codePush = new code_push_1.KoolbaseCodePush(config, config.codePushChannel ?? 'stable');
         // Initialize code push — loads cached bundle then checks in background

package/dist/storage.d.ts

@@ -2,8 +2,8 @@ import { KoolbaseConfig, UploadOptions } from './types';
 export declare class KoolbaseStorage {
     private config;
     private getToken;
-    constructor(config: KoolbaseConfig, getToken: () => string | null);
-    private get headers();
+    constructor(config: KoolbaseConfig, getToken: () => Promise<string | null>);
+    private buildHeaders;
     upload(options: UploadOptions): Promise<{
         url: string;
     }>;

package/dist/storage.js

@@ -6,8 +6,8 @@ class KoolbaseStorage {
         this.config = config;
         this.getToken = getToken;
     }
-    get headers() {
-        const token = this.getToken();
+    async buildHeaders() {
+        const token = await this.getToken();
         return {
             'x-api-key': this.config.publicKey,
             ...(token ? { Authorization: `Bearer ${token}` } : {}),
@@ -17,7 +17,7 @@ class KoolbaseStorage {
         // Get presigned upload URL
         const res = await fetch(`${this.config.baseUrl}/v1/sdk/storage/${options.bucket}/upload`, {
             method: 'POST',
-            headers: { ...this.headers, 'Content-Type': 'application/json' },
+            headers: { ...(await this.buildHeaders()), 'Content-Type': 'application/json' },
             body: JSON.stringify({
                 path: options.path,
                 content_type: options.file.type,
@@ -39,7 +39,7 @@ class KoolbaseStorage {
         return { url: public_url };
     }
     async getDownloadUrl(bucket, path) {
-        const res = await fetch(`${this.config.baseUrl}/v1/sdk/storage/${bucket}/download?path=${encodeURIComponent(path)}`, { headers: this.headers });
+        const res = await fetch(`${this.config.baseUrl}/v1/sdk/storage/${bucket}/download?path=${encodeURIComponent(path)}`, { headers: await this.buildHeaders() });
         if (!res.ok) {
             const data = await res.json();
             throw new Error(data.error ?? 'Failed to get download URL');
@@ -50,7 +50,7 @@ class KoolbaseStorage {
     async delete(bucket, path) {
         const res = await fetch(`${this.config.baseUrl}/v1/sdk/storage/${bucket}/delete`, {
             method: 'DELETE',
-            headers: { ...this.headers, 'Content-Type': 'application/json' },
+            headers: { ...(await this.buildHeaders()), 'Content-Type': 'application/json' },
             body: JSON.stringify({ path }),
         });
         if (!res.ok && res.status !== 204) {

package/dist/sync-engine.d.ts

@@ -3,10 +3,11 @@ type SyncCallback = () => void;
 export declare class SyncEngine {
     private config;
     private getUserId;
+    private getToken;
     private onSyncComplete?;
     private unsubscribe?;
     private isSyncing;
-    constructor(config: KoolbaseConfig, getUserId: () => string | null, onSyncComplete?: SyncCallback);
+    constructor(config: KoolbaseConfig, getUserId: () => string | null, getToken: () => Promise<string | null>, onSyncComplete?: SyncCallback);
     start(): void;
     stop(): void;
     flush(): Promise<void>;

package/dist/sync-engine.js

@@ -7,10 +7,11 @@ exports.SyncEngine = void 0;
 const netinfo_1 = __importDefault(require("@react-native-community/netinfo"));
 const cache_store_1 = require("./cache-store");
 class SyncEngine {
-    constructor(config, getUserId, onSyncComplete) {
+    constructor(config, getUserId, getToken, onSyncComplete) {
         this.isSyncing = false;
         this.config = config;
         this.getUserId = getUserId;
+        this.getToken = getToken;
         this.onSyncComplete = onSyncComplete;
     }
     start() {
@@ -50,9 +51,11 @@ class SyncEngine {
         }
     }
     async executeWrite(write) {
+        const token = await this.getToken();
         const headers = {
             'Content-Type': 'application/json',
             'x-api-key': this.config.publicKey,
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
         };
         if (write.type === 'insert') {
             const res = await fetch(`${this.config.baseUrl}/v1/sdk/db/insert`, {

package/dist/types.d.ts

@@ -2,6 +2,10 @@ export interface KoolbaseConfig {
     publicKey: string;
     baseUrl: string;
     codePushChannel?: string;
+    onMandatoryUpdate?: (info: {
+        version: number;
+        bundleId: string;
+    }) => void;
     analyticsEnabled?: boolean;
     appVersion?: string;
     messagingEnabled?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techfinityedge/koolbase-react-native",
-  "version": "2.3.0",
+  "version": "3.0.0",
   "description": "React Native SDK for Koolbase \u2014 auth, database, storage, realtime, feature flags, and functions in one package.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",