@techfinityedge/koolbase-react-native 1.6.1

package/dist/flags.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoolbaseFlags = void 0;
+class KoolbaseFlags {
+    constructor(config, deviceId) {
+        this.payload = null;
+        this.config = config;
+        this.deviceId = deviceId;
+    }
+    async fetch(appVersion, platform) {
+        try {
+            const res = await fetch(`${this.config.baseUrl}/v1/bootstrap?public_key=${this.config.publicKey}&device_id=${this.deviceId}&app_version=${appVersion}&platform=${platform}`);
+            if (res.ok) {
+                this.payload = await res.json();
+            }
+        }
+        catch (_) { }
+    }
+    isEnabled(key) {
+        const flag = this.payload?.flags[key];
+        if (!flag || !flag.enabled || flag.kill_switch)
+            return false;
+        const bucket = this.stableHash(`${this.deviceId}:${key}`) % 100;
+        return bucket < flag.rollout_percentage;
+    }
+    getString(key, fallback = '') {
+        const val = this.payload?.config[key];
+        return val !== undefined ? String(val) : fallback;
+    }
+    getNumber(key, fallback = 0) {
+        const val = this.payload?.config[key];
+        return typeof val === 'number' ? val : Number(val) || fallback;
+    }
+    getBool(key, fallback = false) {
+        const val = this.payload?.config[key];
+        if (typeof val === 'boolean')
+            return val;
+        return val === 'true' ? true : fallback;
+    }
+    checkVersion(currentVersion) {
+        const policy = this.payload?.version;
+        if (!policy?.min_version) {
+            return { status: 'up_to_date', message: '', latestVersion: '' };
+        }
+        const current = this.parseVersion(currentVersion);
+        const min = this.parseVersion(policy.min_version);
+        const latest = this.parseVersion(policy.latest_version);
+        if (current < min) {
+            return {
+                status: 'force_update',
+                message: policy.update_message,
+                latestVersion: policy.latest_version,
+            };
+        }
+        if (policy.latest_version && current < latest) {
+            return {
+                status: policy.force_update ? 'force_update' : 'soft_update',
+                message: policy.update_message,
+                latestVersion: policy.latest_version,
+            };
+        }
+        return { status: 'up_to_date', message: '', latestVersion: policy.latest_version };
+    }
+    parseVersion(v) {
+        const parts = v.split('.').map(Number);
+        return (parts[0] ?? 0) * 10000 + (parts[1] ?? 0) * 100 + (parts[2] ?? 0);
+    }
+    stableHash(s) {
+        let hash = 0;
+        for (let i = 0; i < s.length; i++) {
+            hash = (Math.imul(31, hash) + s.charCodeAt(i)) | 0;
+        }
+        return Math.abs(hash);
+    }
+}
+exports.KoolbaseFlags = KoolbaseFlags;

package/dist/functions.d.ts

@@ -0,0 +1,7 @@
+import { KoolbaseConfig, FunctionInvokeResult, DeployOptions, DeployResult } from './types';
+export declare class KoolbaseFunctions {
+    private config;
+    constructor(config: KoolbaseConfig);
+    deploy(options: DeployOptions): Promise<DeployResult>;
+    invoke(name: string, body?: Record<string, unknown>): Promise<FunctionInvokeResult>;
+}

