@koolbase/react-native 9.2.0 → 10.0.1

package/dist/{auth-storage.d.ts → cjs/auth-storage.d.ts}

@@ -1,4 +1,4 @@
-import { KoolbaseAuthStorage, KoolbaseSession } from './types';
+import type { KoolbaseAuthStorage, KoolbaseSession } from '@koolbase/core';
 /**
  * Probe whether react-native-keychain is installed without throwing.
  * Used by KoolbaseAuth to decide whether to instantiate a default

package/dist/cjs/index.d.ts

@@ -0,0 +1,19 @@
+export * from '@koolbase/core';
+export { reactNativePlatform } from './platform.js';
+import { KoolbaseAuth, KoolbaseDatabase, KoolbaseStorage, KoolbaseRealtime, KoolbaseFunctions, KoolbaseAnalytics, KoolbaseMessaging, type KoolbaseConfig, type VersionCheckResult } from '@koolbase/core';
+export declare const Koolbase: {
+    initialize(config: KoolbaseConfig): Promise<void>;
+    readonly auth: KoolbaseAuth;
+    readonly db: KoolbaseDatabase;
+    readonly storage: KoolbaseStorage;
+    readonly realtime: KoolbaseRealtime;
+    readonly functions: KoolbaseFunctions;
+    isEnabled(key: string): boolean;
+    configString(key: string, fallback?: string): string;
+    configNumber(key: string, fallback?: number): number;
+    configBool(key: string, fallback?: boolean): boolean;
+    readonly analytics: KoolbaseAnalytics;
+    readonly messaging: KoolbaseMessaging;
+    checkVersion(currentVersion: string): VersionCheckResult;
+};
+export { SecureAuthStorage } from './auth-storage.js';

package/dist/cjs/index.js

@@ -0,0 +1,125 @@
+"use strict";
+// @koolbase/react-native — composes @koolbase/core for a React Native host.
+//
+// Everything the core exports is re-exported here unchanged, so an app that
+// installed this package before the split sees the same surface. What this
+// file adds is the composition: one Koolbase singleton, initialized with the
+// React Native platform adapter and keychain-backed session storage.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecureAuthStorage = exports.Koolbase = exports.reactNativePlatform = void 0;
+__exportStar(require("@koolbase/core"), exports);
+var platform_js_1 = require("./platform.js");
+Object.defineProperty(exports, "reactNativePlatform", { enumerable: true, get: function () { return platform_js_1.reactNativePlatform; } });
+const core_1 = require("@koolbase/core");
+const platform_js_2 = require("./platform.js");
+let _auth = null;
+let _db = null;
+let _storage = null;
+let _realtime = null;
+let _functions = null;
+let _flags = null;
+let _analytics = null;
+let _messaging = null;
+let _initialized = false;
+function ensureInitialized() {
+    if (!_initialized) {
+        throw new Error('Koolbase not initialized. Call Koolbase.initialize() first.');
+    }
+}
+exports.Koolbase = {
+    async initialize(config) {
+        if (_initialized)
+            return;
+        // The host platform, installed before any subsystem touches storage or
+        // the network. Tests leave this unset and run on the in-memory default.
+        (0, core_1.setPlatform)(config.platform ?? (0, platform_js_2.reactNativePlatform)());
+        _auth = new core_1.KoolbaseAuth(config);
+        _db = new core_1.KoolbaseDatabase(config, () => _auth?.currentUser?.id ?? null, () => _auth?.validAccessToken() ?? Promise.resolve(null), 
+        // A session the server refuses is not a session. Clearing it here means an
+        // app catching KoolbaseUnauthenticatedError is already signed out and can
+        // route to login, rather than looping on a dead token.
+        async () => { await _auth?.clearStoredSession(); });
+        _storage = new core_1.KoolbaseStorage(config, () => _auth?.validAccessToken() ?? Promise.resolve(null), async () => { await _auth?.clearStoredSession(); });
+        _realtime = new core_1.KoolbaseRealtime(config, () => _auth?.validAccessToken() ?? Promise.resolve(null), () => _auth?.currentUser?.id ?? null);
+        _functions = new core_1.KoolbaseFunctions(config, () => _auth?.validAccessToken() ?? Promise.resolve(null), async () => { await _auth?.clearStoredSession(); });
+        // One anonymous device id for the whole SDK — bucketing (flags), targeting
+        // (code push), and registration keying (messaging) must all agree on it.
+        const deviceId = await (0, core_1.getOrCreateDeviceId)();
+        _flags = new core_1.KoolbaseFlags(config, deviceId);
+        // Initialize analytics
+        if (config.analyticsEnabled !== false) {
+            _analytics = new core_1.KoolbaseAnalytics(config);
+            await _analytics.init(config.appVersion);
+        }
+        // Initialize messaging
+        if (config.messagingEnabled !== false) {
+            _messaging = new core_1.KoolbaseMessaging(config);
+            _messaging.setDeviceId(deviceId);
+        }
+        _initialized = true;
+    },
+    get auth() {
+        ensureInitialized();
+        return _auth;
+    },
+    get db() {
+        ensureInitialized();
+        return _db;
+    },
+    get storage() {
+        ensureInitialized();
+        return _storage;
+    },
+    get realtime() {
+        ensureInitialized();
+        return _realtime;
+    },
+    get functions() {
+        ensureInitialized();
+        return _functions;
+    },
+    isEnabled(key) {
+        ensureInitialized();
+        return _flags.isEnabled(key);
+    },
+    configString(key, fallback = '') {
+        ensureInitialized();
+        return _flags.getString(key, fallback);
+    },
+    configNumber(key, fallback = 0) {
+        ensureInitialized();
+        return _flags.getNumber(key, fallback);
+    },
+    configBool(key, fallback = false) {
+        ensureInitialized();
+        return _flags.getBool(key, fallback);
+    },
+    get analytics() {
+        ensureInitialized();
+        return _analytics;
+    },
+    get messaging() {
+        ensureInitialized();
+        return _messaging;
+    },
+    checkVersion(currentVersion) {
+        ensureInitialized();
+        return _flags.checkVersion(currentVersion);
+    },
+};
+var auth_storage_js_1 = require("./auth-storage.js");
+Object.defineProperty(exports, "SecureAuthStorage", { enumerable: true, get: function () { return auth_storage_js_1.SecureAuthStorage; } });

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/platform.d.ts

@@ -0,0 +1,2 @@
+import type { PlatformAdapter } from '@koolbase/core';
+export declare function reactNativePlatform(): PlatformAdapter;

package/dist/cjs/platform.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactNativePlatform = reactNativePlatform;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const netinfo_1 = __importDefault(require("@react-native-community/netinfo"));
+const react_native_1 = require("react-native");
+const auth_storage_js_1 = require("./auth-storage.js");
+// The React Native host, expressed through the platform seam. This is the
+// only file in the package that imports a native module; everything the SDK
+// does with storage, connectivity, lifecycle or platform identity goes
+// through the adapter it returns.
+function reactNativePlatform() {
+    return {
+        storage: {
+            getItem: (k) => async_storage_1.default.getItem(k),
+            setItem: (k, v) => async_storage_1.default.setItem(k, v),
+            removeItem: (k) => async_storage_1.default.removeItem(k),
+            getAllKeys: async () => Array.from(await async_storage_1.default.getAllKeys()),
+        },
+        network: {
+            onChange: (cb) => netinfo_1.default.addEventListener(state => {
+                cb(Boolean(state.isConnected) && state.isInternetReachable !== false);
+            }),
+        },
+        lifecycle: {
+            onBackground: (cb) => {
+                const sub = react_native_1.AppState.addEventListener('change', (state) => {
+                    if (state === 'background' || state === 'inactive')
+                        cb();
+                });
+                return () => sub.remove();
+            },
+        },
+        info: {
+            os: String(react_native_1.Platform.OS),
+            version: String(react_native_1.Platform.Version),
+        },
+        authStorage: () => ((0, auth_storage_js_1.isKeychainAvailable)() ? new auth_storage_js_1.SecureAuthStorage() : null),
+    };
+}

package/dist/esm/auth-storage.d.ts

@@ -0,0 +1,26 @@
+import type { KoolbaseAuthStorage, KoolbaseSession } from '@koolbase/core';
+/**
+ * Probe whether react-native-keychain is installed without throwing.
+ * Used by KoolbaseAuth to decide whether to instantiate a default
+ * SecureAuthStorage or proceed without persistence.
+ */
+export declare function isKeychainAvailable(): boolean;
+/**
+ * Default secure storage implementation backed by `react-native-keychain`.
+ *
+ * - iOS: Keychain (encrypted, never synced via iCloud by default)
+ * - Android: Android Keystore-backed encryption
+ *
+ * Requires `react-native-keychain` as a peer dependency. Apps that prefer a
+ * different secure backend (e.g. `expo-secure-store`,
+ * `react-native-encrypted-storage`, an in-memory mock for testing, or a
+ * compliance-grade encryption layer) should implement the
+ * {@link KoolbaseAuthStorage} interface and pass it via
+ * `KoolbaseConfig.authStorage`.
+ */
+export declare class SecureAuthStorage implements KoolbaseAuthStorage {
+    private static readonly SERVICE;
+    saveSession(session: KoolbaseSession): Promise<void>;
+    readSession(): Promise<KoolbaseSession | null>;
+    clear(): Promise<void>;
+}

