dolphin-server-modules 2.9.9 → 2.11.0

package/scripts/client.js

@@ -1,703 +0,0 @@
-/**
- * @typedef {Object} DolphinResponse
- * @property {boolean} success
- * @property {any} [data]
- * @property {string} [message]
- * @property {number} [status]
- */
-
-/**
- * @typedef {Object} SignalMessage
- * @property {string} msgId
- * @property {string} type
- * @property {string} from
- * @property {string} to
- * @property {any} data
- * @property {number} timestamp
- */
-
-/**
- * @typedef {Object} FileMetadata
- * @property {string} fileId
- * @property {string} name
- * @property {number} size
- * @property {number} totalChunks
- * @property {number} chunkSize
- */
-
-/**
- * @callback TopicCallback
- * @param {any} payload
- * @param {string} [topic]
- */
-
-/**
- * Dolphin Client v2.0 - Full-stack Realtime, API & Auth Client
- * Zero-dependency, pure JS.
- * 
- * यो लाइब्रेरी डल्फिन सर्भरबाट सिधै उपलब्ध हुने पब-सब, API र Auth लाइब्रेरी हो।
- */
-
-class APIHandler {
-    /**
-     * @param {DolphinClient} client
-     */
-    constructor(client) {
-        this.client = client;
-        return this._createProxy([]);
-    }
-
-    /**
-     * @param {string[]} pathParts
-     * @private
-     */
-    _createProxy(pathParts) {
-        const path = pathParts.join('/');
-
-        const target = (options) => {
-            return this.request('GET', path, null, options);
-        };
-
-        // Add standard methods to the function target
-        target.get = (pathOrOptions, options) => {
-            if (typeof pathOrOptions === 'string') return this.request('GET', pathOrOptions, null, options);
-            return this.request('GET', path, null, pathOrOptions);
-        };
-        target.post = (pathOrBody, bodyOrOptions, options) => {
-            if (typeof pathOrBody === 'string') return this.request('POST', pathOrBody, bodyOrOptions, options);
-            return this.request('POST', path, pathOrBody, bodyOrOptions);
-        };
-        target.put = (pathOrBody, bodyOrOptions, options) => {
-            if (typeof pathOrBody === 'string') return this.request('PUT', pathOrBody, bodyOrOptions, options);
-            return this.request('PUT', path, pathOrBody, bodyOrOptions);
-        };
-        target.del = (pathOrOptions, options) => {
-            if (typeof pathOrOptions === 'string') return this.request('DELETE', pathOrOptions, null, options);
-            return this.request('DELETE', path, null, pathOrOptions);
-        };
-        target.request = (method, subPath, body, options) => {
-            const finalPath = subPath ? `${path}/${subPath.startsWith('/') ? subPath.slice(1) : subPath}` : path;
-            return this.request(method, finalPath, body, options);
-        };
-
-        const methods = ['get', 'post', 'put', 'del', 'request'];
-
-        return new Proxy(target, {
-            get: (t, prop) => {
-                if (typeof prop === 'string' && !methods.includes(prop)) {
-                    return this._createProxy([...pathParts, prop]);
-                }
-                return t[prop];
-            }
-        });
-    }
-
-    /**
-     * @param {string} method
-     * @param {string} path
-     * @param {any} [body]
-     * @param {RequestInit} [options]
-     * @returns {Promise<any>}
-     */
-    async request(method, path, body = null, options = {}) {
-        const url = `${this.client.httpUrl}${path.startsWith('/') ? path : '/' + path}`;
-        const headers = {
-            'Content-Type': 'application/json',
-            ...options.headers
-        };
-
-        if (this.client.accessToken) {
-            headers['Authorization'] = `Bearer ${this.client.accessToken}`;
-        }
-
-        const fetchOptions = {
-            method,
-            headers,
-            ...options
-        };
-
-        if (body) {
-            fetchOptions.body = JSON.stringify(body);
-        }
-
-        const response = await fetch(url, fetchOptions);
-        const contentType = response.headers.get('content-type');
-        let data;
-        if (contentType && contentType.includes('application/json')) {
-            data = await response.json();
-        } else {
-            data = await response.text();
-        }
-
-        if (!response.ok) {
-            throw { status: response.status, data };
-        }
-
-        return data;
-    }
-
-    /**
-     * @param {string|RequestInit} [pathOrOptions]
-     * @param {RequestInit} [options]
-     * @returns {Promise<any>}
-     */
-    get(pathOrOptions, options) { return Promise.resolve(); }
-
-    /**
-     * @param {string|any} [pathOrBody]
-     * @param {any} [bodyOrOptions]
-     * @param {RequestInit} [options]
-     * @returns {Promise<any>}
-     */
-    post(pathOrBody, bodyOrOptions, options) { return Promise.resolve(); }
-
-    /**
-     * @param {string|any} [pathOrBody]
-     * @param {any} [bodyOrOptions]
-     * @param {RequestInit} [options]
-     * @returns {Promise<any>}
-     */
-    put(pathOrBody, bodyOrOptions, options) { return Promise.resolve(); }
-
-    /**
-     * @param {string|RequestInit} [pathOrOptions]
-     * @param {RequestInit} [options]
-     * @returns {Promise<any>}
-     */
-    del(pathOrOptions, options) { return Promise.resolve(); }
-}
-
-class AuthHandler {
-    /**
-     * @param {DolphinClient} client
-     */
-    constructor(client) {
-        this.client = client;
-        this.user = null;
-    }
-
-    async login(email, password) {
-        const res = await this.client.api.post('/auth/login', { email, password });
-        if (res.accessToken) {
-            this.client.setToken(res.accessToken);
-            this.user = res.user;
-        }
-        return res;
-    }
-
-    async register(data) {
-        return await this.client.api.post('/auth/register', data);
-    }
-
-    async me() {
-        const res = await this.client.api.get('/auth/me');
-        if (res.success) {
-            this.user = res.data;
-        }
-        return res;
-    }
-
-    async logout() {
-        await this.client.api.post('/auth/logout');
-        this.client.setToken(null);
-        this.user = null;
-    }
-
-    /** @param {string} email */
-    async forgotPassword(email) {
-        return await this.client.api.post('/auth/forgot-password', { email });
-    }
-}
-
-/**
- * DolphinStore - Reactive State Sync (Zustand Alternative)
- * Automatically syncs database collections with local state.
- */
-class DolphinStore {
-    /** @param {DolphinClient} client */
-    constructor(client) {
-        this.client = client;
-        /** @type {Map<string, { items: any[], loading: boolean, error: string|null, success: boolean }>} */
-        this.data = new Map();
-        /** @type {Set<function()>} */
-        this.listeners = new Set();
-        /** @type {Set<string>} */
-        this.subscribed = new Set();
-
-        return new Proxy(this, {
-            get: (target, prop) => {
-                if (prop in target) return target[prop];
-                if (typeof prop === 'string') {
-                    return this._getCollection(prop);
-                }
-            }
-        });
-    }
-
-    /** @private */
-    _getCollection(name) {
-        if (!this.data.has(name)) {
-            const collection = {
-                _rawItems: [],
-                items: [],
-                loading: true,
-                error: null,
-                success: false,
-                _filter: null,
-                _sort: null,
-
-                /**
-                 * फिल्टर सेट गर्ने (Local filtering)
-                 * @param {function(any): boolean} fn 
-                 */
-                where: (fn) => {
-                    collection._filter = fn;
-                    this._applyTransform(collection);
-                    return collection;
-                },
-
-                /**
-                 * सर्टिङ सेट गर्ने
-                 * @param {string} key 
-                 * @param {'asc'|'desc'} [direction] 
-                 */
-                orderBy: (key, direction = 'asc') => {
-                    collection._sort = { key, direction };
-                    this._applyTransform(collection);
-                    return collection;
-                },
-
-                /**
-                 * फिल्टर र सर्ट हटाउने
-                 */
-                clear: () => {
-                    collection._filter = null;
-                    collection._sort = null;
-                    this._applyTransform(collection);
-                    return collection;
-                }
-            };
-
-            this.data.set(name, collection);
-            this._fetchAndSync(name);
-        }
-        return this.data.get(name);
-    }
-
-    /** @private */
-    async _fetchAndSync(name) {
-        const state = this.data.get(name);
-        try {
-            // 1. Initial Fetch
-            const res = await this.client.api.get(`/${name.toLowerCase()}`);
-            state._rawItems = Array.isArray(res) ? res : (res.data || []);
-            state.loading = false;
-            state.success = true;
-            state.error = null;
-            this._applyTransform(state);
-
-            // 2. Realtime Sync (if connected)
-            if (!this.subscribed.has(name)) {
-                const topic = `db:sync/${name.toLowerCase()}`;
-                this.client.subscribe(topic, (update) => {
-                    this._handleRemoteUpdate(name, update);
-                });
-                this.subscribed.add(name);
-            }
-        } catch (e) {
-            state.loading = false;
-            state.success = false;
-            state.error = e.data?.error || e.message || 'Fetch failed';
-            this._notify();
-            console.error(`[DolphinStore] Sync failed for ${name}:`, e);
-        }
-    }
-
-    /** @private */
-    _applyTransform(state) {
-        let result = [...state._rawItems];
-
-        // 1. Filter
-        if (state._filter) {
-            result = result.filter(state._filter);
-        }
-
-        // 2. Sort
-        if (state._sort) {
-            const { key, direction } = state._sort;
-            result.sort((a, b) => {
-                const av = a[key];
-                const bv = b[key];
-                if (av === bv) return 0;
-                const compare = av > bv ? 1 : -1;
-                return direction === 'asc' ? compare : -compare;
-            });
-        }
-
-        state.items = result;
-        this._notify();
-    }
-
-    /** @private */
-    _handleRemoteUpdate(collection, update) {
-        const state = this.data.get(collection);
-        if (!state) return;
-
-        let items = state._rawItems;
-        const { type, data } = update; // type: 'create', 'update', 'delete'
-
-        if (type === 'create') {
-            items = [...items, data];
-        } else if (type === 'update') {
-            items = items.map(item => (item.id === data.id || item._id === data._id) ? { ...item, ...data } : item);
-        } else if (type === 'delete') {
-            items = items.filter(item => (item.id !== data.id && item._id !== data._id));
-        }
-
-        state._rawItems = items;
-        this._applyTransform(state);
-    }
-
-    /** Subscribe for React components (useSyncExternalStore) */
-    subscribe(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-
-    getSnapshot(collection) {
-        return this.data.get(collection) || { items: [], loading: false, error: null, success: false };
-    }
-
-    _notify() {
-        this.listeners.forEach(l => l());
-    }
-}
-
-class DolphinClient {
-    /**
-     * @param {string} [url]
-     * @param {string} [deviceId]
-     */
-    constructor(url = '', deviceId = '') {
-        // Handle URL formatting
-        if (!url && typeof window !== 'undefined') {
-            url = window.location.host;
-        }
-
-        let protocol = 'http:';
-        if (url && url.startsWith('https://')) {
-            protocol = 'https:';
-        } else if (url && url.startsWith('http://')) {
-            protocol = 'http:';
-        } else if (typeof window !== 'undefined') {
-            protocol = window.location.protocol;
-        }
-
-        this.host = (url || 'localhost').replace(/\/$/, "").replace(/^https?:\/\//, "");
-        this.httpUrl = `${protocol}//${this.host}`;
-        this.deviceId = deviceId || 'web_' + Math.random().toString(36).substr(2, 5);
-
-        /** @type {WebSocket | null} */
-        this.socket = null;
-
-        // Polyfill Storage if not browser
-        this.storage = typeof localStorage !== 'undefined' ? localStorage : {
-            getItem: (key) => null,
-            setItem: (key, val) => { },
-            removeItem: (key) => { }
-        };
-
-        /** @type {string | null} */
-        this.accessToken = this.storage.getItem('dolphin_token');
-
-        // Sub-handlers
-        this.api = new APIHandler(this);
-        this.auth = new AuthHandler(this);
-        this.store = new DolphinStore(this);
-
-        /** @type {Map<string, Set<TopicCallback>>} */
-        this.handlers = new Map(); // topic -> Set of callbacks
-        /** @type {Set<function(SignalMessage): void>} */
-        this.signalHandlers = new Set();
-        /** @type {Set<function(FileMetadata): void>} */
-        this.fileHandlers = new Set();
-
-        this.reconnectAttempts = 0;
-        this.maxReconnectAttempts = 5;
-    }
-
-    /**
-     * टोकन सेट गर्ने र सेभ गर्ने
-     */
-    setToken(token) {
-        this.accessToken = token;
-        if (token) {
-            this.storage.setItem('dolphin_token', token);
-        } else {
-            this.storage.removeItem('dolphin_token');
-        }
-    }
-
-    /**
-     * रियल-टाइम सर्भरसँग कनेक्शन सुरु गर्ने
-     * @returns {Promise<void>}
-     */
-    async connect() {
-        return new Promise((resolve, reject) => {
-            const protocol = this.httpUrl.startsWith('https') ? 'wss:' : 'ws:';
-            const wsUrl = `${protocol}//${this.host}/realtime?deviceId=${this.deviceId}`;
-
-            console.log(`[Dolphin] Connecting to ${wsUrl}...`);
-            this.socket = new WebSocket(wsUrl);
-
-            this.socket.onopen = () => {
-                console.log(`[Dolphin] Connected as "${this.deviceId}" 🐬`);
-                this.reconnectAttempts = 0;
-                resolve();
-            };
-
-            this.socket.onmessage = (event) => {
-                this._handleMessage(event.data);
-            };
-
-            this.socket.onclose = () => {
-                console.warn("[Dolphin] Connection closed");
-                this._maybeReconnect();
-            };
-
-            this.socket.onerror = (err) => {
-                console.error("[Dolphin] WebSocket Error:", err);
-                reject(err);
-            };
-        });
-    }
-
-    _handleMessage(data) {
-        try {
-            const parsed = JSON.parse(data);
-
-            // १. Signaling Messages
-            if (parsed.type && parsed.from && (parsed.to === this.deviceId || parsed.to === 'all')) {
-                // Auto-ACK for signaling messages
-                if (parsed.msgId && parsed.type !== 'ACK') {
-                    this._sendAck(parsed.from, parsed.msgId);
-                }
-                this.signalHandlers.forEach(handler => handler(parsed));
-            }
-
-            // २. File & Data Responses
-            if (parsed.type === 'FILE_AVAILABLE') {
-                this.fileHandlers.forEach(handler => handler(parsed));
-            }
-            if (parsed.type === 'FILE_CHUNK') {
-                this.saveFileProgress(parsed.fileId, parsed.chunkIndex);
-                this.handlers.forEach((callbacks, pattern) => {
-                    if (pattern === 'file:chunk' || pattern === `file:chunk/${parsed.fileId}`) {
-                        callbacks.forEach(cb => cb(parsed));
-                    }
-                });
-            }
-            if (parsed.type === 'PULL_RESPONSE') {
-                this.handlers.forEach((callbacks, pattern) => {
-                    if (pattern === 'pull:response' || pattern === `pull:response/${parsed.topic}`) {
-                        callbacks.forEach(cb => cb(parsed.payload, parsed.topic));
-                    }
-                });
-            }
-
-            // ३. Pub/Sub Messages
-            if (parsed.topic && parsed.payload !== undefined) {
-                const topic = parsed.topic;
-                this.handlers.forEach((callbacks, pattern) => {
-                    if (this._matchTopic(pattern, topic)) {
-                        callbacks.forEach(cb => cb(parsed.payload, topic));
-                    }
-                });
-            }
-        } catch (e) {
-            this.handlers.forEach((callbacks, pattern) => {
-                if (pattern === 'raw') callbacks.forEach(cb => cb(data));
-            });
-        }
-    }
-
-    /**
-     * @param {string} to
-     * @param {string} msgId
-     * @private
-     */
-    _sendAck(to, msgId) {
-        this.publish(`phone/signaling/${to}`, {
-            type: 'ACK',
-            from: this.deviceId,
-            to: to,
-            data: { ackId: msgId },
-            timestamp: Date.now()
-        });
-    }
-
-    _matchTopic(pattern, topic) {
-        if (pattern === topic || pattern === '#') return true;
-        const pParts = pattern.split('/');
-        const tParts = topic.split('/');
-        if (pParts.length !== tParts.length && !pattern.includes('#')) return false;
-        for (let i = 0; i < pParts.length; i++) {
-            if (pParts[i] === '#') return true;
-            if (pParts[i] !== '+' && pParts[i] !== tParts[i]) return false;
-        }
-        return pParts.length === tParts.length;
-    }
-
-    /**
-     * @param {string} topic
-     * @param {TopicCallback} callback
-     */
-    subscribe(topic, callback) {
-        if (!this.handlers.has(topic)) {
-            this.handlers.set(topic, new Set());
-            // Tell server we want to sub
-            if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-                this.socket.send(JSON.stringify({ type: 'sub', topic }));
-            }
-        }
-        this.handlers.get(topic).add(callback);
-    }
-
-    /**
-     * @param {string} topic
-     * @param {TopicCallback} callback
-     */
-    unsubscribe(topic, callback) {
-        if (this.handlers.has(topic)) {
-            const callbacks = this.handlers.get(topic);
-            callbacks.delete(callback);
-            if (callbacks.size === 0) {
-                this.handlers.delete(topic);
-                // Tell server we want to unsub
-                if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-                    this.socket.send(JSON.stringify({ type: 'unsub', topic }));
-                }
-            }
-        }
-    }
-
-    /**
-     * @param {string} topic
-     * @param {any} payload
-     */
-    publish(topic, payload) {
-        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-            this.socket.send(JSON.stringify({ topic, payload }));
-        }
-    }
-
-    /**
-     * High-frequency data push
-     * @param {string} topic
-     * @param {any} payload
-     */
-    pubPush(topic, payload) {
-        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-            this.socket.send(JSON.stringify({ type: 'pub', topic, payload }));
-        }
-    }
-
-    /**
-     * Request historical data from topic
-     * @param {string} topic
-     * @param {number} [count]
-     */
-    subPull(topic, count = 10) {
-        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-            this.socket.send(JSON.stringify({
-                type: 'PULL_REQUEST',
-                topic,
-                count
-            }));
-        }
-    }
-
-    /**
-     * Start downloading a file by chunks
-     * @param {string} fileId
-     * @param {number} [startChunk]
-     */
-    subFile(fileId, startChunk = 0) {
-        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
-            this.socket.send(JSON.stringify({
-                type: 'FILE_REQUEST',
-                fileId,
-                startChunk
-            }));
-        }
-    }
-
-    /**
-     * Resume a file download from last saved progress
-     * @param {string} fileId
-     */
-    resumeFile(fileId) {
-        const lastChunk = parseInt(localStorage.getItem(`dolphin_file_${fileId}`) || "-1");
-        this.subFile(fileId, lastChunk + 1);
-    }
-
-    /**
-     * Save download progress
-     * @param {string} fileId
-     * @param {number} chunkIndex
-     */
-    saveFileProgress(fileId, chunkIndex) {
-        this.storage.setItem(`dolphin_file_${fileId}`, chunkIndex.toString());
-    }
-
-    /**
-     * @param {function(SignalMessage): void} handler
-     */
-    onSignal(handler) {
-        this.signalHandlers.add(handler);
-    }
-
-    /**
-     * @param {function(SignalMessage): void} handler
-     */
-    offSignal(handler) {
-        this.signalHandlers.delete(handler);
-    }
-
-    /**
-     * @param {function(FileMetadata): void} handler
-     */
-    onFileAvailable(handler) {
-        this.fileHandlers.add(handler);
-    }
-
-    /**
-     * @param {function(FileMetadata): void} handler
-     */
-    offFileAvailable(handler) {
-        this.fileHandlers.delete(handler);
-    }
-
-    _maybeReconnect() {
-        if (this.reconnectAttempts < this.maxReconnectAttempts) {
-            this.reconnectAttempts++;
-            const delay = Math.pow(2, this.reconnectAttempts) * 1000;
-            setTimeout(() => this.connect(), delay);
-        }
-    }
-}
-
-// Browser Global Export
-if (typeof window !== 'undefined') {
-    // @ts-ignore
-    window.DolphinClient = DolphinClient;
-    // @ts-ignore
-    window.dolphin = new DolphinClient();
-}
-
-// NodeJS/CommonJS/ESM Export support
-if (typeof module !== 'undefined' && module.exports) {
-    module.exports = { DolphinClient };
-}
-
-export { DolphinClient };