@techfinityedge/koolbase-react-native 1.6.1

package/dist/realtime.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoolbaseRealtime = void 0;
+class KoolbaseRealtime {
+    constructor(config) {
+        this.ws = null;
+        this.listeners = new Map();
+        this.reconnectTimer = null;
+        this.config = config;
+    }
+    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.connect();
+        }
+        // Return unsubscribe function
+        return () => {
+            const callbacks = this.listeners.get(collection) ?? [];
+            const index = callbacks.indexOf(callback);
+            if (index > -1)
+                callbacks.splice(index, 1);
+        };
+    }
+    connect() {
+        const wsUrl = this.config.baseUrl
+            .replace('https://', 'wss://')
+            .replace('http://', 'ws://');
+        this.ws = new WebSocket(`${wsUrl}/v1/sdk/realtime?key=${this.config.publicKey}`);
+        this.ws.onmessage = (event) => {
+            try {
+                const msg = JSON.parse(event.data);
+                const callbacks = this.listeners.get(msg.collection) ?? [];
+                callbacks.forEach((cb) => cb(msg));
+            }
+            catch (_) { }
+        };
+        this.ws.onclose = () => {
+            this.reconnectTimer = setTimeout(() => this.connect(), 3000);
+        };
+    }
+    disconnect() {
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.ws?.close();
+        this.ws = null;
+        this.listeners.clear();
+    }
+}
+exports.KoolbaseRealtime = KoolbaseRealtime;

package/dist/storage.d.ts

@@ -0,0 +1,12 @@
+import { KoolbaseConfig, UploadOptions } from './types';
+export declare class KoolbaseStorage {
+    private config;
+    private getToken;
+    constructor(config: KoolbaseConfig, getToken: () => string | null);
+    private get headers();
+    upload(options: UploadOptions): Promise<{
+        url: string;
+    }>;
+    getDownloadUrl(bucket: string, path: string): Promise<string>;
+    delete(bucket: string, path: string): Promise<void>;
+}

package/dist/storage.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KoolbaseStorage = void 0;
+class KoolbaseStorage {
+    constructor(config, getToken) {
+        this.config = config;
+        this.getToken = getToken;
+    }
+    get headers() {
+        const token = this.getToken();
+        return {
+            'x-api-key': this.config.publicKey,
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        };
+    }
+    async upload(options) {
+        // Get presigned upload URL
+        const res = await fetch(`${this.config.baseUrl}/v1/sdk/storage/${options.bucket}/upload`, {
+            method: 'POST',
+            headers: { ...this.headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                path: options.path,
+                content_type: options.file.type,
+            }),
+        });
+        if (!res.ok) {
+            const data = await res.json();
+            throw new Error(data.error ?? 'Failed to get upload URL');
+        }
+        const { upload_url, public_url } = await res.json();
+        // Upload to presigned URL
+        const formData = new FormData();
+        formData.append('file', {
+            uri: options.file.uri,
+            name: options.file.name,
+            type: options.file.type,
+        });
+        await fetch(upload_url, { method: 'PUT', body: formData });
+        return { url: public_url };
+    }
+    async getDownloadUrl(bucket, path) {
+        const res = await fetch(`${this.config.baseUrl}/v1/sdk/storage/${bucket}/download?path=${encodeURIComponent(path)}`, { headers: this.headers });
+        if (!res.ok) {
+            const data = await res.json();
+            throw new Error(data.error ?? 'Failed to get download URL');
+        }
+        const { url } = await res.json();
+        return url;
+    }
+    async delete(bucket, path) {
+        const res = await fetch(`${this.config.baseUrl}/v1/sdk/storage/${bucket}/delete`, {
+            method: 'DELETE',
+            headers: { ...this.headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ path }),
+        });
+        if (!res.ok && res.status !== 204) {
+            const data = await res.json();
+            throw new Error(data.error ?? 'Delete failed');
+        }
+    }
+}
+exports.KoolbaseStorage = KoolbaseStorage;

package/dist/sync-engine.d.ts

@@ -0,0 +1,15 @@
+import { KoolbaseConfig } from './types';
+type SyncCallback = () => void;
+export declare class SyncEngine {
+    private config;
+    private getUserId;
+    private onSyncComplete?;
+    private unsubscribe?;
+    private isSyncing;
+    constructor(config: KoolbaseConfig, getUserId: () => string | null, onSyncComplete?: SyncCallback);
+    start(): void;
+    stop(): void;
+    flush(): Promise<void>;
+    private executeWrite;
+}
+export {};