package/dist/esm/auth-storage.js

@@ -0,0 +1,100 @@
+// Lazy-load react-native-keychain so apps without it installed (e.g. Expo Go,
+// or those providing a custom adapter) can still import this module without
+// crashing. The default SecureAuthStorage will throw a clear error on first
+// use if the peer dependency is missing.
+let _keychain = null;
+let _keychainAttempted = false;
+function loadKeychain() {
+    if (!_keychainAttempted) {
+        _keychainAttempted = true;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            _keychain = require('react-native-keychain');
+        }
+        catch {
+            _keychain = null;
+        }
+    }
+    if (!_keychain) {
+        throw new Error('[Koolbase] SecureAuthStorage requires react-native-keychain. ' +
+            'Install it with:\n  npm install react-native-keychain\n' +
+            'Or provide your own storage adapter via ' +
+            'KoolbaseConfig.authStorage. For Expo Go (where ' +
+            'react-native-keychain is unavailable), implement KoolbaseAuthStorage ' +
+            'with expo-secure-store and pass it via authStorage.');
+    }
+    return _keychain;
+}
+/**
+ * Probe whether react-native-keychain is installed without throwing.
+ * Used by KoolbaseAuth to decide whether to instantiate a default
+ * SecureAuthStorage or proceed without persistence.
+ */
+export function isKeychainAvailable() {
+    if (!_keychainAttempted) {
+        _keychainAttempted = true;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            _keychain = require('react-native-keychain');
+        }
+        catch {
+            _keychain = null;
+        }
+    }
+    return _keychain !== null;
+}
+/**
+ * Default secure storage implementation backed by `react-native-keychain`.
+ *
+ * - iOS: Keychain (encrypted, never synced via iCloud by default)
+ * - Android: Android Keystore-backed encryption
+ *
+ * Requires `react-native-keychain` as a peer dependency. Apps that prefer a
+ * different secure backend (e.g. `expo-secure-store`,
+ * `react-native-encrypted-storage`, an in-memory mock for testing, or a
+ * compliance-grade encryption layer) should implement the
+ * {@link KoolbaseAuthStorage} interface and pass it via
+ * `KoolbaseConfig.authStorage`.
+ */
+export class SecureAuthStorage {
+    async saveSession(session) {
+        const Keychain = loadKeychain();
+        await Keychain.setGenericPassword('session', JSON.stringify(session), { service: SecureAuthStorage.SERVICE });
+    }
+    async readSession() {
+        let Keychain;
+        try {
+            Keychain = loadKeychain();
+        }
+        catch {
+            // Peer dep missing — caller will fall back to no persistence.
+            return null;
+        }
+        try {
+            const credentials = await Keychain.getGenericPassword({
+                service: SecureAuthStorage.SERVICE,
+            });
+            if (!credentials || !credentials.password)
+                return null;
+            return JSON.parse(credentials.password);
+        }
+        catch {
+            // Corrupt data, schema mismatch, or platform-level keychain error.
+            // Treat as no session — caller will trigger fresh login.
+            return null;
+        }
+    }
+    async clear() {
+        let Keychain;
+        try {
+            Keychain = loadKeychain();
+        }
+        catch {
+            return; // No-op if peer dep missing.
+        }
+        await Keychain.resetGenericPassword({
+            service: SecureAuthStorage.SERVICE,
+        });
+    }
+}
+SecureAuthStorage.SERVICE = 'koolbase_session_v1';

