mongo.do 0.1.0

package/dist/rpc/rpc-client.js

@@ -0,0 +1,735 @@
+/**
+ * RPC Client - Client-side RPC handler for capnweb-style Workers RPC
+ *
+ * Implements:
+ * - HTTP batch protocol
+ * - WebSocket sessions
+ * - Auto-reconnection
+ * - Request deduplication
+ */
+/**
+ * Deduplicates identical concurrent requests
+ */
+export class RequestDeduplicator {
+    cache = new Map();
+    ttl;
+    cleanupInterval = null;
+    constructor(options = {}) {
+        this.ttl = options.ttl ?? 1000;
+        this.startCleanup();
+    }
+    /**
+     * Start the cleanup interval
+     */
+    startCleanup() {
+        this.cleanupInterval = setInterval(() => {
+            this.cleanup();
+        }, this.ttl);
+    }
+    /**
+     * Stop the cleanup interval
+     */
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+    }
+    /**
+     * Clean up expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache) {
+            if (now - entry.timestamp > this.ttl) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+     * Check if a key exists and is not expired
+     */
+    has(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return false;
+        if (Date.now() - entry.timestamp > this.ttl) {
+            this.cache.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Get a cached promise
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() - entry.timestamp > this.ttl) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.promise;
+    }
+    /**
+     * Set a promise for a key
+     */
+    set(key, promise) {
+        this.cache.set(key, { promise, timestamp: Date.now() });
+    }
+    /**
+     * Generate a cache key from method and params
+     */
+    static generateKey(method, params) {
+        return `${method}:${JSON.stringify(params)}`;
+    }
+}
+// ============================================================================
+// WebSocket RPC Transport
+// ============================================================================
+/**
+ * WebSocket-based RPC transport
+ */
+export class WebSocketRpcTransport {
+    ws;
+    messageId = 0;
+    pending = new Map();
+    messageHandlers = new Set();
+    options;
+    constructor(ws, options) {
+        this.ws = ws;
+        this.options = options ?? {};
+        this.setupMessageHandler();
+    }
+    /**
+     * Set up the WebSocket message handler
+     */
+    setupMessageHandler() {
+        this.ws.addEventListener('message', (event) => {
+            try {
+                const data = JSON.parse(event.data);
+                this.handleMessage(data);
+            }
+            catch {
+                // Ignore parse errors
+            }
+        });
+    }
+    /**
+     * Handle incoming message
+     */
+    handleMessage(data) {
+        // Notify all message handlers
+        this.messageHandlers.forEach((handler) => handler(data));
+        // Resolve pending requests
+        if (data.id) {
+            const pending = this.pending.get(data.id);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pending.delete(data.id);
+                if (data.error) {
+                    pending.reject(new Error(data.error));
+                }
+                else {
+                    pending.resolve(data.result);
+                }
+            }
+        }
+    }
+    /**
+     * Send a request over WebSocket
+     */
+    send(request) {
+        const id = String(++this.messageId);
+        const fullRequest = { ...request, id };
+        return new Promise((resolve, reject) => {
+            if (this.ws.readyState !== WebSocket.OPEN) {
+                reject(new Error('WebSocket is not open'));
+                return;
+            }
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error('Request timeout'));
+            }, this.options?.timeout ?? 30000);
+            this.pending.set(id, { resolve, reject, timeout });
+            this.ws.send(JSON.stringify(fullRequest));
+        });
+    }
+    /**
+     * Add a message handler for streaming responses
+     */
+    onMessage(handler) {
+        this.messageHandlers.add(handler);
+        return () => this.messageHandlers.delete(handler);
+    }
+    /**
+     * Close the connection
+     */
+    close() {
+        this.ws.close();
+    }
+    /**
+     * Get connection state
+     */
+    get readyState() {
+        return this.ws.readyState;
+    }
+}
+// ============================================================================
+// RPC Client
+// ============================================================================
+let requestIdCounter = 0;
+/**
+ * RPC client for connecting to Mondo workers
+ */
+export class RpcClient {
+    url;
+    options;
+    transport;
+    eventHandlers = new Map();
+    batchMode = false;
+    batchQueue = [];
+    deduplicator = null;
+    wsTransport = null;
+    constructor(url, options = {}) {
+        this.url = url;
+        this.options = {
+            autoReconnect: options.autoReconnect ?? false,
+            maxRetries: options.maxRetries ?? 3,
+            reconnectInterval: options.reconnectInterval ?? 1000,
+            deduplicate: options.deduplicate ?? false,
+            deduplicationTtl: options.deduplicationTtl ?? 1000,
+            timeout: options.timeout ?? 30000,
+        };
+        // Determine transport based on URL
+        this.transport = url.startsWith('ws://') || url.startsWith('wss://') ? 'websocket' : 'http';
+        // Set up deduplication if enabled
+        if (this.options.deduplicate) {
+            this.deduplicator = new RequestDeduplicator({ ttl: this.options.deduplicationTtl });
+        }
+    }
+    /**
+     * Make an RPC call
+     */
+    async call(method, params) {
+        const request = {
+            id: String(++requestIdCounter),
+            method,
+            params,
+        };
+        // Check deduplication cache
+        if (this.deduplicator) {
+            const key = RequestDeduplicator.generateKey(method, params);
+            const cached = this.deduplicator.get(key);
+            if (cached) {
+                return cached;
+            }
+            const promise = this.executeCall(request);
+            this.deduplicator.set(key, promise);
+            return promise;
+        }
+        return this.executeCall(request);
+    }
+    /**
+     * Execute the actual RPC call
+     */
+    async executeCall(request) {
+        // If in batch mode, queue the request
+        if (this.batchMode) {
+            return new Promise((resolve, reject) => {
+                this.batchQueue.push({ request, resolve, reject });
+            });
+        }
+        // Use WebSocket transport if available
+        if (this.transport === 'websocket' && this.wsTransport) {
+            return this.wsTransport.send(request);
+        }
+        // HTTP transport with retry logic
+        return this.executeWithRetry(request);
+    }
+    /**
+     * Execute with retry logic
+     */
+    async executeWithRetry(request, attempt = 1) {
+        try {
+            const response = await fetch(this.url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(request),
+                signal: AbortSignal.timeout(this.options.timeout),
+            });
+            const data = await response.json();
+            if (data.error) {
+                throw new Error(data.error);
+            }
+            return data.result ?? data;
+        }
+        catch (error) {
+            if (this.options.autoReconnect && attempt < this.options.maxRetries) {
+                // Wait before retrying
+                await new Promise((resolve) => setTimeout(resolve, this.options.reconnectInterval));
+                this.emit('reconnect', { attempt });
+                return this.executeWithRetry(request, attempt + 1);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Start batch mode
+     */
+    startBatch() {
+        this.batchMode = true;
+        this.batchQueue = [];
+    }
+    /**
+     * End batch mode and send all queued requests
+     */
+    async endBatch() {
+        this.batchMode = false;
+        if (this.batchQueue.length === 0) {
+            return;
+        }
+        const batch = [...this.batchQueue];
+        this.batchQueue = [];
+        try {
+            const response = await fetch(`${this.url}/batch`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(batch.map((item) => item.request)),
+                signal: AbortSignal.timeout(this.options.timeout),
+            });
+            const data = await response.json();
+            batch.forEach((item, index) => {
+                const result = data.results[index];
+                if (result) {
+                    if (result.error) {
+                        item.reject(new Error(result.error));
+                    }
+                    else {
+                        item.resolve(result.result);
+                    }
+                }
+                else {
+                    item.reject(new Error('Missing result for batch item'));
+                }
+            });
+        }
+        catch (error) {
+            // Reject all queued requests
+            batch.forEach((item) => {
+                item.reject(error instanceof Error ? error : new Error('Unknown error'));
+            });
+        }
+    }
+    /**
+     * Register an event handler
+     */
+    on(event, handler) {
+        let handlers = this.eventHandlers.get(event);
+        if (!handlers) {
+            handlers = new Set();
+            this.eventHandlers.set(event, handlers);
+        }
+        handlers.add(handler);
+    }
+    /**
+     * Remove an event handler
+     */
+    off(event, handler) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            handlers.delete(handler);
+        }
+    }
+    /**
+     * Emit an event
+     */
+    emit(event, data) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            handlers.forEach((handler) => handler(data));
+        }
+    }
+    /**
+     * Connect via WebSocket
+     */
+    async connectWebSocket() {
+        if (this.transport !== 'websocket') {
+            throw new Error('Cannot connect WebSocket for HTTP transport');
+        }
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(this.url);
+            ws.addEventListener('open', () => {
+                this.wsTransport = new WebSocketRpcTransport(ws, { timeout: this.options.timeout });
+                resolve();
+            });
+            ws.addEventListener('error', (_event) => {
+                reject(new Error('WebSocket connection failed'));
+            });
+            ws.addEventListener('close', () => {
+                this.wsTransport = null;
+                if (this.options.autoReconnect) {
+                    setTimeout(() => this.connectWebSocket(), this.options.reconnectInterval);
+                }
+            });
+        });
+    }
+    /**
+     * Close the client connection
+     */
+    close() {
+        if (this.wsTransport) {
+            this.wsTransport.close();
+            this.wsTransport = null;
+        }
+        if (this.deduplicator) {
+            this.deduplicator.destroy();
+            this.deduplicator = null;
+        }
+    }
+}
+// ============================================================================
+// MongoClient wrapper
+// ============================================================================
+/**
+ * MongoDB-compatible client wrapper over RPC
+ */
+export class MongoClient {
+    client;
+    isConnected = false;
+    dbName = null;
+    constructor(url, options = {}) {
+        // Convert MongoDB URL to RPC endpoint URL
+        const rpcUrl = this.parseMongoUrl(url);
+        this.client = new RpcClient(rpcUrl, options);
+    }
+    /**
+     * Parse MongoDB URL to extract RPC endpoint
+     */
+    parseMongoUrl(url) {
+        // Extract host from mongodb:// URL
+        const parsed = new URL(url.replace('mongodb://', 'http://'));
+        this.dbName = parsed.pathname.slice(1) || null;
+        return `http://${parsed.host}/rpc`;
+    }
+    /**
+     * Connect to the database
+     */
+    async connect() {
+        if (!this.dbName) {
+            throw new Error('No database specified in connection string');
+        }
+        await this.client.call('connect', [`mongodb://localhost/${this.dbName}`]);
+        this.isConnected = true;
+        return this;
+    }
+    /**
+     * Get a database reference
+     */
+    db(name) {
+        const dbName = name || this.dbName;
+        if (!dbName) {
+            throw new Error('No database specified');
+        }
+        return new Database(this.client, dbName);
+    }
+    /**
+     * Close the connection
+     */
+    close() {
+        this.client.close();
+        this.isConnected = false;
+    }
+    /**
+     * Check if connected
+     */
+    get connected() {
+        return this.isConnected;
+    }
+}
+/**
+ * Database reference
+ */
+class Database {
+    client;
+    name;
+    constructor(client, name) {
+        this.client = client;
+        this.name = name;
+    }
+    /**
+     * Get a collection reference
+     */
+    collection(name) {
+        return new Collection(this.client, this.name, name);
+    }
+}
+/**
+ * RPC Find Cursor - Simple cursor for RPC-based find operations
+ */
+class RpcFindCursor {
+    client;
+    dbName;
+    collectionName;
+    query;
+    _sort;
+    _limit;
+    _skip;
+    _projection;
+    _buffer = [];
+    _position = 0;
+    _fetched = false;
+    _closed = false;
+    constructor(client, dbName, collectionName, query = {}) {
+        this.client = client;
+        this.dbName = dbName;
+        this.collectionName = collectionName;
+        this.query = query;
+    }
+    get closed() {
+        return this._closed;
+    }
+    sort(spec) {
+        this._sort = spec;
+        return this;
+    }
+    limit(count) {
+        if (count < 0)
+            throw new Error('Limit must be non-negative');
+        this._limit = count;
+        return this;
+    }
+    skip(count) {
+        if (count < 0)
+            throw new Error('Skip must be non-negative');
+        this._skip = count;
+        return this;
+    }
+    project(spec) {
+        this._projection = spec;
+        return this;
+    }
+    async ensureFetched() {
+        if (this._fetched || this._closed)
+            return;
+        const options = {};
+        if (this._sort)
+            options.sort = this._sort;
+        if (this._limit !== undefined)
+            options.limit = this._limit;
+        if (this._skip !== undefined)
+            options.skip = this._skip;
+        if (this._projection)
+            options.projection = this._projection;
+        this._buffer = await this.client.call('find', [
+            this.dbName,
+            this.collectionName,
+            this.query,
+            options
+        ]);
+        this._fetched = true;
+    }
+    async next() {
+        if (this._closed)
+            return null;
+        await this.ensureFetched();
+        if (this._position >= this._buffer.length)
+            return null;
+        return this._buffer[this._position++] ?? null;
+    }
+    async hasNext() {
+        if (this._closed)
+            return false;
+        await this.ensureFetched();
+        return this._position < this._buffer.length;
+    }
+    async toArray() {
+        if (this._closed)
+            return [];
+        await this.ensureFetched();
+        const remaining = this._buffer.slice(this._position);
+        this._position = this._buffer.length;
+        await this.close();
+        return remaining;
+    }
+    async forEach(callback) {
+        if (this._closed)
+            return;
+        await this.ensureFetched();
+        let index = 0;
+        while (this._position < this._buffer.length) {
+            const doc = this._buffer[this._position++];
+            if (doc !== undefined) {
+                const result = await callback(doc, index++);
+                if (result === false)
+                    break;
+            }
+        }
+    }
+    async count() {
+        await this.ensureFetched();
+        return this._buffer.length - this._position;
+    }
+    async close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this._buffer = [];
+        this._position = 0;
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            while (await this.hasNext()) {
+                const doc = await this.next();
+                if (doc !== null)
+                    yield doc;
+            }
+        }
+        finally {
+            await this.close();
+        }
+    }
+}
+/**
+ * RPC Aggregation Cursor - Simple cursor for RPC-based aggregate operations
+ */
+class RpcAggregationCursor {
+    client;
+    dbName;
+    collectionName;
+    pipeline;
+    options;
+    _buffer = [];
+    _position = 0;
+    _fetched = false;
+    _closed = false;
+    constructor(client, dbName, collectionName, pipeline = [], options = {}) {
+        this.client = client;
+        this.dbName = dbName;
+        this.collectionName = collectionName;
+        this.pipeline = pipeline;
+        this.options = options;
+    }
+    get closed() {
+        return this._closed;
+    }
+    async ensureFetched() {
+        if (this._fetched || this._closed)
+            return;
+        this._buffer = await this.client.call('aggregate', [
+            this.dbName,
+            this.collectionName,
+            this.pipeline,
+            this.options
+        ]);
+        this._fetched = true;
+    }
+    async next() {
+        if (this._closed)
+            return null;
+        await this.ensureFetched();
+        if (this._position >= this._buffer.length)
+            return null;
+        return this._buffer[this._position++] ?? null;
+    }
+    async hasNext() {
+        if (this._closed)
+            return false;
+        await this.ensureFetched();
+        return this._position < this._buffer.length;
+    }
+    async toArray() {
+        if (this._closed)
+            return [];
+        await this.ensureFetched();
+        const remaining = this._buffer.slice(this._position);
+        this._position = this._buffer.length;
+        await this.close();
+        return remaining;
+    }
+    async forEach(callback) {
+        if (this._closed)
+            return;
+        await this.ensureFetched();
+        let index = 0;
+        while (this._position < this._buffer.length) {
+            const doc = this._buffer[this._position++];
+            if (doc !== undefined) {
+                const result = await callback(doc, index++);
+                if (result === false)
+                    break;
+            }
+        }
+    }
+    async close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        this._buffer = [];
+        this._position = 0;
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            while (await this.hasNext()) {
+                const doc = await this.next();
+                if (doc !== null)
+                    yield doc;
+            }
+        }
+        finally {
+            await this.close();
+        }
+    }
+}
+/**
+ * Collection reference
+ */
+class Collection {
+    client;
+    dbName;
+    collectionName;
+    constructor(client, dbName, collectionName) {
+        this.client = client;
+        this.dbName = dbName;
+        this.collectionName = collectionName;
+    }
+    /**
+     * Find documents - returns a cursor
+     */
+    find(query = {}) {
+        return new RpcFindCursor(this.client, this.dbName, this.collectionName, query);
+    }
+    /**
+     * Find one document
+     */
+    async findOne(query = {}) {
+        const cursor = this.find(query).limit(1);
+        return cursor.next();
+    }
+    /**
+     * Aggregate pipeline - returns a cursor
+     */
+    aggregate(pipeline = [], options = {}) {
+        return new RpcAggregationCursor(this.client, this.dbName, this.collectionName, pipeline, options);
+    }
+    /**
+     * Insert one document
+     */
+    async insertOne(document) {
+        return this.client.call('insertOne', [this.dbName, this.collectionName, document]);
+    }
+    /**
+     * Update one document
+     */
+    async updateOne(filter, update) {
+        return this.client.call('updateOne', [this.dbName, this.collectionName, filter, update]);
+    }
+    /**
+     * Delete one document
+     */
+    async deleteOne(filter) {
+        return this.client.call('deleteOne', [this.dbName, this.collectionName, filter]);
+    }
+}
+//# sourceMappingURL=rpc-client.js.map