mongo.do 0.1.0 → 0.1.1

package/dist/rpc/rpc-client.js

@@ -1,735 +0,0 @@
-/**
- * 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