package/dist/esm/index.d.ts

@@ -0,0 +1,19 @@
+export * from '@koolbase/core';
+export { reactNativePlatform } from './platform.js';
+import { KoolbaseAuth, KoolbaseDatabase, KoolbaseStorage, KoolbaseRealtime, KoolbaseFunctions, KoolbaseAnalytics, KoolbaseMessaging, type KoolbaseConfig, type VersionCheckResult } from '@koolbase/core';
+export declare const Koolbase: {
+    initialize(config: KoolbaseConfig): Promise<void>;
+    readonly auth: KoolbaseAuth;
+    readonly db: KoolbaseDatabase;
+    readonly storage: KoolbaseStorage;
+    readonly realtime: KoolbaseRealtime;
+    readonly functions: KoolbaseFunctions;
+    isEnabled(key: string): boolean;
+    configString(key: string, fallback?: string): string;
+    configNumber(key: string, fallback?: number): number;
+    configBool(key: string, fallback?: boolean): boolean;
+    readonly analytics: KoolbaseAnalytics;
+    readonly messaging: KoolbaseMessaging;
+    checkVersion(currentVersion: string): VersionCheckResult;
+};
+export { SecureAuthStorage } from './auth-storage.js';

package/dist/esm/index.js

@@ -0,0 +1,106 @@
+// @koolbase/react-native — composes @koolbase/core for a React Native host.
+//
+// Everything the core exports is re-exported here unchanged, so an app that
+// installed this package before the split sees the same surface. What this
+// file adds is the composition: one Koolbase singleton, initialized with the
+// React Native platform adapter and keychain-backed session storage.
+export * from '@koolbase/core';
+export { reactNativePlatform } from './platform.js';
+import { KoolbaseAuth, KoolbaseDatabase, KoolbaseStorage, KoolbaseRealtime, KoolbaseFunctions, KoolbaseFlags, KoolbaseAnalytics, KoolbaseMessaging, getOrCreateDeviceId, setPlatform, } from '@koolbase/core';
+import { reactNativePlatform } from './platform.js';
+let _auth = null;
+let _db = null;
+let _storage = null;
+let _realtime = null;
+let _functions = null;
+let _flags = null;
+let _analytics = null;
+let _messaging = null;
+let _initialized = false;
+function ensureInitialized() {
+    if (!_initialized) {
+        throw new Error('Koolbase not initialized. Call Koolbase.initialize() first.');
+    }
+}
+export const Koolbase = {
+    async initialize(config) {
+        if (_initialized)
+            return;
+        // The host platform, installed before any subsystem touches storage or
+        // the network. Tests leave this unset and run on the in-memory default.
+        setPlatform(config.platform ?? reactNativePlatform());
+        _auth = new KoolbaseAuth(config);
+        _db = new KoolbaseDatabase(config, () => _auth?.currentUser?.id ?? null, () => _auth?.validAccessToken() ?? Promise.resolve(null), 
+        // A session the server refuses is not a session. Clearing it here means an
+        // app catching KoolbaseUnauthenticatedError is already signed out and can
+        // route to login, rather than looping on a dead token.
+        async () => { await _auth?.clearStoredSession(); });
+        _storage = new KoolbaseStorage(config, () => _auth?.validAccessToken() ?? Promise.resolve(null), async () => { await _auth?.clearStoredSession(); });
+        _realtime = new KoolbaseRealtime(config, () => _auth?.validAccessToken() ?? Promise.resolve(null), () => _auth?.currentUser?.id ?? null);
+        _functions = new KoolbaseFunctions(config, () => _auth?.validAccessToken() ?? Promise.resolve(null), async () => { await _auth?.clearStoredSession(); });
+        // One anonymous device id for the whole SDK — bucketing (flags), targeting
+        // (code push), and registration keying (messaging) must all agree on it.
+        const deviceId = await getOrCreateDeviceId();
+        _flags = new KoolbaseFlags(config, deviceId);
+        // Initialize analytics
+        if (config.analyticsEnabled !== false) {
+            _analytics = new KoolbaseAnalytics(config);
+            await _analytics.init(config.appVersion);
+        }
+        // Initialize messaging
+        if (config.messagingEnabled !== false) {
+            _messaging = new KoolbaseMessaging(config);
+            _messaging.setDeviceId(deviceId);
+        }
+        _initialized = true;
+    },
+    get auth() {
+        ensureInitialized();
+        return _auth;
+    },
+    get db() {
+        ensureInitialized();
+        return _db;
+    },
+    get storage() {
+        ensureInitialized();
+        return _storage;
+    },
+    get realtime() {
+        ensureInitialized();
+        return _realtime;
+    },
+    get functions() {
+        ensureInitialized();
+        return _functions;
+    },
+    isEnabled(key) {
+        ensureInitialized();
+        return _flags.isEnabled(key);
+    },
+    configString(key, fallback = '') {
+        ensureInitialized();
+        return _flags.getString(key, fallback);
+    },
+    configNumber(key, fallback = 0) {
+        ensureInitialized();
+        return _flags.getNumber(key, fallback);
+    },
+    configBool(key, fallback = false) {
+        ensureInitialized();
+        return _flags.getBool(key, fallback);
+    },
+    get analytics() {
+        ensureInitialized();
+        return _analytics;
+    },
+    get messaging() {
+        ensureInitialized();
+        return _messaging;
+    },
+    checkVersion(currentVersion) {
+        ensureInitialized();
+        return _flags.checkVersion(currentVersion);
+    },
+};
+export { SecureAuthStorage } from './auth-storage.js';

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/platform.d.ts

