@koolbase/react-native 9.1.0 → 10.0.0

package/dist/logic-engine.js

@@ -1,193 +0,0 @@
-"use strict";
-// ─── Logic Engine ────────────────────────────────────────────────────────
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KoolbaseLogicEngine = void 0;
-class KoolbaseLogicEngine {
-    // ─── Public API ───────────────────────────────────────────────────────────
-    execute(flowId, flows, context, config, flags) {
-        try {
-            const flowJson = flows[flowId];
-            if (!flowJson) {
-                return { hasEvent: false, args: {}, completed: true };
-            }
-            const ctx = {
-                context: { ...context },
-                config,
-                flags,
-            };
-            return this.evalNode(flowJson, ctx);
-        }
-        catch (e) {
-            return {
-                hasEvent: false,
-                args: {},
-                completed: false,
-                error: String(e),
-            };
-        }
-    }
-    // ─── Node evaluation ──────────────────────────────────────────────────────
-    evalNode(node, ctx) {
-        switch (node.type) {
-            case 'if':
-                return this.evalIf(node, ctx);
-            case 'sequence':
-                return this.evalSequence(node, ctx);
-            case 'event':
-                return { hasEvent: true, eventName: node.name, args: node.args ?? {}, completed: true };
-            case 'set':
-                this.setNested(ctx.context, node.key, node.value);
-                return { hasEvent: false, args: {}, completed: true };
-            default:
-                return { hasEvent: false, args: {}, completed: true };
-        }
-    }
-    evalIf(node, ctx) {
-        const result = this.evalCondition(node.condition, ctx);
-        if (result)
-            return this.evalNode(node.then, ctx);
-        if (node.else)
-            return this.evalNode(node.else, ctx);
-        return { hasEvent: false, args: {}, completed: true };
-    }
-    evalSequence(node, ctx) {
-        for (const step of node.steps) {
-            const result = this.evalNode(step, ctx);
-            if (result.hasEvent)
-                return result;
-        }
-        return { hasEvent: false, args: {}, completed: true };
-    }
-    // ─── Condition evaluation ─────────────────────────────────────────────────
-    evalCondition(condition, ctx) {
-        switch (condition.op) {
-            case 'eq': {
-                const left = condition.left ? this.resolve(condition.left.from, ctx) : undefined;
-                return String(left) === String(condition.right);
-            }
-            case 'neq': {
-                const left = condition.left ? this.resolve(condition.left.from, ctx) : undefined;
-                return String(left) !== String(condition.right);
-            }
-            case 'gt': {
-                const left = Number(condition.left ? this.resolve(condition.left.from, ctx) : undefined);
-                const right = Number(condition.right);
-                return !isNaN(left) && !isNaN(right) && left > right;
-            }
-            case 'lt': {
-                const left = Number(condition.left ? this.resolve(condition.left.from, ctx) : undefined);
-                const right = Number(condition.right);
-                return !isNaN(left) && !isNaN(right) && left < right;
-            }
-            case 'and':
-                return (condition.conditions ?? []).every((c) => this.evalCondition(c, ctx));
-            case 'or':
-                return (condition.conditions ?? []).some((c) => this.evalCondition(c, ctx));
-            case 'exists': {
-                const val = condition.value ? this.resolve(condition.value.from, ctx) : undefined;
-                return val !== null && val !== undefined;
-            }
-            case 'not_exists': {
-                const val = condition.value ? this.resolve(condition.value.from, ctx) : undefined;
-                return val === null || val === undefined;
-            }
-            case 'gte': {
-                const left = Number(condition.left ? this.resolve(condition.left.from, ctx) : undefined);
-                const right = Number(condition.right);
-                return !isNaN(left) && !isNaN(right) && left >= right;
-            }
-            case 'lte': {
-                const left = Number(condition.left ? this.resolve(condition.left.from, ctx) : undefined);
-                const right = Number(condition.right);
-                return !isNaN(left) && !isNaN(right) && left <= right;
-            }
-            case 'contains': {
-                const left = condition.left ? this.resolve(condition.left.from, ctx) : undefined;
-                const right = condition.right;
-                if (typeof left === 'string' && typeof right === 'string')
-                    return left.includes(right);
-                if (Array.isArray(left))
-                    return left.includes(right);
-                return false;
-            }
-            case 'starts_with': {
-                const left = condition.left ? this.resolve(condition.left.from, ctx) : undefined;
-                const right = String(condition.right ?? '');
-                return typeof left === 'string' && left.startsWith(right);
-            }
-            case 'ends_with': {
-                const left = condition.left ? this.resolve(condition.left.from, ctx) : undefined;
-                const right = String(condition.right ?? '');
-                return typeof left === 'string' && left.endsWith(right);
-            }
-            case 'in_list': {
-                const left = condition.left ? this.resolve(condition.left.from, ctx) : undefined;
-                const list = condition.right;
-                if (!Array.isArray(list))
-                    return false;
-                return list.some((item) => String(item) === String(left));
-            }
-            case 'not_in_list': {
-                const left = condition.left ? this.resolve(condition.left.from, ctx) : undefined;
-                const list = condition.right;
-                if (!Array.isArray(list))
-                    return true;
-                return !list.some((item) => String(item) === String(left));
-            }
-            case 'between': {
-                const left = Number(condition.left ? this.resolve(condition.left.from, ctx) : undefined);
-                const range = condition.right;
-                if (!Array.isArray(range) || range.length < 2)
-                    return false;
-                const min = Number(range[0]);
-                const max = Number(range[1]);
-                return !isNaN(left) && !isNaN(min) && !isNaN(max) && left >= min && left <= max;
-            }
-            case 'is_true': {
-                const left = condition.left ? this.resolve(condition.left.from, ctx) : undefined;
-                return left === true || left === 'true';
-            }
-            case 'is_false': {
-                const left = condition.left ? this.resolve(condition.left.from, ctx) : undefined;
-                return left === false || left === 'false';
-            }
-            default:
-                return false;
-        }
-    }
-    // ─── Data resolution ──────────────────────────────────────────────────────
-    resolve(from, ctx) {
-        const dotIdx = from.indexOf('.');
-        if (dotIdx === -1)
-            return undefined;
-        const source = from.substring(0, dotIdx);
-        const key = from.substring(dotIdx + 1);
-        switch (source) {
-            case 'context': return this.getNested(ctx.context, key);
-            case 'config': return this.getNested(ctx.config, key);
-            case 'flags': return ctx.flags[key];
-            default: return undefined;
-        }
-    }
-    getNested(obj, key) {
-        const parts = key.split('.');
-        let current = obj;
-        for (const part of parts) {
-            if (current == null || typeof current !== 'object')
-                return undefined;
-            current = current[part];
-        }
-        return current;
-    }
-    setNested(obj, key, value) {
-        const parts = key.split('.');
-        let current = obj;
-        for (let i = 0; i < parts.length - 1; i++) {
-            if (!(parts[i] in current))
-                current[parts[i]] = {};
-            current = current[parts[i]];
-        }
-        current[parts[parts.length - 1]] = value;
-    }
-}
-exports.KoolbaseLogicEngine = KoolbaseLogicEngine;

