@techfinityedge/koolbase-react-native 1.6.1

package/dist/cache-store.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashQuery = hashQuery;
+exports.getCached = getCached;
+exports.setCached = setCached;
+exports.invalidateCache = invalidateCache;
+exports.clearUserCache = clearUserCache;
+exports.getWriteQueue = getWriteQueue;
+exports.addToWriteQueue = addToWriteQueue;
+exports.removeFromWriteQueue = removeFromWriteQueue;
+exports.incrementWriteRetry = incrementWriteRetry;
+exports.optimisticallyInsert = optimisticallyInsert;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const CACHE_VERSION = 'v1';
+function cacheKey(userId, collection, queryHash) {
+    return `koolbase:${CACHE_VERSION}:${userId}:${collection}:${queryHash}`;
+}
+function writeQueueKey(userId) {
+    return `koolbase:${CACHE_VERSION}:${userId}:write_queue`;
+}
+function hashQuery(collection, options) {
+    return `${collection}:${JSON.stringify(options)}`;
+}
+// ─── Cache ──────────────────────────────────────────────────────────────────
+async function getCached(userId, collection, queryHash) {
+    try {
+        const raw = await async_storage_1.default.getItem(cacheKey(userId, collection, queryHash));
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function setCached(userId, collection, queryHash, result) {
+    try {
+        await async_storage_1.default.setItem(cacheKey(userId, collection, queryHash), JSON.stringify(result));
+    }
+    catch {
+        // ignore storage errors
+    }
+}
+async function invalidateCache(userId, collection) {
+    try {
+        const keys = await async_storage_1.default.getAllKeys();
+        const prefix = `koolbase:${CACHE_VERSION}:${userId}:${collection}:`;
+        const toDelete = keys.filter(k => k.startsWith(prefix));
+        for (const key of toDelete) {
+            await async_storage_1.default.removeItem(key);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+async function clearUserCache(userId) {
+    try {
+        const keys = await async_storage_1.default.getAllKeys();
+        const prefix = `koolbase:${CACHE_VERSION}:${userId}:`;
+        const toDelete = keys.filter(k => k.startsWith(prefix));
+        for (const key of toDelete) {
+            await async_storage_1.default.removeItem(key);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+// ─── Write Queue ────────────────────────────────────────────────────────────
+async function getWriteQueue(userId) {
+    try {
+        const raw = await async_storage_1.default.getItem(writeQueueKey(userId));
+        if (!raw)
+            return [];
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+async function addToWriteQueue(userId, write) {
+    try {
+        const queue = await getWriteQueue(userId);
+        queue.push({ ...write, retries: 0, createdAt: new Date().toISOString() });
+        await async_storage_1.default.setItem(writeQueueKey(userId), JSON.stringify(queue));
+    }
+    catch {
+        // ignore
+    }
+}
+async function removeFromWriteQueue(userId, writeId) {
+    try {
+        const queue = await getWriteQueue(userId);
+        const updated = queue.filter(w => w.id !== writeId);
+        await async_storage_1.default.setItem(writeQueueKey(userId), JSON.stringify(updated));
+    }
+    catch {
+        // ignore
+    }
+}
+async function incrementWriteRetry(userId, writeId) {
+    try {
+        const queue = await getWriteQueue(userId);
+        const updated = queue.map(w => w.id === writeId ? { ...w, retries: w.retries + 1 } : w);
+        // Drop writes that have exceeded 3 retries
+        const filtered = updated.filter(w => w.retries <= 3);
+        await async_storage_1.default.setItem(writeQueueKey(userId), JSON.stringify(filtered));
+    }
+    catch {
+        // ignore
+    }
+}
+// ─── Optimistic cache update ─────────────────────────────────────────────────
+async function optimisticallyInsert(userId, collection, record) {
+    try {
+        const keys = await async_storage_1.default.getAllKeys();
+        const prefix = `koolbase:${CACHE_VERSION}:${userId}:${collection}:`;
+        const collectionKeys = keys.filter(k => k.startsWith(prefix));
+        for (const key of collectionKeys) {
+            const raw = await async_storage_1.default.getItem(key);
+            if (!raw)
+                continue;
+            const cached = JSON.parse(raw);
+            cached.records = [record, ...cached.records];
+            cached.total = cached.total + 1;
+            await async_storage_1.default.setItem(key, JSON.stringify(cached));
+        }
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/code-push.d.ts

@@ -0,0 +1,51 @@
+import { KoolbaseConfig } from './types';
+export interface BundlePayload {
+    config: Record<string, unknown>;
+    flags: Record<string, boolean>;
+    directives: Record<string, unknown>;
+    assets: {
+        images: string[];
+        json: string[];
+        fonts: string[];
+    };
+    screens?: Record<string, string>;
+    flows?: Record<string, unknown>;
+}
+export interface BundleManifest {
+    bundle_id: string;
+    app_id: string;
+    version: number;
+    base_app_version: string;
+    max_app_version: string;
+    platform: string;
+    channel: string;
+    checksum: string;
+    signature: string;
+    size_bytes: number;
+    payload: BundlePayload;
+}
+export declare class KoolbaseCodePush {
+    private config;
+    private channel;
+    private activeManifest;
+    constructor(config: KoolbaseConfig, channel?: string);
+    init(options: {
+        appVersion: string;
+        platform: string;
+        deviceId: string;
+    }): Promise<void>;
+    private promotePendingIfAvailable;
+    private loadActive;
+    private checkInBackground;
+    private download;
+    private handleRollback;
+    get hasActiveBundle(): boolean;
+    get manifest(): BundleManifest | null;
+    getBundleConfig(key: string): unknown | undefined;
+    getBundleFlag(key: string): boolean | undefined;
+    getBundleDirective(key: string): unknown | undefined;
+    private directiveHandlers;
+    onDirective(key: string, handler: (value: unknown) => void): void;
+    applyDirectives(): void;
+    clearBundle(): Promise<void>;
+}

package/dist/code-push.js

@@ -0,0 +1,234 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoolbaseCodePush = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const STORAGE_KEY_ACTIVE = 'koolbase:codepush:active';
+const STORAGE_KEY_PENDING = 'koolbase:codepush:pending';
+// ─── Pure JS sha256 for checksum verification ────────────────────────────────
+async function sha256Hex(data) {
+    // Use SubtleCrypto if available (modern RN / Hermes)
+    if (typeof crypto !== 'undefined' && crypto.subtle) {
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    // Fallback — skip verification (dev only)
+    return '';
+}
+// ─── Zip manifest extraction ─────────────────────────────────────────────────
+async function extractManifestFromZip(data) {
+    try {
+        // Dynamically import JSZip — must be installed as a dependency
+        const JSZip = (await Promise.resolve().then(() => __importStar(require('jszip')))).default;
+        const zip = await JSZip.loadAsync(data);
+        const manifestFile = zip.file('manifest.json');
+        if (!manifestFile)
+            return null;
+        const json = await manifestFile.async('string');
+        return JSON.parse(json);
+    }
+    catch (e) {
+        console.warn('[KoolbaseCodePush] manifest extraction failed:', e);
+        return null;
+    }
+}
+// ─── KoolbaseCodePush ────────────────────────────────────────────────────────
+class KoolbaseCodePush {
+    constructor(config, channel = 'stable') {
+        this.activeManifest = null;
+        // ─── Directive handling ──────────────────────────────────────────────────
+        this.directiveHandlers = new Map();
+        this.config = config;
+        this.channel = channel;
+    }
+    // Called inside Koolbase.initialize() — loads cached bundle then checks in background
+    async init(options) {
+        // Step 1 — promote pending → active if available
+        await this.promotePendingIfAvailable();
+        // Step 2 — load active manifest into memory
+        this.activeManifest = await this.loadActive();
+        if (this.activeManifest) {
+            console.log(`[KoolbaseCodePush] bundle v${this.activeManifest.version} active`);
+        }
+        else {
+            console.log('[KoolbaseCodePush] no active bundle — using app defaults');
+        }
+        // Step 3 — check for updates in background (non-blocking)
+        this.checkInBackground(options);
+    }
+    async promotePendingIfAvailable() {
+        try {
+            const pending = await async_storage_1.default.getItem(STORAGE_KEY_PENDING);
+            if (!pending)
+                return;
+            // Archive current active → just overwrite, we keep one version
+            await async_storage_1.default.setItem(STORAGE_KEY_ACTIVE, pending);
+            await async_storage_1.default.removeItem(STORAGE_KEY_PENDING);
+            console.log('[KoolbaseCodePush] promoted pending bundle to active');
+        }
+        catch (e) {
+            console.warn('[KoolbaseCodePush] promotion failed:', e);
+            // One re-check will be triggered naturally by background check
+        }
+    }
+    async loadActive() {
+        try {
+            const stored = await async_storage_1.default.getItem(STORAGE_KEY_ACTIVE);
+            if (!stored)
+                return null;
+            return JSON.parse(stored);
+        }
+        catch {
+            return null;
+        }
+    }
+    checkInBackground(options) {
+        // Fire and forget
+        (async () => {
+            try {
+                const currentVersion = this.activeManifest?.version ?? 0;
+                const res = await fetch(`${this.config.baseUrl}/v1/code-push/check` +
+                    `?app_version=${options.appVersion}` +
+                    `&platform=${options.platform}` +
+                    `&channel=${this.channel}` +
+                    `&device_id=${options.deviceId}` +
+                    `&current_bundle=${currentVersion}`, { headers: { 'x-api-key': this.config.publicKey } });
+                if (!res.ok)
+                    return;
+                const body = await res.json();
+                switch (body.status) {
+                    case 'update_available':
+                        await this.download(body.bundle);
+                        break;
+                    case 'rollback':
+                        await this.handleRollback(body.revert_to ?? '0');
+                        break;
+                    case 'no_update':
+                        console.log('[KoolbaseCodePush] no update available');
+                        break;
+                }
+            }
+            catch (e) {
+                // Server unreachable — continue silently
+                console.log('[KoolbaseCodePush] check failed silently:', e);
+            }
+        })();
+    }
+    async download(ref) {
+        try {
+            console.log(`[KoolbaseCodePush] downloading bundle v${ref.version}...`);
+            const res = await fetch(ref.download_url);
+            if (!res.ok) {
+                console.warn('[KoolbaseCodePush] download failed:', res.status);
+                return;
+            }
+            const data = await res.arrayBuffer();
+            console.log(`[KoolbaseCodePush] downloaded ${data.byteLength} bytes`);
+            // Verify checksum
+            if (ref.checksum !== 'placeholder' && ref.checksum !== 'pending') {
+                const actual = `sha256:${await sha256Hex(data)}`;
+                if (actual !== ref.checksum && actual !== 'sha256:') {
+                    console.warn('[KoolbaseCodePush] checksum mismatch — bundle rejected');
+                    return;
+                }
+                console.log('[KoolbaseCodePush] checksum verified');
+            }
+            else {
+                console.log('[KoolbaseCodePush] checksum skipped (dev mode)');
+            }
+            // Extract manifest
+            const manifest = await extractManifestFromZip(data);
+            if (!manifest) {
+                console.warn('[KoolbaseCodePush] manifest extraction failed');
+                return;
+            }
+            // 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`);
+        }
+        catch (e) {
+            console.warn('[KoolbaseCodePush] download error:', e);
+        }
+    }
+    async handleRollback(revertTo) {
+        console.log(`[KoolbaseCodePush] rollback to v${revertTo}`);
+        await async_storage_1.default.removeItem(STORAGE_KEY_ACTIVE);
+        await async_storage_1.default.removeItem(STORAGE_KEY_PENDING);
+        this.activeManifest = null;
+        console.log('[KoolbaseCodePush] reverted to app defaults');
+    }
+    // ─── Public accessors ────────────────────────────────────────────────────
+    get hasActiveBundle() {
+        return this.activeManifest !== null;
+    }
+    get manifest() {
+        return this.activeManifest;
+    }
+    getBundleConfig(key) {
+        return this.activeManifest?.payload.config[key];
+    }
+    getBundleFlag(key) {
+        return this.activeManifest?.payload.flags[key];
+    }
+    getBundleDirective(key) {
+        return this.activeManifest?.payload.directives[key];
+    }
+    onDirective(key, handler) {
+        this.directiveHandlers.set(key, handler);
+    }
+    applyDirectives() {
+        if (!this.activeManifest?.payload.directives)
+            return;
+        for (const [key, value] of Object.entries(this.activeManifest.payload.directives)) {
+            const handler = this.directiveHandlers.get(key);
+            if (handler) {
+                console.log(`[KoolbaseCodePush] directive: ${key} = ${value}`);
+                handler(value);
+            }
+        }
+    }
+    // ─── Cache management ────────────────────────────────────────────────────
+    async clearBundle() {
+        await async_storage_1.default.removeItem(STORAGE_KEY_ACTIVE);
+        await async_storage_1.default.removeItem(STORAGE_KEY_PENDING);
+        this.activeManifest = null;
+        console.log('[KoolbaseCodePush] bundle cache cleared');
+    }
+}
+exports.KoolbaseCodePush = KoolbaseCodePush;

package/dist/database.d.ts

@@ -0,0 +1,15 @@
+import { KoolbaseConfig, KoolbaseRecord, QueryOptions, QueryResult } from './types';
+export declare class KoolbaseDatabase {
+    private config;
+    private getUserId;
+    private syncEngine;
+    constructor(config: KoolbaseConfig, getUserId: () => string | null);
+    private get headers();
+    private request;
+    query(collection: string, options?: QueryOptions): Promise<QueryResult>;
+    insert(collection: string, data: Record<string, unknown>): Promise<KoolbaseRecord>;
+    get(recordId: string): Promise<KoolbaseRecord>;
+    update(recordId: string, data: Record<string, unknown>): Promise<KoolbaseRecord>;
+    delete(recordId: string): Promise<void>;
+    syncPendingWrites(): Promise<void>;
+}

package/dist/database.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoolbaseDatabase = void 0;
+const cache_store_1 = require("./cache-store");
+const sync_engine_1 = require("./sync-engine");
+function generateId() {
+    return 'local_' + Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+class KoolbaseDatabase {
+    constructor(config, getUserId) {
+        this.config = config;
+        this.getUserId = getUserId;
+        this.syncEngine = new sync_engine_1.SyncEngine(config, getUserId);
+        this.syncEngine.start();
+    }
+    get headers() {
+        const userId = this.getUserId();
+        return {
+            'Content-Type': 'application/json',
+            'x-api-key': this.config.publicKey,
+            ...(userId ? { 'x-user-id': userId } : {}),
+        };
+    }
+    async request(method, path, body) {
+        const res = await fetch(`${this.config.baseUrl}${path}`, {
+            method,
+            headers: this.headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const data = await res.json();
+        if (!res.ok) {
+            throw new Error(data.error ?? `Request failed: ${res.status}`);
+        }
+        return data;
+    }
+    // ─── Query (cache-first) ───────────────────────────────────────────────────
+    async query(collection, options = {}) {
+        const userId = this.getUserId() ?? 'anonymous';
+        const queryHash = (0, cache_store_1.hashQuery)(collection, options);
+        // 1. Return cached data immediately if available
+        const cached = await (0, cache_store_1.getCached)(userId, collection, queryHash);
+        // 2. Fetch from network in background
+        this.request('POST', '/v1/sdk/db/query', {
+            collection,
+            filters: options.filters ?? {},
+            limit: options.limit ?? 20,
+            offset: options.offset ?? 0,
+            order_by: options.orderBy,
+            order_desc: options.orderDesc ?? false,
+            populate: options.populate ?? [],
+        })
+            .then(async (result) => {
+            await (0, cache_store_1.setCached)(userId, collection, queryHash, result);
+        })
+            .catch(() => {
+            // Network unavailable — cached data is already returned
+        });
+        if (cached) {
+            return { ...cached, isFromCache: true };
+        }
+        // No cache — wait for network
+        const result = await this.request('POST', '/v1/sdk/db/query', {
+            collection,
+            filters: options.filters ?? {},
+            limit: options.limit ?? 20,
+            offset: options.offset ?? 0,
+            order_by: options.orderBy,
+            order_desc: options.orderDesc ?? false,
+            populate: options.populate ?? [],
+        });
+        await (0, cache_store_1.setCached)(userId, collection, queryHash, result);
+        return { ...result, isFromCache: false };
+    }
+    // ─── Insert (optimistic) ────────────────────────────────────────────────────
+    async insert(collection, data) {
+        const userId = this.getUserId() ?? 'anonymous';
+        // Build optimistic record
+        const optimisticRecord = {
+            id: generateId(),
+            projectId: '',
+            collectionId: '',
+            createdBy: userId,
+            data,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        // Write to local cache immediately
+        await (0, cache_store_1.optimisticallyInsert)(userId, collection, optimisticRecord);
+        // Add to write queue
+        await (0, cache_store_1.addToWriteQueue)(userId, {
+            id: generateId(),
+            type: 'insert',
+            collection,
+            data,
+        });
+        // Try network in background
+        this.request('POST', '/v1/sdk/db/insert', {
+            collection,
+            data,
+        })
+            .then(async (serverRecord) => {
+            // Invalidate cache so next query gets real data
+            await (0, cache_store_1.invalidateCache)(userId, collection);
+        })
+            .catch(() => {
+            // Will sync when online via SyncEngine
+        });
+        return optimisticRecord;
+    }
+    // ─── Get single record ──────────────────────────────────────────────────────
+    async get(recordId) {
+        return this.request('GET', `/v1/sdk/db/records/${recordId}`);
+    }
+    // ─── Update ─────────────────────────────────────────────────────────────────
+    async update(recordId, data) {
+        const userId = this.getUserId() ?? 'anonymous';
+        // Add to write queue
+        await (0, cache_store_1.addToWriteQueue)(userId, {
+            id: generateId(),
+            type: 'update',
+            recordId,
+            data,
+        });
+        // Try network
+        try {
+            const result = await this.request('PATCH', `/v1/sdk/db/records/${recordId}`, { data });
+            return result;
+        }
+        catch {
+            // Return optimistic version
+            return {
+                id: recordId,
+                projectId: '',
+                collectionId: '',
+                data,
+                createdAt: '',
+                updatedAt: new Date().toISOString(),
+            };
+        }
+    }
+    // ─── Delete ─────────────────────────────────────────────────────────────────
+    async delete(recordId) {
+        const userId = this.getUserId() ?? 'anonymous';
+        // Add to write queue
+        await (0, cache_store_1.addToWriteQueue)(userId, {
+            id: generateId(),
+            type: 'delete',
+            recordId,
+        });
+        // Try network
+        const res = await fetch(`${this.config.baseUrl}/v1/sdk/db/records/${recordId}`, { method: 'DELETE', headers: this.headers });
+        if (!res.ok && res.status !== 204) {
+            // Queued for sync — will retry when online
+        }
+    }
+    // ─── Manual sync ────────────────────────────────────────────────────────────
+    async syncPendingWrites() {
+        await this.syncEngine.flush();
+    }
+}
+exports.KoolbaseDatabase = KoolbaseDatabase;

package/dist/flags.d.ts

@@ -0,0 +1,15 @@
+import { KoolbaseConfig, VersionCheckResult } from './types';
+export declare class KoolbaseFlags {
+    private config;
+    private payload;
+    private deviceId;
+    constructor(config: KoolbaseConfig, deviceId: string);
+    fetch(appVersion: string, platform: string): Promise<void>;
+    isEnabled(key: string): boolean;
+    getString(key: string, fallback?: string): string;
+    getNumber(key: string, fallback?: number): number;
+    getBool(key: string, fallback?: boolean): boolean;
+    checkVersion(currentVersion: string): VersionCheckResult;
+    private parseVersion;
+    private stableHash;
+}