@@ -0,0 +1,2 @@
+import type { PlatformAdapter } from '@koolbase/core';
+export declare function reactNativePlatform(): PlatformAdapter;

package/dist/esm/platform.js

@@ -0,0 +1,37 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import NetInfo from '@react-native-community/netinfo';
+import { AppState, Platform } from 'react-native';
+import { SecureAuthStorage, isKeychainAvailable } from './auth-storage.js';
+// The React Native host, expressed through the platform seam. This is the
+// only file in the package that imports a native module; everything the SDK
+// does with storage, connectivity, lifecycle or platform identity goes
+// through the adapter it returns.
+export function reactNativePlatform() {
+    return {
+        storage: {
+            getItem: (k) => AsyncStorage.getItem(k),
+            setItem: (k, v) => AsyncStorage.setItem(k, v),
+            removeItem: (k) => AsyncStorage.removeItem(k),
+            getAllKeys: async () => Array.from(await AsyncStorage.getAllKeys()),
+        },
+        network: {
+            onChange: (cb) => NetInfo.addEventListener(state => {
+                cb(Boolean(state.isConnected) && state.isInternetReachable !== false);
+            }),
+        },
+        lifecycle: {
+            onBackground: (cb) => {
+                const sub = AppState.addEventListener('change', (state) => {
+                    if (state === 'background' || state === 'inactive')
+                        cb();
+                });
+                return () => sub.remove();
+            },
+        },
+        info: {
+            os: String(Platform.OS),
+            version: String(Platform.Version),
+        },
+        authStorage: () => (isKeychainAvailable() ? new SecureAuthStorage() : null),
+    };
+}

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@koolbase/react-native",
-  "version": "9.2.0",
+  "version": "10.0.1",
   "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",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/esm/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsc",