package/dist/messaging.d.ts

@@ -1,13 +0,0 @@
-import { KoolbaseConfig } from './types';
-export interface RegisterTokenOptions {
-    token: string;
-    platform: 'android' | 'ios';
-    userId?: string;
-}
-export declare class KoolbaseMessaging {
-    private config;
-    private deviceId;
-    constructor(config: KoolbaseConfig);
-    setDeviceId(deviceId: string): void;
-    registerToken(options: RegisterTokenOptions): Promise<boolean>;
-}

package/dist/messaging.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KoolbaseMessaging = void 0;
-// ─── KoolbaseMessaging ────────────────────────────────────────────────────────
-class KoolbaseMessaging {
-    constructor(config) {
-        this.deviceId = '';
-        this.config = config;
-    }
-    setDeviceId(deviceId) {
-        this.deviceId = deviceId;
-    }
-    // ─── Register token ───────────────────────────────────────────────────────
-    async registerToken(options) {
-        try {
-            const response = await fetch(`${this.config.baseUrl}/v1/messaging/register`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': this.config.publicKey,
-                },
-                body: JSON.stringify({
-                    device_id: this.deviceId,
-                    token: options.token,
-                    platform: options.platform,
-                    ...(options.userId && { user_id: options.userId }),
-                }),
-            });
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-}
-exports.KoolbaseMessaging = KoolbaseMessaging;

package/dist/realtime.d.ts

