@push.rocks/smartdb 1.0.1 → 2.1.1

package/ts/ts_smartdb/index.ts

@@ -1,46 +1,19 @@
-// SmartDB - MongoDB Wire Protocol compatible in-memory database server
-// Use the official MongoDB driver to connect to SmartdbServer
-
-// Re-export plugins for external use
-import * as plugins from './plugins.js';
-export { plugins };
-
-// Export BSON types for convenience
-export { ObjectId, Binary, Timestamp, Long, Decimal128, UUID } from 'bson';
-
-// Export all types
-export * from './types/interfaces.js';
-
-// Export errors
-export * from './errors/SmartdbErrors.js';
-
-// Export storage adapters
-export type { IStorageAdapter } from './storage/IStorageAdapter.js';
-export { MemoryStorageAdapter } from './storage/MemoryStorageAdapter.js';
-export { FileStorageAdapter } from './storage/FileStorageAdapter.js';
-export { OpLog } from './storage/OpLog.js';
-export { WAL } from './storage/WAL.js';
-export type { IWalEntry, TWalOperation } from './storage/WAL.js';
-
-// Export engines
-export { QueryEngine } from './engine/QueryEngine.js';
-export { UpdateEngine } from './engine/UpdateEngine.js';
-export { AggregationEngine } from './engine/AggregationEngine.js';
-export { IndexEngine } from './engine/IndexEngine.js';
-export { TransactionEngine } from './engine/TransactionEngine.js';
-export { QueryPlanner } from './engine/QueryPlanner.js';
-export type { IQueryPlan, TQueryPlanType } from './engine/QueryPlanner.js';
-export { SessionEngine } from './engine/SessionEngine.js';
-export type { ISession, ISessionEngineOptions } from './engine/SessionEngine.js';
+// SmartDB - Wire protocol compatible embedded database server
 
 // Export server (the main entry point for using SmartDB)
 export { SmartdbServer } from './server/SmartdbServer.js';
 export type { ISmartdbServerOptions } from './server/SmartdbServer.js';
 
-// Export wire protocol utilities (for advanced usage)
-export { WireProtocol } from './server/WireProtocol.js';
-export { CommandRouter } from './server/CommandRouter.js';
-export type { ICommandHandler, IHandlerContext, ICursorState } from './server/CommandRouter.js';
-
-// Export utilities
-export * from './utils/checksum.js';
+// Export bridge for advanced usage
+export { RustDbBridge } from './rust-db-bridge.js';
+
+// Export oplog / debug types
+export type {
+  IOpLogEntry,
+  IOpLogResult,
+  IOpLogStats,
+  IRevertResult,
+  ICollectionInfo,
+  IDocumentsResult,
+  ISmartDbMetrics,
+} from './rust-db-bridge.js';

package/ts/ts_smartdb/plugins.ts

@@ -1,17 +1,4 @@
 // @push.rocks scope
-import * as smartfs from '@push.rocks/smartfs';
-import * as smartpath from '@push.rocks/smartpath';
-import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartrx from '@push.rocks/smartrx';
+import * as smartrust from '@push.rocks/smartrust';
 
-export { smartfs, smartpath, smartpromise, smartrx };
-
-// thirdparty
-import * as bson from 'bson';
-import * as mingo from 'mingo';
-
-export { bson, mingo };
-
-// Re-export commonly used mingo classes
-export { Query } from 'mingo';
-export { Aggregator } from 'mingo';
+export { smartrust };

package/ts/ts_smartdb/rust-db-bridge.ts

