@push.rocks/smartdb 2.0.0 → 2.3.1

package/.smartconfig.json

@@ -32,6 +32,17 @@
   "@git.zone/tsdoc": {
     "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
   },
+  "@git.zone/tsbundle": {
+    "bundles": [
+      {
+        "from": "./ts_debugui/index.ts",
+        "to": "./ts_debugserver/bundled.ts",
+        "outputMode": "base64ts",
+        "bundler": "esbuild",
+        "includeFiles": ["./html/index.html"]
+      }
+    ]
+  },
   "@git.zone/tsrust": {
     "targets": ["linux_amd64", "linux_arm64"]
   },

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartdb',
-    version: '2.0.0',
+    version: '2.3.0',
     description: 'A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHFIQUFxSDtDQUNuSSxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -2,4 +2,6 @@ import { commitinfo } from './00_commitinfo_data.js';
 export * from './ts_smartdb/index.js';
 export { LocalSmartDb } from './ts_local/index.js';
 export type { ILocalSmartDbOptions, ILocalSmartDbConnectionInfo } from './ts_local/index.js';
+export { StorageMigrator } from './ts_migration/index.js';
 export { commitinfo };
+export type { IOpLogEntry, IOpLogResult, IOpLogStats, IRevertResult, ICollectionInfo, IDocumentsResult, ISmartDbMetrics, } from './ts_smartdb/index.js';

package/dist_ts/index.js

@@ -3,6 +3,8 @@ import { commitinfo } from './00_commitinfo_data.js';
 export * from './ts_smartdb/index.js';
 // Export LocalSmartDb
 export { LocalSmartDb } from './ts_local/index.js';
+// Export migration
+export { StorageMigrator } from './ts_migration/index.js';
 // Export commitinfo
 export { commitinfo };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFckQsNkJBQTZCO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsc0JBQXNCO0FBQ3RCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUduRCxvQkFBb0I7QUFDcEIsT0FBTyxFQUFFLFVBQVUsRUFBRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFckQsNkJBQTZCO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsc0JBQXNCO0FBQ3RCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUduRCxtQkFBbUI7QUFDbkIsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRTFELG9CQUFvQjtBQUNwQixPQUFPLEVBQUUsVUFBVSxFQUFFLENBQUMifQ==

package/dist_ts/ts_local/classes.localsmartdb.js

@@ -2,6 +2,7 @@ import * as crypto from 'crypto';
 import * as path from 'path';
 import * as os from 'os';
 import { SmartdbServer } from '../ts_smartdb/index.js';
