@koolbase/react-native 9.1.0 → 10.0.0

package/dist/cache-store.d.ts

@@ -1,11 +0,0 @@
-import { KoolbaseRecord, PendingWrite, QueryResult } from './types';
-export declare function hashQuery(collection: string, options: Record<string, unknown>): string;
-export declare function getCached(userId: string, collection: string, queryHash: string): Promise<QueryResult | null>;
-export declare function setCached(userId: string, collection: string, queryHash: string, result: QueryResult): Promise<void>;
-export declare function invalidateCache(userId: string, collection: string): Promise<void>;
-export declare function clearUserCache(userId: string): Promise<void>;
-export declare function getWriteQueue(userId: string): Promise<PendingWrite[]>;
-export declare function addToWriteQueue(userId: string, write: Omit<PendingWrite, 'retries' | 'createdAt'>): Promise<void>;
-export declare function removeFromWriteQueue(userId: string, writeId: string): Promise<void>;
-export declare function incrementWriteRetry(userId: string, writeId: string): Promise<void>;
-export declare function optimisticallyInsert(userId: string, collection: string, record: KoolbaseRecord): Promise<void>;

package/dist/cache-store.js

@@ -1,136 +0,0 @@
-"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

@@ -1,59 +0,0 @@
-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;
-    mandatory?: boolean;
-}
-export declare class KoolbaseCodePush {
-    private config;
-    private channel;
-    private activeManifest;
-    private mandatoryPending;
-    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;
-    /**
-     * 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;
-    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

@@ -1,255 +0,0 @@
-"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;
-        this.mandatoryPending = false;
-        // ─── 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;
-            }
-            // 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);
-        }
-    }
-    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;
-    }
-    /**
-     * 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;
-    }
-    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-errors.d.ts

@@ -1,95 +0,0 @@
-/**
- * Base class for errors surfaced by the Koolbase data layer (database reads
- * and writes). Every data error carries a `message` and, when the server
- * provides one, its stable `code` (e.g. `not_found`, `validation_error`,
- * `unique_violation`).
- *
- * Catch this to handle any data-layer failure generically, or catch a
- * specific subclass to branch on the kind of failure.
- */
-export declare class KoolbaseDataError extends Error {
-    code?: string;
-    constructor(message: string, code?: string);
-}
-/**
- * Thrown when a write is rejected because the value would violate a
- * collection's unique constraint — the server responds with 409 Conflict.
- * Catch it to handle duplicates, e.g. an email or username already in use.
- *
- * `field` names the field that collided, when the server reports it
- * (`details.field`) — useful when a collection has more than one unique
- * constraint and you need to know which value clashed.
- *
- * Surfaced by `insert`, `update`, and `upsert` whenever the server is
- * reachable and rejects the write with a 409. These writes are online-first:
- * a server-side conflict throws immediately. Only a genuine network failure
- * falls back to the offline queue, where a conflict that surfaces at sync
- * time is handled by the sync engine rather than thrown here.
- *
- * @example
- * try {
- *   await koolbase.db.upsert('users', { email }, { name });
- * } catch (e) {
- *   if (e instanceof KoolbaseConflictError) {
- *     showError(`That ${e.field ?? 'value'} is already registered.`);
- *   }
- * }
- */
-export declare class KoolbaseConflictError extends KoolbaseDataError {
-    field?: string;
-    constructor(message?: string, field?: string);
-}
-/**
- * Thrown when the requested record or collection does not exist — the server
- * responds with 404 and code `not_found` / `record_not_found` /
- * `collection_not_found`.
- */
-export declare class KoolbaseNotFoundError extends KoolbaseDataError {
-    constructor(message?: string);
-}
-/**
- * Thrown when the request is rejected as invalid — the server responds with
- * 400 and code `validation_error`.
- */
-export declare class KoolbaseValidationError extends KoolbaseDataError {
-    constructor(message?: string);
-}
-/**
- * Thrown when the caller is authenticated but not allowed to perform the
- * operation — the server responds with 403 and code `permission_denied`
- * (typically a collection access rule rejecting the read/write).
- */
-export declare class KoolbasePermissionError extends KoolbaseDataError {
-    constructor(message?: string);
-}
-/**
- * Thrown when the server is rate-limiting the caller — 429 with code
- * `rate_limit`. Back off and retry after a short delay.
- */
-export declare class KoolbaseRateLimitError extends KoolbaseDataError {
-    constructor(message?: string);
-}
-/**
- * Thrown when the supplied vector's length does not match the dimension
- * declared on the collection's vector field — the server responds with
- * 400 and code `vector_dimension_mismatch`. The message includes both
- * the expected and actual dimensions so you can surface a precise error.
- *
- * @example
- * try {
- *   await koolbase.db.setVector(id, 'embedding', [0.1, 0.2]); // 2 dims
- * } catch (e) {
- *   if (e instanceof KoolbaseVectorDimensionMismatchError) {
- *     showError(e.message); // "expected 1536, got 2"
- *   }
- * }
- */
-export declare class KoolbaseVectorDimensionMismatchError extends KoolbaseDataError {
-    constructor(message?: string);
-}
-/**
- * Maps a non-2xx data-layer response to a typed {@link KoolbaseDataError},
- * preferring the server's stable `code` and falling back to the HTTP status
- * for older or uncoded responses. Always returns an error to throw.
- */
-export declare function koolbaseDataError(status: number, body: any, fallbackMessage?: string): KoolbaseDataError;