@@ -1,19 +0,0 @@
-import { KoolbaseConfig, RealtimeCallback } from './types';
-type TokenProvider = () => Promise<string | null>;
-export declare class KoolbaseRealtime {
-    private config;
-    private getToken;
-    private ws;
-    private projectId;
-    private listeners;
-    private reconnectTimer;
-    private connecting;
-    constructor(config: KoolbaseConfig, getToken: TokenProvider);
-    subscribe(collection: string, callback: RealtimeCallback): () => void;
-    private connect;
-    private sendSubscribe;
-    private sendUnsubscribe;
-    private scheduleReconnect;
-    disconnect(): void;
-}
-export {};

package/dist/realtime.js

@@ -1,148 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KoolbaseRealtime = void 0;
-const record_1 = require("./record");
-const EVENT_TYPE_MAP = {
-    'db.record.created': 'created',
-    'db.record.updated': 'updated',
-    'db.record.deleted': 'deleted',
-};
-function projectIdFromToken(token) {
-    try {
-        const part = token.split('.')[1];
-        if (!part)
-            return null;
-        const b64 = part.replace(/-/g, '+').replace(/_/g, '/');
-        const g = globalThis;
-        let json;
-        if (typeof g.atob === 'function') {
-            const bin = g.atob(b64);
-            json = decodeURIComponent(bin.split('').map((c) => '%' + c.charCodeAt(0).toString(16).padStart(2, '0')).join(''));
-        }
-        else if (g.Buffer) {
-            json = g.Buffer.from(b64, 'base64').toString('utf8');
-        }
-        else {
-            return null;
-        }
-        return JSON.parse(json).project_id ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-class KoolbaseRealtime {
-    constructor(config, getToken) {
-        this.ws = null;
-        this.projectId = null;
-        this.listeners = new Map();
-        this.reconnectTimer = null;
-        this.connecting = false;
-        this.config = config;
-        this.getToken = getToken;
-    }
-    subscribe(collection, callback) {
-        if (!this.listeners.has(collection))
-            this.listeners.set(collection, []);
-        this.listeners.get(collection).push(callback);
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            this.sendSubscribe(collection);
-        }
-        else {
-            void this.connect();
-        }
-        return () => {
-            const callbacks = this.listeners.get(collection) ?? [];
-            const i = callbacks.indexOf(callback);
-            if (i > -1)
-                callbacks.splice(i, 1);
-            if (callbacks.length === 0) {
-                this.listeners.delete(collection);
-                this.sendUnsubscribe(collection);
-            }
-        };
-    }
-    async connect() {
-        if (this.connecting)
-            return;
-        if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING))
-            return;
-        const token = await this.getToken();
-        if (!token) {
-            this.scheduleReconnect(); // sign-in may be in flight
-            return;
-        }
-        this.projectId = projectIdFromToken(token);
-        this.connecting = true;
-        const wsUrl = this.config.baseUrl.replace('https://', 'wss://').replace('http://', 'ws://');
-        const ws = new WebSocket(`${wsUrl}/v1/realtime/ws?token=${encodeURIComponent(token)}`);
-        this.ws = ws;
-        ws.onopen = () => {
-            this.connecting = false;
-            for (const collection of this.listeners.keys())
-                this.sendSubscribe(collection); // (re)subscribe all
-        };
-        ws.onmessage = (event) => {
-            let raw;
-            try {
-                raw = JSON.parse(event.data);
-            }
-            catch {
-                return;
-            }
-            const mapped = EVENT_TYPE_MAP[raw?.type];
-            if (!mapped)
-                return; // ignore subscribed / unsubscribed / error / unknown
-            const payload = raw.payload;
-            if (!payload || !payload.collection)
-                return;
-            let msg;
-            if (mapped === 'deleted') {
-                msg = { type: 'deleted', collection: payload.collection, recordId: payload.record_id };
-            }
-            else if (payload.record) {
-                msg = { type: mapped, collection: payload.collection, record: (0, record_1.recordFromWire)(payload.record) };
-            }
-            else {
-                return;
-            }
-            (this.listeners.get(payload.collection) ?? []).forEach((cb) => cb(msg));
-        };
-        ws.onclose = () => {
-            this.connecting = false;
-            if (this.ws === ws)
-                this.ws = null;
-            this.scheduleReconnect();
-        };
-        ws.onerror = () => { };
-    }
-    sendSubscribe(collection) {
-        if (!this.projectId || !this.ws || this.ws.readyState !== WebSocket.OPEN)
-            return;
-        this.ws.send(JSON.stringify({ action: 'subscribe', project_id: this.projectId, collection }));
-    }
-    sendUnsubscribe(collection) {
-        if (!this.projectId || !this.ws || this.ws.readyState !== WebSocket.OPEN)
-            return;
-        this.ws.send(JSON.stringify({ action: 'unsubscribe', project_id: this.projectId, collection }));
-    }
-    scheduleReconnect() {
-        if (this.listeners.size === 0 || this.reconnectTimer)
-            return;
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnectTimer = null;
-            void this.connect();
-        }, 3000);
-    }
-    disconnect() {
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        this.ws?.close();
-        this.ws = null;
-        this.projectId = null;
-        this.listeners.clear();
-    }
-}
-exports.KoolbaseRealtime = KoolbaseRealtime;