package/dist/functions.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoolbaseFunctions = void 0;
+const types_1 = require("./types");
+class KoolbaseFunctions {
+    constructor(config) {
+        this.config = config;
+    }
+    // ─── Deploy ────────────────────────────────────────────────────────────────
+    async deploy(options) {
+        const runtime = options.runtime ?? types_1.FunctionRuntime.Deno;
+        const res = await fetch(`${this.config.baseUrl}/v1/sdk/functions/deploy`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.config.publicKey,
+            },
+            body: JSON.stringify({
+                name: options.name,
+                code: options.code,
+                runtime,
+                timeout_ms: options.timeoutMs ?? 10000,
+            }),
+        });
+        const data = await res.json().catch(() => null);
+        if (!res.ok) {
+            throw new Error(data?.error ??
+                'Function deploy failed');
+        }
+        const d = data;
+        return {
+            id: d.id,
+            name: d.name,
+            runtime: d.runtime,
+            version: d.version,
+            isActive: d.is_active,
+            timeoutMs: d.timeout_ms,
+            lastDeployedAt: d.last_deployed_at,
+        };
+    }
+    // ─── Invoke ────────────────────────────────────────────────────────────────
+    async invoke(name, body) {
+        const res = await fetch(`${this.config.baseUrl}/v1/sdk/functions/${name}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.config.publicKey,
+            },
+            body: JSON.stringify({ body: body ?? {} }),
+        });
+        const data = await res.json().catch(() => null);
+        const success = res.status >= 200 && res.status < 300;
+        if (!success) {
+            throw new Error(data?.error ??
+                'Function invocation failed');
+        }
+        return {
+            statusCode: res.status,
+            data: data,
+            success,
+        };
+    }
+}
+exports.KoolbaseFunctions = KoolbaseFunctions;

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { KoolbaseAuth } from './auth';
+import { KoolbaseCodePush } from './code-push';
+import { KoolbaseAnalytics } from './analytics';
+import { KoolbaseMessaging } from './messaging';
+export { KoolbaseMessaging } from './messaging';
+export { KoolbaseAppleAuth } from './apple-auth';
+export type { RegisterTokenOptions, SendOptions } from './messaging';
+import { FlowResult } from './logic-engine';
+export { KoolbaseAnalytics } from './analytics';
+export type { FlowResult } from './logic-engine';
+export { KoolbaseCodePush } from './code-push';
+export type { BundleManifest, BundlePayload } from './code-push';
+import { KoolbaseDatabase } from './database';
+import { KoolbaseFlags } from './flags';
+import { KoolbaseFunctions } from './functions';
+import { KoolbaseRealtime } from './realtime';
+import { KoolbaseStorage } from './storage';
+import { KoolbaseConfig, VersionCheckResult } from './types';
+export * from './types';
+export { KoolbaseAuth, KoolbaseDatabase, KoolbaseFlags, KoolbaseFunctions, KoolbaseRealtime, KoolbaseStorage };
+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 codePush: KoolbaseCodePush;
+    readonly analytics: KoolbaseAnalytics;
+    executeFlow(flowId: string, context?: Record<string, unknown>): FlowResult;
+    readonly messaging: KoolbaseMessaging;
+    checkVersion(currentVersion: string): VersionCheckResult;
+};

package/dist/index.js

@@ -0,0 +1,165 @@
+"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 __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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Koolbase = exports.KoolbaseStorage = exports.KoolbaseRealtime = exports.KoolbaseFunctions = exports.KoolbaseFlags = exports.KoolbaseDatabase = exports.KoolbaseAuth = exports.KoolbaseCodePush = exports.KoolbaseAnalytics = exports.KoolbaseAppleAuth = exports.KoolbaseMessaging = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const auth_1 = require("./auth");
+Object.defineProperty(exports, "KoolbaseAuth", { enumerable: true, get: function () { return auth_1.KoolbaseAuth; } });
+const code_push_1 = require("./code-push");
+const analytics_1 = require("./analytics");
+const messaging_1 = require("./messaging");
+var messaging_2 = require("./messaging");
+Object.defineProperty(exports, "KoolbaseMessaging", { enumerable: true, get: function () { return messaging_2.KoolbaseMessaging; } });
+var apple_auth_1 = require("./apple-auth");
+Object.defineProperty(exports, "KoolbaseAppleAuth", { enumerable: true, get: function () { return apple_auth_1.KoolbaseAppleAuth; } });
+const logic_engine_1 = require("./logic-engine");
+var analytics_2 = require("./analytics");
+Object.defineProperty(exports, "KoolbaseAnalytics", { enumerable: true, get: function () { return analytics_2.KoolbaseAnalytics; } });
+var code_push_2 = require("./code-push");
+Object.defineProperty(exports, "KoolbaseCodePush", { enumerable: true, get: function () { return code_push_2.KoolbaseCodePush; } });
+const database_1 = require("./database");
+Object.defineProperty(exports, "KoolbaseDatabase", { enumerable: true, get: function () { return database_1.KoolbaseDatabase; } });
+const flags_1 = require("./flags");
+Object.defineProperty(exports, "KoolbaseFlags", { enumerable: true, get: function () { return flags_1.KoolbaseFlags; } });
+const functions_1 = require("./functions");
+Object.defineProperty(exports, "KoolbaseFunctions", { enumerable: true, get: function () { return functions_1.KoolbaseFunctions; } });
+const realtime_1 = require("./realtime");
+Object.defineProperty(exports, "KoolbaseRealtime", { enumerable: true, get: function () { return realtime_1.KoolbaseRealtime; } });
+const storage_1 = require("./storage");
+Object.defineProperty(exports, "KoolbaseStorage", { enumerable: true, get: function () { return storage_1.KoolbaseStorage; } });
+__exportStar(require("./types"), exports);
+let _auth = null;
+let _db = null;
+let _storage = null;
+let _realtime = null;
+let _functions = null;
+let _flags = null;
+let _codePush = null;
+let _analytics = null;
+let _messaging = null;
+const _logicEngine = new logic_engine_1.KoolbaseLogicEngine();
+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;
+        _auth = new auth_1.KoolbaseAuth(config);
+        _db = new database_1.KoolbaseDatabase(config, () => _auth?.currentUser?.id ?? null);
+        _storage = new storage_1.KoolbaseStorage(config, () => _auth?.accessToken ?? null);
+        _realtime = new realtime_1.KoolbaseRealtime(config);
+        _functions = new functions_1.KoolbaseFunctions(config);
+        _flags = new flags_1.KoolbaseFlags(config, 'rn-device');
+        _codePush = new code_push_1.KoolbaseCodePush(config, config.codePushChannel ?? 'stable');
+        // Initialize code push — loads cached bundle then checks in background
+        await _codePush.init({
+            appVersion: '1.0.0', // override with your app version
+            platform: 'react-native',
+            deviceId: 'rn-device',
+        });
+        // Initialize analytics
+        if (config.analyticsEnabled !== false) {
+            _analytics = new analytics_1.KoolbaseAnalytics(config);
+            await _analytics.init(config.appVersion);
+        }
+        // Initialize messaging
+        if (config.messagingEnabled !== false) {
+            _messaging = new messaging_1.KoolbaseMessaging(config);
+            const storedDeviceId = await async_storage_1.default.getItem('koolbase:device_id');
+            _messaging.setDeviceId(storedDeviceId ?? 'rn-device');
+        }
+        _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();
+        // Bundle flag wins over remote flag
+        const bundleFlag = _codePush?.getBundleFlag(key);
+        if (bundleFlag !== undefined)
+            return bundleFlag;
+        return _flags.isEnabled(key);
+    },
+    configString(key, fallback = '') {
+        ensureInitialized();
+        const bundleVal = _codePush?.getBundleConfig(key);
+        if (bundleVal !== undefined)
+            return String(bundleVal);
+        return _flags.getString(key, fallback);
+    },
+    configNumber(key, fallback = 0) {
+        ensureInitialized();
+        const bundleVal = _codePush?.getBundleConfig(key);
+        if (bundleVal !== undefined)
+            return typeof bundleVal === 'number' ? bundleVal : Number(bundleVal) || fallback;
+        return _flags.getNumber(key, fallback);
+    },
+    configBool(key, fallback = false) {
+        ensureInitialized();
+        const bundleVal = _codePush?.getBundleConfig(key);
+        if (bundleVal !== undefined)
+            return typeof bundleVal === 'boolean' ? bundleVal : bundleVal === 'true';
+        return _flags.getBool(key, fallback);
+    },
+    get codePush() {
+        ensureInitialized();
+        return _codePush;
+    },
+    get analytics() {
+        ensureInitialized();
+        return _analytics;
+    },
+    executeFlow(flowId, context) {
+        ensureInitialized();
+        const manifest = _codePush?.manifest;
+        if (!manifest)
+            return { hasEvent: false, args: {}, completed: true };
+        return _logicEngine.execute(flowId, manifest.payload.flows ?? {}, context ?? {}, manifest.payload.config ?? {}, manifest.payload.flags ?? {});
+    },
+    get messaging() {
+        ensureInitialized();
+        return _messaging;
+    },
+    checkVersion(currentVersion) {
+        ensureInitialized();
+        return _flags.checkVersion(currentVersion);
+    },
+};

package/dist/logic-engine.d.ts

@@ -0,0 +1,17 @@
+export interface FlowResult {
+    hasEvent: boolean;
+    eventName?: string;
+    args: Record<string, unknown>;
+    completed: boolean;
+    error?: string;
+}
+export declare class KoolbaseLogicEngine {
+    execute(flowId: string, flows: Record<string, unknown>, context: Record<string, unknown>, config: Record<string, unknown>, flags: Record<string, boolean>): FlowResult;
+    private evalNode;
+    private evalIf;
+    private evalSequence;
+    private evalCondition;
+    private resolve;
+    private getNested;
+    private setNested;
+}

package/dist/logic-engine.js

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

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

package/dist/messaging.js

@@ -0,0 +1,58 @@
+"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;
+        }
+    }
+    // ─── Send notification ────────────────────────────────────────────────────
+    async send(options) {
+        try {
+            const response = await fetch(`${this.config.baseUrl}/v1/messaging/send`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.config.publicKey,
+                },
+                body: JSON.stringify({
+                    token: options.to,
+                    title: options.title,
+                    body: options.body,
+                    data: options.data ?? {},
+                }),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.KoolbaseMessaging = KoolbaseMessaging;

package/dist/realtime.d.ts

@@ -0,0 +1,11 @@
+import { KoolbaseConfig, RealtimeCallback } from './types';
+export declare class KoolbaseRealtime {
+    private config;
+    private ws;
+    private listeners;
+    private reconnectTimer;
+    constructor(config: KoolbaseConfig);
+    subscribe(collection: string, callback: RealtimeCallback): () => void;
+    private connect;
+    disconnect(): void;
+}