-    "prepare": "npm run build",
-    "test": "jest"
+    "build": "node ../../scripts/build-package.js react-native"
   },
   "keywords": [
     "koolbase",
@@ -19,40 +18,41 @@
     "firebase-alternative",
     "flutter"
   ],
-  "author": "Kennedy Owusu",
   "license": "MIT",
-  "homepage": "https://koolbase.com",
   "repository": {
     "type": "git",
     "url": "https://github.com/koolbase/koolbase-react-native"
   },
-  "devDependencies": {
-    "@types/jest": "^30.0.0",
-    "@types/jszip": "^3.4.0",
-    "@types/node": "^25.9.1",
-    "jest": "^30.4.2",
-    "react-native": "^0.85.3",
-    "react-native-keychain": "^10.0.0",
-    "ts-jest": "^29.4.12",
-    "typescript": "^5.0.0",
-    "@react-native-async-storage/async-storage": "^3.0.2",
-    "@react-native-community/netinfo": "^12.0.1"
+  "dependencies": {
+    "@koolbase/core": "10.0.1"
   },
   "peerDependencies": {
-    "react-native": ">=0.70.0",
-    "react-native-keychain": ">=8.0.0",
     "@react-native-async-storage/async-storage": "^3.0.2",
-    "@react-native-community/netinfo": "^12.0.1"
-  },
-  "dependencies": {
-    "jszip": "^3.10.1"
-  },
-  "publishConfig": {
-    "access": "public"
+    "@react-native-community/netinfo": "^12.0.1",
+    "react-native": ">=0.70.0",
+    "react-native-keychain": ">=8.0.0"
   },
   "peerDependenciesMeta": {
     "react-native-keychain": {
       "optional": true
     }
-  }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "module": "./dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false
 }

package/dist/analytics.d.ts

@@ -1,24 +0,0 @@
-import { KoolbaseConfig } from './types';
-export declare class KoolbaseAnalytics {
-    private config;
-    private queue;
-    private deviceId;
-    private userId?;
-    private environmentId?;
-    private userProperties;
-    private sessionId;
-    private appVersion;
-    private flushTimer?;
-    private initialized;
-    constructor(config: KoolbaseConfig);
-    init(appVersion?: string): Promise<void>;
-    track(eventName: string, properties?: Record<string, unknown>): void;
-    screenView(screenName: string, properties?: Record<string, unknown>): void;
-    identify(userId: string): void;
-    setUserProperty(key: string, value: unknown): void;
-    setUserProperties(properties: Record<string, unknown>): void;
-    setEnvironment(environmentId: string): void;
-    reset(): void;
-    flush(): Promise<void>;
-    dispose(): Promise<void>;
-}