+import { StorageMigrator } from '../ts_migration/index.js';
 /**
  * LocalSmartDb - Lightweight local MongoDB-compatible database using Unix sockets
  *
@@ -31,10 +32,9 @@ import { SmartdbServer } from '../ts_smartdb/index.js';
  * ```
  */
 export class LocalSmartDb {
-    options;
-    server = null;
-    generatedSocketPath = null;
     constructor(options) {
+        this.server = null;
+        this.generatedSocketPath = null;
         this.options = options;
     }
     /**
@@ -51,6 +51,9 @@ export class LocalSmartDb {
         if (this.server) {
             throw new Error('LocalSmartDb is already running');
         }
+        // Run storage migration before starting the Rust engine
+        const migrator = new StorageMigrator(this.options.folderPath);
+        await migrator.run();
         // Use provided socket path or generate one
         this.generatedSocketPath = this.options.socketPath ?? this.generateSocketPath();
         this.server = new SmartdbServer({
@@ -111,4 +114,4 @@ export class LocalSmartDb {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts_migration/classes.storagemigrator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * StorageMigrator — runs before the Rust engine starts.
+ *
+ * Detects the current storage format version and runs the appropriate
+ * migration chain. The Rust engine only knows the current format (v1).
+ *
+ * Migration is safe: original files are never modified or deleted.
+ * On success, a console hint is printed about which old files can be removed.
+ */
+export declare class StorageMigrator {
+    private storagePath;
+    constructor(storagePath: string);
+    /**
+     * Run any needed migrations. Safe to call even if storage is already current.
+     */
+    run(): Promise<void>;
+    /**
+     * Detect the storage format version by inspecting the directory structure.
+     *
+     * v0: {db}/{coll}.json files exist
+     * v1: {db}/{coll}/data.rdb directories exist
+     */
+    private detectVersion;
+}

package/dist_ts/ts_migration/classes.storagemigrator.js

@@ -0,0 +1,75 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { migrateV0ToV1 } from './migrators/v0_to_v1.js';
+/**
+ * StorageMigrator — runs before the Rust engine starts.
+ *
+ * Detects the current storage format version and runs the appropriate
+ * migration chain. The Rust engine only knows the current format (v1).
+ *
+ * Migration is safe: original files are never modified or deleted.
+ * On success, a console hint is printed about which old files can be removed.
+ */
+export class StorageMigrator {
+    constructor(storagePath) {
+        this.storagePath = storagePath;
+    }
+    /**
+     * Run any needed migrations. Safe to call even if storage is already current.
+     */
+    async run() {
+        if (!fs.existsSync(this.storagePath)) {
+            return; // No data yet — nothing to migrate
+        }
+        const version = this.detectVersion();
+        if (version === 1) {
+            return; // Already current
+        }
+        if (version === 0) {
+            console.log(`[smartdb] Detected v0 (JSON) storage format at ${this.storagePath}`);
+            console.log(`[smartdb] Running migration v0 → v1 (Bitcask binary format)...`);
+            const deletableFiles = await migrateV0ToV1(this.storagePath);
+            if (deletableFiles.length > 0) {
+                console.log(`[smartdb] Migration v0 → v1 complete.`);
+                console.log(`[smartdb] The following old files can be safely deleted:`);
+                for (const f of deletableFiles) {
+                    console.log(`[smartdb]   ${f}`);
+                }
+            }
+            else {
+                console.log(`[smartdb] Migration v0 → v1 complete. No old files to clean up.`);
+            }
+        }
+    }
+    /**
+     * Detect the storage format version by inspecting the directory structure.
+     *
+     * v0: {db}/{coll}.json files exist
+     * v1: {db}/{coll}/data.rdb directories exist
+     */
+    detectVersion() {
+        const entries = fs.readdirSync(this.storagePath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const dbDir = path.join(this.storagePath, entry.name);
+            const dbEntries = fs.readdirSync(dbDir, { withFileTypes: true });
+            for (const dbEntry of dbEntries) {
+                // v1: subdirectory with data.rdb
+                if (dbEntry.isDirectory()) {
+                    const dataRdb = path.join(dbDir, dbEntry.name, 'data.rdb');
+                    if (fs.existsSync(dataRdb)) {
+                        return 1;
+                    }
+                }
+                // v0: .json file (not .indexes.json)
+                if (dbEntry.isFile() && dbEntry.name.endsWith('.json') && !dbEntry.name.endsWith('.indexes.json')) {
+                    return 0;
+                }
+            }
+        }
+        // Empty or unrecognized — treat as v1 (fresh start)
+        return 1;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts_migration/index.d.ts

@@ -0,0 +1 @@
+export { StorageMigrator } from './classes.storagemigrator.js';

package/dist_ts/ts_migration/index.js

@@ -0,0 +1,2 @@
+export { StorageMigrator } from './classes.storagemigrator.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19taWdyYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDhCQUE4QixDQUFDIn0=

package/dist_ts/ts_migration/migrators/v0_to_v1.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Migrate a storage directory from v0 (JSON-per-collection) to v1 (Bitcask binary).
+ *
+ * - Original .json files are NOT modified or deleted.
+ * - New v1 files are written into {db}/{coll}/ subdirectories.
+ * - Returns a list of old files that can be safely deleted.
+ * - On failure, cleans up any partial new files and throws.
+ */
+export declare function migrateV0ToV1(storagePath: string): Promise<string[]>;

package/dist_ts/ts_migration/migrators/v0_to_v1.js

@@ -0,0 +1,225 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { BSON } from 'bson';
+// ---------------------------------------------------------------------------
+// Binary format constants (must match Rust: record.rs)
+// ---------------------------------------------------------------------------
+/** File-level magic: "SMARTDB\0" */
+const FILE_MAGIC = Buffer.from('SMARTDB\0', 'ascii');
+/** Current format version */
+const FORMAT_VERSION = 1;
+/** File type tags */
+const FILE_TYPE_DATA = 1;
+const FILE_TYPE_HINT = 3;
+/** File header total size */
+const FILE_HEADER_SIZE = 64;
+/** Per-record magic */
+const RECORD_MAGIC = 0xDB01;
+/** Per-record header size */
+const RECORD_HEADER_SIZE = 22; // 2 + 8 + 4 + 4 + 4
+// ---------------------------------------------------------------------------
+// Binary encoding helpers
+// ---------------------------------------------------------------------------
+function writeFileHeader(fileType) {
+    const buf = Buffer.alloc(FILE_HEADER_SIZE, 0);
+    FILE_MAGIC.copy(buf, 0);
+    buf.writeUInt16LE(FORMAT_VERSION, 8);
+    buf.writeUInt8(fileType, 10);
+    buf.writeUInt32LE(0, 11); // flags
+    const now = BigInt(Date.now());
+    buf.writeBigUInt64LE(now, 15);
+    // bytes 23..64 are reserved (zeros)
+    return buf;
+}
+function encodeDataRecord(timestamp, key, value) {
+    const keyLen = key.length;
+    const valLen = value.length;
+    const totalSize = RECORD_HEADER_SIZE + keyLen + valLen;
+    const buf = Buffer.alloc(totalSize);
+    // Write header fields (without CRC)
+    buf.writeUInt16LE(RECORD_MAGIC, 0);
+    buf.writeBigUInt64LE(timestamp, 2);
+    buf.writeUInt32LE(keyLen, 10);
+    buf.writeUInt32LE(valLen, 14);
+    // CRC placeholder at offset 18..22 (will fill below)
+    key.copy(buf, RECORD_HEADER_SIZE);
+    value.copy(buf, RECORD_HEADER_SIZE + keyLen);
+    // CRC32 covers everything except the CRC field itself:
+    // bytes [0..18] + bytes [22..]
+    const crc = crc32(Buffer.concat([
+        buf.subarray(0, 18),
+        buf.subarray(22),
+    ]));
+    buf.writeUInt32LE(crc, 18);
+    return buf;
+}
+function encodeHintEntry(key, offset, recordLen, valueLen, timestamp) {
+    const keyBuf = Buffer.from(key, 'utf-8');
+    const buf = Buffer.alloc(4 + keyBuf.length + 8 + 4 + 4 + 8);
+    let pos = 0;
+    buf.writeUInt32LE(keyBuf.length, pos);
+    pos += 4;
+    keyBuf.copy(buf, pos);
+    pos += keyBuf.length;
+    buf.writeBigUInt64LE(offset, pos);
+    pos += 8;
+    buf.writeUInt32LE(recordLen, pos);
+    pos += 4;
+    buf.writeUInt32LE(valueLen, pos);
+    pos += 4;
+    buf.writeBigUInt64LE(timestamp, pos);
+    return buf;
+}
+// ---------------------------------------------------------------------------
+// CRC32 (matching crc32fast in Rust)
+// ---------------------------------------------------------------------------
+const CRC32_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let i = 0; i < 256; i++) {
+        let crc = i;
+        for (let j = 0; j < 8; j++) {
+            crc = (crc & 1) ? (0xEDB88320 ^ (crc >>> 1)) : (crc >>> 1);
+        }
+        table[i] = crc;
+    }
+    return table;
+})();
+function crc32(data) {
+    let crc = 0xFFFFFFFF;
+    for (let i = 0; i < data.length; i++) {
+        crc = CRC32_TABLE[(crc ^ data[i]) & 0xFF] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xFFFFFFFF) >>> 0;
+}
+/**
+ * Migrate a storage directory from v0 (JSON-per-collection) to v1 (Bitcask binary).
+ *
+ * - Original .json files are NOT modified or deleted.
+ * - New v1 files are written into {db}/{coll}/ subdirectories.
+ * - Returns a list of old files that can be safely deleted.
+ * - On failure, cleans up any partial new files and throws.
+ */
+export async function migrateV0ToV1(storagePath) {
+    const deletableFiles = [];
+    const createdDirs = [];
+    try {
+        const dbEntries = fs.readdirSync(storagePath, { withFileTypes: true });
+        for (const dbEntry of dbEntries) {
+            if (!dbEntry.isDirectory())
+                continue;
+            const dbDir = path.join(storagePath, dbEntry.name);
+            const collFiles = fs.readdirSync(dbDir, { withFileTypes: true });
+            for (const collFile of collFiles) {
+                if (!collFile.isFile())
+                    continue;
+                if (!collFile.name.endsWith('.json'))
+                    continue;
+                if (collFile.name.endsWith('.indexes.json'))
+                    continue;
+                const collName = collFile.name.replace(/\.json$/, '');
+                const jsonPath = path.join(dbDir, collFile.name);
+                const indexJsonPath = path.join(dbDir, `${collName}.indexes.json`);
+                // Target directory
+                const collDir = path.join(dbDir, collName);
+                if (fs.existsSync(collDir)) {
+                    // Already migrated
+                    continue;
+                }
+                console.log(`[smartdb]   Migrating ${dbEntry.name}.${collName}...`);
+                // Read the JSON collection
+                const jsonData = fs.readFileSync(jsonPath, 'utf-8');
+                const docs = JSON.parse(jsonData);
+                // Create collection directory
+                fs.mkdirSync(collDir, { recursive: true });
+                createdDirs.push(collDir);
+                // Write data.rdb
+                const dataPath = path.join(collDir, 'data.rdb');
+                const fd = fs.openSync(dataPath, 'w');
+                try {
+                    // File header
+                    const headerBuf = writeFileHeader(FILE_TYPE_DATA);
+                    fs.writeSync(fd, headerBuf);
+                    let currentOffset = BigInt(FILE_HEADER_SIZE);
+                    const keydir = new Map();
+                    const ts = BigInt(Date.now());
+                    for (const doc of docs) {
+                        // Extract _id
+                        let idHex;
+                        if (doc._id && doc._id.$oid) {
+                            idHex = doc._id.$oid;
+                        }
+                        else if (typeof doc._id === 'string') {
+                            idHex = doc._id;
+                        }
+                        else if (doc._id) {
+                            idHex = String(doc._id);
+                        }
+                        else {
+                            // Generate a new ObjectId
+                            idHex = crypto.randomBytes(12).toString('hex');
+                            doc._id = { $oid: idHex };
+                        }
+                        // Serialize to BSON
+                        const bsonBytes = BSON.serialize(doc);
+                        const keyBuf = Buffer.from(idHex, 'utf-8');
+                        const valueBuf = Buffer.from(bsonBytes);
+                        const record = encodeDataRecord(ts, keyBuf, valueBuf);
+                        fs.writeSync(fd, record);
+                        keydir.set(idHex, {
+                            offset: currentOffset,
+                            recordLen: record.length,
+                            valueLen: valueBuf.length,
+                            timestamp: ts,
+                        });
+                        currentOffset += BigInt(record.length);
+                    }
+                    fs.fsyncSync(fd);
+                    fs.closeSync(fd);
+                    // Write keydir.hint
+                    const hintPath = path.join(collDir, 'keydir.hint');
+                    const hintFd = fs.openSync(hintPath, 'w');
+                    fs.writeSync(hintFd, writeFileHeader(FILE_TYPE_HINT));
+                    for (const [key, entry] of keydir) {
+                        fs.writeSync(hintFd, encodeHintEntry(key, entry.offset, entry.recordLen, entry.valueLen, entry.timestamp));
+                    }
+                    fs.fsyncSync(hintFd);
+                    fs.closeSync(hintFd);
+                }
+                catch (writeErr) {
+                    // Clean up on write failure
+                    try {
+                        fs.closeSync(fd);
+                    }
+                    catch { }
+                    throw writeErr;
+                }
+                // Copy indexes.json if it exists
+                if (fs.existsSync(indexJsonPath)) {
+                    const destIndexPath = path.join(collDir, 'indexes.json');
+                    fs.copyFileSync(indexJsonPath, destIndexPath);
+                    deletableFiles.push(indexJsonPath);
+                }
+                else {
+                    // Write default _id index
+                    const destIndexPath = path.join(collDir, 'indexes.json');
+                    fs.writeFileSync(destIndexPath, JSON.stringify([{ name: '_id_', key: { _id: 1 } }], null, 2));
+                }
+                deletableFiles.push(jsonPath);
+                console.log(`[smartdb]   Migrated ${dbEntry.name}.${collName}: ${docs.length} documents`);
+            }
+        }
+    }
+    catch (err) {
+        // Clean up any partially created directories
+        for (const dir of createdDirs) {
+            try {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+            catch { }
+        }
+        throw err;
+    }
+    return deletableFiles;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v0_to_v1.js","sourceRoot":"","sources":["../../../ts/ts_migration/migrators/v0_to_v1.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts_smartdb/index.d.ts

@@ -1,3 +1,4 @@
 export { SmartdbServer } from './server/SmartdbServer.js';
 export type { ISmartdbServerOptions } from './server/SmartdbServer.js';
 export { RustDbBridge } from './rust-db-bridge.js';
+export type { IOpLogEntry, IOpLogResult, IOpLogStats, IRevertResult, ICollectionInfo, IDocumentsResult, ISmartDbMetrics, } from './rust-db-bridge.js';

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

@@ -1,4 +1,73 @@
 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;
+}
 /**
  * Configuration sent to the Rust binary on start.
  */
@@ -38,6 +107,16 @@ export declare class RustDbBridge extends EventEmitter {
     getStatus(): Promise<{
         running: boolean;
     }>;
-    getMetrics(): Promise<any>;
+    getMetrics(): Promise<ISmartDbMetrics>;
+    getOpLog(params?: {
+        sinceSeq?: number;
+        limit?: number;
+        db?: string;
+        collection?: string;
+    }): Promise<IOpLogResult>;
+    getOpLogStats(): Promise<IOpLogStats>;
+    revertToSeq(seq: number, dryRun?: boolean): Promise<IRevertResult>;
+    getCollections(db?: string): Promise<ICollectionInfo[]>;
+    getDocuments(db: string, collection: string, limit?: number, skip?: number): Promise<IDocumentsResult>;
 }
 export {};

package/dist_ts/ts_smartdb/rust-db-bridge.js

@@ -47,7 +47,6 @@ function buildLocalPaths() {
  * Wraps @push.rocks/smartrust's RustBridge with type-safe command definitions.
  */
 export class RustDbBridge extends EventEmitter {
-    bridge;
     constructor() {
         super();
         this.bridge = new plugins.smartrust.RustBridge({
@@ -94,5 +93,21 @@ export class RustDbBridge extends EventEmitter {
     async getMetrics() {
         return this.bridge.sendCommand('getMetrics', {});
     }
+    async getOpLog(params = {}) {
+        return this.bridge.sendCommand('getOpLog', params);
+    }
+    async getOpLogStats() {
+        return this.bridge.sendCommand('getOpLogStats', {});
+    }
+    async revertToSeq(seq, dryRun = false) {
+        return this.bridge.sendCommand('revertToSeq', { seq, dryRun });
+    }
+    async getCollections(db) {
+        const result = await this.bridge.sendCommand('getCollections', db ? { db } : {});
+        return result.collections;
+    }
+    async getDocuments(db, collection, limit = 50, skip = 0) {
+        return this.bridge.sendCommand('getDocuments', { db, collection, limit, skip });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts_smartdb/server/SmartdbServer.d.ts

@@ -1,3 +1,4 @@
+import type { IOpLogResult, IOpLogStats, IRevertResult, ICollectionInfo, IDocumentsResult, ISmartDbMetrics } from '../rust-db-bridge.js';
 /**
  * Server configuration options
  */
@@ -70,4 +71,34 @@ export declare class SmartdbServer {
      * Get the host the server is bound to
      */
     get host(): string;
+    /**
+     * Get oplog entries, optionally filtered.
+     */
+    getOpLog(params?: {
+        sinceSeq?: number;
+        limit?: number;
+        db?: string;
+        collection?: string;
+    }): Promise<IOpLogResult>;
+    /**
+     * Get aggregate oplog statistics.
+     */
+    getOpLogStats(): Promise<IOpLogStats>;
+    /**
+     * Revert database state to a specific oplog sequence number.
+     * Use dryRun=true to preview which entries would be reverted.
+     */
+    revertToSeq(seq: number, dryRun?: boolean): Promise<IRevertResult>;
+    /**
+     * List all collections across all databases, with document counts.
+     */
+    getCollections(db?: string): Promise<ICollectionInfo[]>;
+    /**
+     * Get documents from a collection with pagination.
+     */
+    getDocuments(db: string, collection: string, limit?: number, skip?: number): Promise<IDocumentsResult>;
+    /**
+     * Get server metrics including database/collection counts and oplog info.
+     */
+    getMetrics(): Promise<ISmartDbMetrics>;
 }