package/dist/sync-engine.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncEngine = void 0;
+const netinfo_1 = __importDefault(require("@react-native-community/netinfo"));
+const cache_store_1 = require("./cache-store");
+class SyncEngine {
+    constructor(config, getUserId, onSyncComplete) {
+        this.isSyncing = false;
+        this.config = config;
+        this.getUserId = getUserId;
+        this.onSyncComplete = onSyncComplete;
+    }
+    start() {
+        this.unsubscribe = netinfo_1.default.addEventListener(state => {
+            if (state.isConnected && state.isInternetReachable !== false) {
+                this.flush();
+            }
+        });
+    }
+    stop() {
+        this.unsubscribe?.();
+    }
+    async flush() {
+        if (this.isSyncing)
+            return;
+        const userId = this.getUserId();
+        if (!userId)
+            return;
+        this.isSyncing = true;
+        try {
+            const queue = await (0, cache_store_1.getWriteQueue)(userId);
+            if (queue.length === 0)
+                return;
+            for (const write of queue) {
+                try {
+                    await this.executeWrite(write);
+                    await (0, cache_store_1.removeFromWriteQueue)(userId, write.id);
+                }
+                catch {
+                    await (0, cache_store_1.incrementWriteRetry)(userId, write.id);
+                }
+            }
+            this.onSyncComplete?.();
+        }
+        finally {
+            this.isSyncing = false;
+        }
+    }
+    async executeWrite(write) {
+        const headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': this.config.publicKey,
+        };
+        if (write.type === 'insert') {
+            const res = await fetch(`${this.config.baseUrl}/v1/sdk/db/insert`, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({ collection: write.collection, data: write.data }),
+            });
+            if (!res.ok)
+                throw new Error(`Insert failed: ${res.status}`);
+        }
+        else if (write.type === 'update') {
+            const res = await fetch(`${this.config.baseUrl}/v1/sdk/db/records/${write.recordId}`, {
+                method: 'PATCH',
+                headers,
+                body: JSON.stringify({ data: write.data }),
+            });
+            if (!res.ok)
+                throw new Error(`Update failed: ${res.status}`);
+        }
+        else if (write.type === 'delete') {
+            const res = await fetch(`${this.config.baseUrl}/v1/sdk/db/records/${write.recordId}`, { method: 'DELETE', headers });
+            if (!res.ok && res.status !== 204) {
+                throw new Error(`Delete failed: ${res.status}`);
+            }
+        }
+    }
+}
+exports.SyncEngine = SyncEngine;

package/dist/types.d.ts

@@ -0,0 +1,122 @@
+export interface KoolbaseConfig {
+    publicKey: string;
+    baseUrl: string;
+    codePushChannel?: string;
+    analyticsEnabled?: boolean;
+    appVersion?: string;
+    messagingEnabled?: boolean;
+}
+export interface KoolbaseUser {
+    id: string;
+    email: string;
+    fullName?: string;
+    avatarUrl?: string;
+    verified: boolean;
+    createdAt: string;
+}
+export interface KoolbaseSession {
+    accessToken: string;
+    refreshToken: string;
+    user: KoolbaseUser;
+}
+export interface RegisterParams {
+    email: string;
+    password: string;
+    fullName?: string;
+}
+export interface LoginParams {
+    email: string;
+    password: string;
+}
+export interface KoolbaseRecord {
+    id: string;
+    projectId: string;
+    collectionId: string;
+    createdBy?: string;
+    data: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface QueryOptions {
+    filters?: Record<string, unknown>;
+    limit?: number;
+    offset?: number;
+    orderBy?: string;
+    orderDesc?: boolean;
+    populate?: string[];
+}
+export interface QueryResult {
+    records: KoolbaseRecord[];
+    total: number;
+    isFromCache?: boolean;
+}
+export interface PendingWrite {
+    id: string;
+    type: 'insert' | 'update' | 'delete';
+    collection?: string;
+    recordId?: string;
+    data?: Record<string, unknown>;
+    retries: number;
+    createdAt: string;
+}
+export interface UploadOptions {
+    bucket: string;
+    path: string;
+    file: {
+        uri: string;
+        name: string;
+        type: string;
+    };
+    onProgress?: (percent: number) => void;
+}
+export interface RealtimeEvent {
+    type: 'created' | 'updated' | 'deleted';
+    collection: string;
+    record: KoolbaseRecord;
+}
+export type RealtimeCallback = (event: RealtimeEvent) => void;
+export interface BootstrapPayload {
+    payload_version: string;
+    flags: Record<string, {
+        enabled: boolean;
+        rollout_percentage: number;
+        kill_switch: boolean;
+    }>;
+    config: Record<string, unknown>;
+    version: {
+        min_version: string;
+        latest_version: string;
+        force_update: boolean;
+        update_message: string;
+    };
+}
+export type VersionStatus = 'up_to_date' | 'soft_update' | 'force_update';
+export interface VersionCheckResult {
+    status: VersionStatus;
+    message: string;
+    latestVersion: string;
+}
+export declare enum FunctionRuntime {
+    Deno = "deno",
+    Dart = "dart"
+}
+export interface DeployOptions {
+    name: string;
+    code: string;
+    runtime?: FunctionRuntime;
+    timeoutMs?: number;
+}
+export interface DeployResult {
+    id: string;
+    name: string;
+    runtime: string;
+    version: number;
+    isActive: boolean;
+    timeoutMs: number;
+    lastDeployedAt: string | null;
+}
+export interface FunctionInvokeResult {
+    statusCode: number;
+    data: Record<string, unknown> | null;
+    success: boolean;
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionRuntime = void 0;
+// ─── Functions ─────────────────────────────────────────────────────────────
+var FunctionRuntime;
+(function (FunctionRuntime) {
+    FunctionRuntime["Deno"] = "deno";
+    FunctionRuntime["Dart"] = "dart";
+})(FunctionRuntime || (exports.FunctionRuntime = FunctionRuntime = {}));

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@techfinityedge/koolbase-react-native",
+  "version": "1.6.1",
+  "description": "React Native SDK for Koolbase — auth, database, storage, realtime, feature flags, and functions in one package.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "koolbase",
+    "react-native",
+    "baas",
+    "firebase-alternative",
+    "flutter"
+  ],
+  "author": "Kennedy Owusu",
+  "license": "MIT",
+  "homepage": "https://koolbase.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kennedyowusu/koolbase-react-native"
+  },
+  "devDependencies": {
+    "@types/jszip": "^3.4.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.70.0"
+  },
+  "dependencies": {
+    "@react-native-async-storage/async-storage": "^3.0.2",
+    "@react-native-community/netinfo": "^12.0.1",
+    "jszip": "^3.10.1"
+  },
+    "publishConfig": {
+    "access": "public"
+  }
+}