@@ -0,0 +1,262 @@
+import * as plugins from './plugins.js';
+import * as path from 'path';
+import * as url from 'url';
+import { EventEmitter } from 'events';
+
+/**
+ * A single oplog entry returned from the Rust engine.
+ */
+export interface IOpLogEntry {
+  seq: number;
+  timestampMs: number;
+  op: 'insert' | 'update' | 'delete';
+  db: string;
+  collection: string;
+  documentId: string;
+  document: Record<string, any> | null;
+  previousDocument: Record<string, any> | null;
+}
+
+/**
+ * Aggregate oplog statistics.
+ */
+export interface IOpLogStats {
+  currentSeq: number;
+  totalEntries: number;
+  oldestSeq: number;
+  entriesByOp: {
+    insert: number;
+    update: number;
+    delete: number;
+  };
+}
+
+/**
+ * Result of a getOpLog query.
+ */
+export interface IOpLogResult {
+  entries: IOpLogEntry[];
+  currentSeq: number;
+  totalEntries: number;
+}
+
+/**
+ * Result of a revertToSeq command.
+ */
+export interface IRevertResult {
+  dryRun: boolean;
+  reverted: number;
+  targetSeq?: number;
+  entries?: IOpLogEntry[];
+  errors?: string[];
+}
+
+/**
+ * A collection info entry.
+ */
+export interface ICollectionInfo {
+  db: string;
+  name: string;
+  count: number;
+}
+
+/**
+ * Result of a getDocuments query.
+ */
+export interface IDocumentsResult {
+  documents: Record<string, any>[];
+  total: number;
+}
+
+/**
+ * Server metrics.
+ */
+export interface ISmartDbMetrics {
+  databases: number;
+  collections: number;
+  oplogEntries: number;
+  oplogCurrentSeq: number;
+  uptimeSeconds: number;
+}
+
+/**
+ * Type-safe command definitions for the RustDb IPC protocol.
+ */
+type TSmartDbCommands = {
+  start: { params: { config: ISmartDbRustConfig }; result: { connectionUri: string } };
+  stop: { params: Record<string, never>; result: void };
+  getStatus: { params: Record<string, never>; result: { running: boolean } };
+  getMetrics: { params: Record<string, never>; result: ISmartDbMetrics };
+  getOpLog: {
+    params: { sinceSeq?: number; limit?: number; db?: string; collection?: string };
+    result: IOpLogResult;
+  };
+  getOpLogStats: { params: Record<string, never>; result: IOpLogStats };
+  revertToSeq: {
+    params: { seq: number; dryRun?: boolean };
+    result: IRevertResult;
+  };
+  getCollections: {
+    params: { db?: string };
+    result: { collections: ICollectionInfo[] };
+  };
+  getDocuments: {
+    params: { db: string; collection: string; limit?: number; skip?: number };
+    result: IDocumentsResult;
+  };
+};
+
+/**
+ * Configuration sent to the Rust binary on start.
+ */
+interface ISmartDbRustConfig {
+  port?: number;
+  host?: string;
+  socketPath?: string;
+  storage: 'memory' | 'file';
+  storagePath?: string;
+  persistPath?: string;
+  persistIntervalMs?: number;
+}
+
+/**
+ * Get the package root directory using import.meta.url.
+ * This file is at ts/ts_smartdb/, so package root is 2 levels up.
+ */
+function getPackageRoot(): string {
+  const thisDir = path.dirname(url.fileURLToPath(import.meta.url));
+  return path.resolve(thisDir, '..', '..');
+}
+
+/**
+ * Map Node.js process.platform/process.arch to tsrust's friendly name suffix.
+ * tsrust names cross-compiled binaries as: rustdb_linux_amd64, rustdb_linux_arm64, etc.
+ */
+function getTsrustPlatformSuffix(): string | null {
+  const archMap: Record<string, string> = { x64: 'amd64', arm64: 'arm64' };
+  const osMap: Record<string, string> = { linux: 'linux', darwin: 'macos' };
+  const os = osMap[process.platform];
+  const arch = archMap[process.arch];
+  if (os && arch) {
+    return `${os}_${arch}`;
+  }
+  return null;
+}
+
+/**
+ * Build local search paths for the Rust binary, including dist_rust/ candidates
+ * (built by tsrust) and local development build paths.
+ */
+function buildLocalPaths(): string[] {
+  const packageRoot = getPackageRoot();
+  const suffix = getTsrustPlatformSuffix();
+  const paths: string[] = [];
+
+  // dist_rust/ candidates (tsrust cross-compiled output)
+  if (suffix) {
+    paths.push(path.join(packageRoot, 'dist_rust', `rustdb_${suffix}`));
+  }
+  paths.push(path.join(packageRoot, 'dist_rust', 'rustdb'));
+
+  // Local dev build paths
+  paths.push(path.resolve(process.cwd(), 'rust', 'target', 'release', 'rustdb'));
+  paths.push(path.resolve(process.cwd(), 'rust', 'target', 'debug', 'rustdb'));
+
+  return paths;
+}
+
+/**
+ * Bridge between TypeScript SmartdbServer and the Rust binary.
+ * Wraps @push.rocks/smartrust's RustBridge with type-safe command definitions.
+ */
+export class RustDbBridge extends EventEmitter {
+  private bridge: plugins.smartrust.RustBridge<TSmartDbCommands>;
+
+  constructor() {
+    super();
+
+    this.bridge = new plugins.smartrust.RustBridge<TSmartDbCommands>({
+      binaryName: 'rustdb',
+      envVarName: 'SMARTDB_RUST_BINARY',
+      platformPackagePrefix: '@push.rocks/smartdb',
+      localPaths: buildLocalPaths(),
+      maxPayloadSize: 10 * 1024 * 1024, // 10 MB
+    });
+
+    // Forward events from the inner bridge
+    this.bridge.on('exit', (code: number | null, signal: string | null) => {
+      this.emit('exit', code, signal);
+    });
+  }
+
+  /**
+   * Spawn the Rust binary in management mode.
+   * Returns true if the binary was found and spawned successfully.
+   */
+  public async spawn(): Promise<boolean> {
+    return this.bridge.spawn();
+  }
+
+  /**
+   * Kill the Rust process and clean up.
+   */
+  public kill(): void {
+    this.bridge.kill();
+  }
+
+  /**
+   * Whether the bridge is currently running.
+   */
+  public get running(): boolean {
+    return this.bridge.running;
+  }
+
+  // --- Convenience methods for each management command ---
+
+  public async startDb(config: ISmartDbRustConfig): Promise<{ connectionUri: string }> {
+    return await this.bridge.sendCommand('start', { config }) as { connectionUri: string };
+  }
+
+  public async stopDb(): Promise<void> {
+    await this.bridge.sendCommand('stop', {} as Record<string, never>);
+  }
+
+  public async getStatus(): Promise<{ running: boolean }> {
+    return await this.bridge.sendCommand('getStatus', {} as Record<string, never>) as { running: boolean };
+  }
+
+  public async getMetrics(): Promise<ISmartDbMetrics> {
+    return this.bridge.sendCommand('getMetrics', {} as Record<string, never>) as Promise<ISmartDbMetrics>;
+  }
+
+  public async getOpLog(params: {
+    sinceSeq?: number;
+    limit?: number;
+    db?: string;
+    collection?: string;
+  } = {}): Promise<IOpLogResult> {
+    return this.bridge.sendCommand('getOpLog', params) as Promise<IOpLogResult>;
+  }
+
+  public async getOpLogStats(): Promise<IOpLogStats> {
+    return this.bridge.sendCommand('getOpLogStats', {} as Record<string, never>) as Promise<IOpLogStats>;
+  }
+
+  public async revertToSeq(seq: number, dryRun = false): Promise<IRevertResult> {
+    return this.bridge.sendCommand('revertToSeq', { seq, dryRun }) as Promise<IRevertResult>;
+  }
+
+  public async getCollections(db?: string): Promise<ICollectionInfo[]> {
+    const result = await this.bridge.sendCommand('getCollections', db ? { db } : {}) as { collections: ICollectionInfo[] };
+    return result.collections;
+  }
+
+  public async getDocuments(
+    db: string,
+    collection: string,
+    limit = 50,
+    skip = 0,
+  ): Promise<IDocumentsResult> {
+    return this.bridge.sendCommand('getDocuments', { db, collection, limit, skip }) as Promise<IDocumentsResult>;
+  }
+}