package/dist/record.d.ts

@@ -1,2 +0,0 @@
-import { KoolbaseRecord } from './types';
-export declare function recordFromWire(raw: Record<string, unknown>): KoolbaseRecord;

package/dist/record.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.recordFromWire = recordFromWire;
-// Converts the flat public wire shape into a KoolbaseRecord.
-// Server sends: { $id, $createdAt, $updatedAt, $collection, $createdBy?, ...fields }
-function recordFromWire(raw) {
-    const data = {};
-    for (const key of Object.keys(raw)) {
-        if (!key.startsWith('$'))
-            data[key] = raw[key];
-    }
-    return {
-        id: raw['$id'],
-        collection: raw['$collection'],
-        createdBy: raw['$createdBy'],
-        data,
-        createdAt: raw['$createdAt'],
-        updatedAt: raw['$updatedAt'],
-    };
-}

package/dist/storage-errors.d.ts

@@ -1,163 +0,0 @@
-/**
- * Base error type for all Koolbase storage errors. Catchable via
- * `instanceof KoolbaseStorageError` to handle any storage-related failure
- * generically; subclasses let you handle specific cases.
- */
-export declare class KoolbaseStorageError extends Error {
-    code?: string;
-    constructor(message: string, code?: string);
-}
-/**
- * Thrown when an upload is rejected because an object already exists at
- * the requested path — the server responds with 409 Conflict and code
- * `path_conflict`. Catch it to give the user an "overwrite this file?"
- * prompt, then retry the upload with `overwrite: true`.
- *
- * `path` is the colliding path the server rejected, surfaced from the
- * response body for diagnostics and UI.
- *
- * @example
- * try {
- *   await Koolbase.storage.upload({
- *     bucket: 'avatars',
- *     path: 'me.png',
- *     file: { uri, name, type: 'image/png' },
- *   });
- * } catch (e) {
- *   if (e instanceof KoolbaseStorageConflictError) {
- *     const ok = await confirm(`${e.path} already exists. Overwrite?`);
- *     if (ok) {
- *       await Koolbase.storage.upload({
- *         bucket: 'avatars',
- *         path: 'me.png',
- *         file: { uri, name, type: 'image/png' },
- *         overwrite: true,
- *       });
- *     }
- *   }
- * }
- */
-export declare class KoolbaseStorageConflictError extends KoolbaseStorageError {
-    path?: string;
-    constructor(message?: string, path?: string);
-}
-/**
- * Thrown when the requested bucket or object does not exist — the server
- * responds with 404. Also surfaced for cross-tenant access attempts
- * (Koolbase's 404-over-403 convention prevents enumeration in
- * multi-tenant contexts).
- */
-export declare class KoolbaseStorageNotFoundError extends KoolbaseStorageError {
-    constructor(message?: string);
-}
-/**
- * Thrown when the request is rejected as invalid — the server responds
- * with 400 (e.g. a malformed path, missing field, invalid bucket name).
- */
-export declare class KoolbaseStorageValidationError extends KoolbaseStorageError {
-    constructor(message?: string);
-}
-/**
- * Thrown when the caller is authenticated but not allowed to perform the
- * storage operation — the server responds with 403.
- */
-export declare class KoolbaseStoragePermissionError extends KoolbaseStorageError {
-    constructor(message?: string);
-}
-/**
- * Thrown when an upload would push the bucket past its configured
- * `max_size_bytes` quota — the server responds with 409 Conflict and code
- * `quota_exceeded`. The server cleans up the underlying R2 object before
- * returning; nothing leaks. Catch this to surface a "bucket is full"
- * message or prompt the caller to delete older files. The per-bucket
- * quota is set at bucket creation time and is currently immutable.
- *
- * Distinct from {@link KoolbaseStorageConflictError} (which also uses
- * 409 but means "path collides"); branch on the error type via
- * `instanceof`, not on status.
- */
-export declare class KoolbaseStorageQuotaError extends KoolbaseStorageError {
-    constructor(message?: string);
-}
-/**
- * Thrown when a single file exceeds the bucket's configured
- * `max_file_size_bytes` — the server responds with 413 Payload Too Large
- * and code `file_too_large`. The server cleans up the underlying R2
- * object before returning. The configured per-file limit lives on the
- * bucket record; check `Bucket.maxFileSizeBytes` to surface a clear
- * "files must be under X MB" message at the call site.
- */
-export declare class KoolbaseStorageFileTooLargeError extends KoolbaseStorageError {
-    constructor(message?: string);
-}
-/**
- * Thrown when an upload's content-type isn't in the bucket's configured
- * `allowed_mime_types` allowlist — the server responds with 415
- * Unsupported Media Type and code `mime_not_allowed`. The check runs at
- * presign time, so no bytes are transferred before rejection.
- *
- * Allowlists support `type/*` wildcards (e.g. `image/*` matches every
- * image content-type). A bucket with no allowlist configured accepts
- * every type.
- */
-export declare class KoolbaseStorageMimeTypeError extends KoolbaseStorageError {
-    constructor(message?: string);
-}
-/**
- * Thrown when an object metadata payload (either at upload-confirm time
- * or via `updateMetadata`) fails server-side validation — the server
- * responds with 400 and code `metadata_invalid`.
- *
- * The `detail` field carries the specific reason from the server — e.g.
- * `'key "foo bar": must match [a-z0-9_]+'`, `'exceeds 50 keys (got 53)'`,
- * or `'exceeds 8192 bytes total (sum of all key + value lengths)'`. The
- * detail names the failing key and rule so callers can fix the offending
- * entry without guessing what shape rule was violated.
- *
- * Validation rules (enforced server-side):
- * - At most 50 keys per object.
- * - At most 8KB total (sum of byte lengths across all keys + values).
- * - Keys: 1–64 chars, must match `[a-z0-9_]+`.
- * - Keys with a leading underscore are reserved for system use.
- * - Values: at most 1024 chars each.
- *
- * @example
- * try {
- *   await Koolbase.storage.updateMetadata('photos', 'sunset.jpg', {
- *     tag: 'sunset',
- *     'BAD KEY': 'oops',
- *   });
- * } catch (e) {
- *   if (e instanceof KoolbaseStorageMetadataInvalidError) {
- *     console.warn('Metadata rejected:', e.detail);
- *     // -> 'Metadata rejected: key "BAD KEY": must match [a-z0-9_]+'
- *   }
- * }
- */
-export declare class KoolbaseStorageMetadataInvalidError extends KoolbaseStorageError {
-    /**
-     * The specific validation failure reported by the server. Names the
-     * failing key (when applicable) and the rule that was violated.
-     * Surface this directly to developer logs or user-facing UI.
-     */
-    detail?: string;
-    constructor(message?: string, detail?: string);
-}
-/**
- * Maps a non-2xx storage-layer response to a typed
- * {@link KoolbaseStorageError}, preferring the server's stable `code` and
- * falling back to the HTTP status for older or uncoded responses. Always
- * returns an error to throw.
- *
- * Status-fallback note: HTTP 409 covers both path_conflict and
- * quota_exceeded. Without a `code` field, the mapper defaults 409 to
- * {@link KoolbaseStorageConflictError} since path collisions are the more
- * common case. Modern Koolbase servers always emit `code`, so this only
- * matters for very old API responses or non-Koolbase 409s.
- */
-export declare function koolbaseStorageError(status: number, body: any, fallbackMessage?: string): KoolbaseStorageError;
-/**
- * Convenience wrapper over {@link koolbaseStorageError} that decodes the
- * response body for you. Use at call sites that have the raw `Response`.
- */
-export declare function koolbaseStorageErrorFromResponse(res: Response, fallbackMessage?: string): Promise<KoolbaseStorageError>;