@push.rocks/smartdb 1.0.1 → 2.1.1

package/ts/ts_smartdb/server/SmartdbServer.ts

@@ -1,11 +1,13 @@
-import * as net from 'net';
-import * as fs from 'fs/promises';
-import * as plugins from '../plugins.js';
-import { WireProtocol, OP_QUERY } from './WireProtocol.js';
-import { CommandRouter } from './CommandRouter.js';
-import { MemoryStorageAdapter } from '../storage/MemoryStorageAdapter.js';
-import { FileStorageAdapter } from '../storage/FileStorageAdapter.js';
-import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
+import { RustDbBridge } from '../rust-db-bridge.js';
+import type {
+  IOpLogEntry,
+  IOpLogResult,
+  IOpLogStats,
+  IRevertResult,
+  ICollectionInfo,
+  IDocumentsResult,
+  ISmartDbMetrics,
+} from '../rust-db-bridge.js';
 
 /**
  * Server configuration options
@@ -28,90 +30,41 @@ export interface ISmartdbServerOptions {
 }
 
 /**
- * Connection state for each client
- */
-interface IConnectionState {
-  id: number;
-  socket: net.Socket;
-  buffer: Buffer;
-  authenticated: boolean;
-  database: string;
-}
-
-/**
- * SmartdbServer - MongoDB Wire Protocol compatible server
+ * SmartdbServer - Wire protocol compatible database server backed by Rust
  *
- * This server implements the MongoDB wire protocol (OP_MSG) to allow
- * official MongoDB drivers to connect and perform operations.
+ * This server implements the wire protocol to allow official drivers to
+ * connect and perform operations. The core engine runs as a Rust sidecar
+ * binary managed via @push.rocks/smartrust IPC.
  *
  * @example
  * ```typescript
- * import { SmartdbServer } from '@push.rocks/smartmongo/smartdb';
+ * import { SmartdbServer } from '@push.rocks/smartdb';
  * import { MongoClient } from 'mongodb';
  *
  * const server = new SmartdbServer({ port: 27017 });
  * await server.start();
  *
- * const client = new MongoClient('mongodb://127.0.0.1:27017');
+ * const client = new MongoClient(server.getConnectionUri());
  * await client.connect();
  * ```
  */
 export class SmartdbServer {
-  private options: Required<Omit<ISmartdbServerOptions, 'socketPath'>> & { socketPath: string };
-  private server: net.Server | null = null;
-  private storage: IStorageAdapter;
-  private commandRouter: CommandRouter;
-  private connections: Map<number, IConnectionState> = new Map();
-  private connectionIdCounter = 0;
+  private options: ISmartdbServerOptions;
+  private bridge: RustDbBridge;
   private isRunning = false;
-  private startTime: Date = new Date();
-  private useSocket: boolean;
+  private resolvedConnectionUri = '';
 
   constructor(options: ISmartdbServerOptions = {}) {
-    this.useSocket = !!options.socketPath;
     this.options = {
       port: options.port ?? 27017,
       host: options.host ?? '127.0.0.1',
-      socketPath: options.socketPath ?? '',
+      socketPath: options.socketPath,
       storage: options.storage ?? 'memory',
       storagePath: options.storagePath ?? './data',
-      persistPath: options.persistPath ?? '',
+      persistPath: options.persistPath,
       persistIntervalMs: options.persistIntervalMs ?? 60000,
     };
-
-    // Create storage adapter
-    if (this.options.storage === 'file') {
-      this.storage = new FileStorageAdapter(this.options.storagePath);
-    } else {
-      this.storage = new MemoryStorageAdapter({
-        persistPath: this.options.persistPath || undefined,
-        persistIntervalMs: this.options.persistPath ? this.options.persistIntervalMs : undefined,
-      });
-    }
-
-    // Create command router
-    this.commandRouter = new CommandRouter(this.storage, this);
-  }
-
-  /**
-   * Get the storage adapter (for testing/debugging)
-   */
-  getStorage(): IStorageAdapter {
-    return this.storage;
-  }
-
-  /**
-   * Get server uptime in seconds
-   */
-  getUptime(): number {
-    return Math.floor((Date.now() - this.startTime.getTime()) / 1000);
-  }
-
-  /**
-   * Get current connection count
-   */
-  getConnectionCount(): number {
-    return this.connections.size;
+    this.bridge = new RustDbBridge();
   }
 
   /**
@@ -122,233 +75,149 @@ export class SmartdbServer {
       throw new Error('Server is already running');
     }
 
-    // Initialize storage
-    await this.storage.initialize();
-
-    // Clean up stale socket file if using Unix socket
-    if (this.useSocket && this.options.socketPath) {
-      try {
-        await fs.unlink(this.options.socketPath);
-      } catch (err: any) {
-        // Ignore ENOENT (file doesn't exist)
-        if (err.code !== 'ENOENT') {
-          throw err;
-        }
-      }
+    const spawned = await this.bridge.spawn();
+    if (!spawned) {
+      throw new Error(
+        'smartdb Rust binary not found. Set SMARTDB_RUST_BINARY env var, ' +
+        'install the platform package, or build locally with `tsrust`.'
+      );
     }
 
-    return new Promise((resolve, reject) => {
-      this.server = net.createServer((socket) => {
-        this.handleConnection(socket);
-      });
-
-      this.server.on('error', (err) => {
-        if (!this.isRunning) {
-          reject(err);
-        } else {
-          console.error('Server error:', err);
-        }
-      });
-
-      if (this.useSocket && this.options.socketPath) {
-        // Listen on Unix socket
-        this.server.listen(this.options.socketPath, () => {
-          this.isRunning = true;
-          this.startTime = new Date();
-          resolve();
-        });
-      } else {
-        // Listen on TCP
-        this.server.listen(this.options.port, this.options.host, () => {
-          this.isRunning = true;
-          this.startTime = new Date();
-          resolve();
-        });
+    // Forward unexpected exit
+    this.bridge.on('exit', (code: number | null, signal: string | null) => {
+      if (this.isRunning) {
+        console.error(`smartdb Rust process exited unexpectedly (code=${code}, signal=${signal})`);
       }
     });
+
+    // Send config, get back connectionUri
+    const result = await this.bridge.startDb({
+      port: this.options.port,
+      host: this.options.host,
+      socketPath: this.options.socketPath,
+      storage: this.options.storage ?? 'memory',
+      storagePath: this.options.storagePath,
+      persistPath: this.options.persistPath,
+      persistIntervalMs: this.options.persistIntervalMs,
+    });
+
+    this.resolvedConnectionUri = result.connectionUri;
+    this.isRunning = true;
   }
 
   /**
    * Stop the server
    */
   async stop(): Promise<void> {
-    if (!this.isRunning || !this.server) {
+    if (!this.isRunning) {
       return;
     }
 
-    // Close all connections
-    for (const conn of this.connections.values()) {
-      conn.socket.destroy();
+    try {
+      await this.bridge.stopDb();
+    } catch {
+      // Bridge may already be dead
     }
-    this.connections.clear();
-
-    // Close command router (cleans up session engine, cursors, etc.)
-    this.commandRouter.close();
-
-    // Close storage
-    await this.storage.close();
 
-    return new Promise((resolve) => {
-      this.server!.close(async () => {
-        this.isRunning = false;
-        this.server = null;
-
-        // Clean up socket file if using Unix socket
-        if (this.useSocket && this.options.socketPath) {
-          try {
-            await fs.unlink(this.options.socketPath);
-          } catch (err: any) {
-            // Ignore ENOENT (file doesn't exist)
-            if (err.code !== 'ENOENT') {
-              console.error('Failed to remove socket file:', err);
-            }
-          }
-        }
-
-        resolve();
-      });
-    });
+    this.bridge.kill();
+    this.isRunning = false;
   }
 
   /**
-   * Handle a new client connection
+   * Get the connection URI for this server
    */
-  private handleConnection(socket: net.Socket): void {
-    const connectionId = ++this.connectionIdCounter;
-
-    const state: IConnectionState = {
-      id: connectionId,
-      socket,
-      buffer: Buffer.alloc(0),
-      authenticated: true, // No auth required for now
-      database: 'test',
-    };
-
-    this.connections.set(connectionId, state);
-
-    socket.on('data', (data) => {
-      this.handleData(state, Buffer.isBuffer(data) ? data : Buffer.from(data));
-    });
-
-    socket.on('close', () => {
-      this.connections.delete(connectionId);
-    });
-
-    socket.on('error', (err) => {
-      // Connection errors are expected when clients disconnect
-      this.connections.delete(connectionId);
-    });
+  getConnectionUri(): string {
+    if (this.resolvedConnectionUri) {
+      return this.resolvedConnectionUri;
+    }
+    // Fallback: compute from options
+    if (this.options.socketPath) {
+      const encodedPath = encodeURIComponent(this.options.socketPath);
+      return `mongodb://${encodedPath}`;
+    }
+    return `mongodb://${this.options.host ?? '127.0.0.1'}:${this.options.port ?? 27017}`;
   }
 
   /**
-   * Handle incoming data from a client
+   * Get the socket path (if using Unix socket mode)
    */
-  private handleData(state: IConnectionState, data: Buffer): void {
-    // Append new data to buffer
-    state.buffer = Buffer.concat([state.buffer, data]);
-
-    // Process messages from buffer
-    this.processMessages(state);
+  get socketPath(): string | undefined {
+    return this.options.socketPath;
   }
 
   /**
-   * Process complete messages from the buffer
+   * Check if the server is running
    */
-  private async processMessages(state: IConnectionState): Promise<void> {
-    while (state.buffer.length >= 16) {
-      try {
-        const result = WireProtocol.parseMessage(state.buffer);
-
-        if (!result) {
-          // Not enough data for a complete message
-          break;
-        }
-
-        const { command, bytesConsumed } = result;
-
-        // Remove processed bytes from buffer
-        state.buffer = state.buffer.subarray(bytesConsumed);
-
-        // Process the command
-        const response = await this.commandRouter.route(command);
+  get running(): boolean {
+    return this.isRunning;
+  }
 
-        // Encode and send response
-        let responseBuffer: Buffer;
-        if (command.opCode === OP_QUERY) {
-          // Legacy OP_QUERY gets OP_REPLY response
-          responseBuffer = WireProtocol.encodeOpReplyResponse(
-            command.requestID,
-            [response]
-          );
-        } else {
-          // OP_MSG gets OP_MSG response
-          responseBuffer = WireProtocol.encodeOpMsgResponse(
-            command.requestID,
-            response
-          );
-        }
+  /**
+   * Get the port the server is listening on
+   */
+  get port(): number {
+    return this.options.port ?? 27017;
+  }
 
-        if (!state.socket.destroyed) {
-          state.socket.write(responseBuffer);
-        }
-      } catch (error: any) {
-        // Send error response
-        const errorResponse = WireProtocol.encodeErrorResponse(
-          0, // We don't have the requestID at this point
-          1,
-          error.message || 'Internal error'
-        );
+  /**
+   * Get the host the server is bound to
+   */
+  get host(): string {
+    return this.options.host ?? '127.0.0.1';
+  }
 
-        if (!state.socket.destroyed) {
-          state.socket.write(errorResponse);
-        }
+  // --- OpLog / Debug API ---
 
-        // Clear buffer on parse errors to avoid infinite loops
-        if (error.message?.includes('opCode') || error.message?.includes('section')) {
-          state.buffer = Buffer.alloc(0);
-        }
-        break;
-      }
-    }
+  /**
+   * Get oplog entries, optionally filtered.
+   */
+  async getOpLog(params: {
+    sinceSeq?: number;
+    limit?: number;
+    db?: string;
+    collection?: string;
+  } = {}): Promise<IOpLogResult> {
+    return this.bridge.getOpLog(params);
   }
 
   /**
-   * Get the connection URI for this server
+   * Get aggregate oplog statistics.
    */
-  getConnectionUri(): string {
-    if (this.useSocket && this.options.socketPath) {
-      // URL-encode the socket path (replace / with %2F)
-      const encodedPath = encodeURIComponent(this.options.socketPath);
-      return `mongodb://${encodedPath}`;
-    }
-    return `mongodb://${this.options.host}:${this.options.port}`;
+  async getOpLogStats(): Promise<IOpLogStats> {
+    return this.bridge.getOpLogStats();
   }
 
   /**
-   * Get the socket path (if using Unix socket mode)
+   * Revert database state to a specific oplog sequence number.
+   * Use dryRun=true to preview which entries would be reverted.
    */
-  get socketPath(): string | undefined {
-    return this.useSocket ? this.options.socketPath : undefined;
+  async revertToSeq(seq: number, dryRun = false): Promise<IRevertResult> {
+    return this.bridge.revertToSeq(seq, dryRun);
   }
 
   /**
-   * Check if the server is running
+   * List all collections across all databases, with document counts.
    */
-  get running(): boolean {
-    return this.isRunning;
+  async getCollections(db?: string): Promise<ICollectionInfo[]> {
+    return this.bridge.getCollections(db);
   }
 
   /**
-   * Get the port the server is listening on
+   * Get documents from a collection with pagination.
    */
-  get port(): number {
-    return this.options.port;
+  async getDocuments(
+    db: string,
+    collection: string,
+    limit = 50,
+    skip = 0,
+  ): Promise<IDocumentsResult> {
+    return this.bridge.getDocuments(db, collection, limit, skip);
   }
 
   /**
-   * Get the host the server is bound to
+   * Get server metrics including database/collection counts and oplog info.
    */
-  get host(): string {
-    return this.options.host;
+  async getMetrics(): Promise<ISmartDbMetrics> {
+    return this.bridge.getMetrics();
   }
 }

package/ts/ts_smartdb/server/index.ts

@@ -1,10 +1,3 @@
 // Server module exports
-
 export { SmartdbServer } from './SmartdbServer.js';
 export type { ISmartdbServerOptions } from './SmartdbServer.js';
-export { WireProtocol } from './WireProtocol.js';
-export { CommandRouter } from './CommandRouter.js';
-export type { ICommandHandler, IHandlerContext, ICursorState } from './CommandRouter.js';
-
-// Export handlers
-export * from './handlers/index.js';

package/dist_ts/ts_smartdb/engine/AggregationEngine.d.ts

@@ -1,66 +0,0 @@
-import type { Document, IStoredDocument, IAggregateOptions } from '../types/interfaces.js';
-/**
- * Aggregation engine using mingo for MongoDB-compatible aggregation pipeline execution
- */
-export declare class AggregationEngine {
-    /**
-     * Execute an aggregation pipeline on a collection of documents
-     */
-    static aggregate(documents: IStoredDocument[], pipeline: Document[], options?: IAggregateOptions): Document[];
-    /**
-     * Execute aggregation and return an iterator for lazy evaluation
-     */
-    static aggregateIterator(documents: IStoredDocument[], pipeline: Document[], options?: IAggregateOptions): Generator<Document>;
-    /**
-     * Execute a $lookup stage manually (for cross-collection lookups)
-     * This is used when the lookup references another collection in the same database
-     */
-    static executeLookup(documents: IStoredDocument[], lookupSpec: {
-        from: string;
-        localField: string;
-        foreignField: string;
-        as: string;
-    }, foreignCollection: IStoredDocument[]): Document[];
-    /**
-     * Execute a $graphLookup stage manually
-     */
-    static executeGraphLookup(documents: IStoredDocument[], graphLookupSpec: {
-        from: string;
-        startWith: string | Document;
-        connectFromField: string;
-        connectToField: string;
-        as: string;
-        maxDepth?: number;
-        depthField?: string;
-        restrictSearchWithMatch?: Document;
-    }, foreignCollection: IStoredDocument[]): Document[];
-    /**
-     * Execute a $facet stage manually
-     */
-    static executeFacet(documents: IStoredDocument[], facetSpec: Record<string, Document[]>): Document;
-    /**
-     * Execute a $unionWith stage
-     */
-    static executeUnionWith(documents: IStoredDocument[], otherDocuments: IStoredDocument[], pipeline?: Document[]): Document[];
-    /**
-     * Execute a $merge stage (output to another collection)
-     * Returns the documents that would be inserted/updated
-     */
-    static prepareMerge(documents: Document[], mergeSpec: {
-        into: string;
-        on?: string | string[];
-        whenMatched?: 'replace' | 'keepExisting' | 'merge' | 'fail' | Document[];
-        whenNotMatched?: 'insert' | 'discard' | 'fail';
-    }): {
-        toInsert: Document[];
-        toUpdate: Array<{
-            filter: Document;
-            update: Document;
-        }>;
-        onField: string | string[];
-        whenMatched: string | Document[];
-        whenNotMatched: string;
-    };
-    private static getNestedValue;
-    private static valuesMatch;
-}