@push.rocks/smartdb 2.5.5 → 2.5.8

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/smartdb',
+    version: '2.5.7',
+    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

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

@@ -0,0 +1,10 @@
+import { commitinfo } from './00_commitinfo_data.js';
+// Export core SmartDB module
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFckQsNkJBQTZCO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsc0JBQXNCO0FBQ3RCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUduRCxtQkFBbUI7QUFDbkIsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRTFELG9CQUFvQjtBQUNwQixPQUFPLEVBQUUsVUFBVSxFQUFFLENBQUMifQ==

package/dist_ts/ts_local/classes.localsmartdb.d.ts

@@ -0,0 +1,87 @@
+import { SmartdbServer } from '../ts_smartdb/index.js';
+/**
+ * Connection information returned by LocalSmartDb.start()
+ */
+export interface ILocalSmartDbConnectionInfo {
+    /** The Unix socket file path */
+    socketPath: string;
+    /** Connection URI (mongodb:// scheme) ready for MongoClient */
+    connectionUri: string;
+}
+export interface ILocalSmartDbOptions {
+    /** Required: where to store data */
+    folderPath: string;
+    /** Optional: custom socket path (default: auto-generated in /tmp) */
+    socketPath?: string;
+}
+/**
+ * LocalSmartDb - Lightweight local MongoDB-compatible database using Unix sockets
+ *
+ * This class wraps SmartdbServer and provides a simple interface for
+ * starting a local file-based database server. Returns connection
+ * info that you can use with any compatible driver instance.
+ *
+ * @example
+ * ```typescript
+ * import { LocalSmartDb } from '@push.rocks/smartdb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const db = new LocalSmartDb({ folderPath: './data' });
+ * const { connectionUri } = await db.start();
+ *
+ * // Connect with the driver
+ * const client = new MongoClient(connectionUri, { directConnection: true });
+ * await client.connect();
+ *
+ * // Use the client
+ * const collection = client.db('mydb').collection('users');
+ * await collection.insertOne({ name: 'Alice' });
+ *
+ * // When done
+ * await client.close();
+ * await db.stop();
+ * ```
+ */
+export declare class LocalSmartDb {
+    private options;
+    private server;
+    private generatedSocketPath;
+    constructor(options: ILocalSmartDbOptions);
+    /**
+     * Generate a unique socket path in /tmp
+     */
+    private generateSocketPath;
+    /**
+     * Check if a Unix socket is alive by attempting to connect.
+     */
+    private static isSocketAlive;
+    /**
+     * Remove stale smartdb-*.sock files from /tmp.
+     * A socket is considered stale if connecting to it fails.
+     */
+    private static cleanStaleSockets;
+    /**
+     * Start the local SmartDB server and return connection info
+     */
+    start(): Promise<ILocalSmartDbConnectionInfo>;
+    /**
+     * Get connection info (throws if not started)
+     */
+    getConnectionInfo(): ILocalSmartDbConnectionInfo;
+    /**
+     * Get the underlying SmartdbServer instance (throws if not started)
+     */
+    getServer(): SmartdbServer;
+    /**
+     * Get the connection URI
+     */
+    getConnectionUri(): string;
+    /**
+     * Check if the server is running
+     */
+    get running(): boolean;
+    /**
+     * Stop the local SmartDB server
+     */
+    stop(): Promise<void>;
+}

package/dist_ts/ts_local/classes.localsmartdb.js

@@ -0,0 +1,169 @@
+import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import * as net from 'net';
+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
+ *
+ * This class wraps SmartdbServer and provides a simple interface for
+ * starting a local file-based database server. Returns connection
+ * info that you can use with any compatible driver instance.
+ *
+ * @example
+ * ```typescript
+ * import { LocalSmartDb } from '@push.rocks/smartdb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const db = new LocalSmartDb({ folderPath: './data' });
+ * const { connectionUri } = await db.start();
+ *
+ * // Connect with the driver
+ * const client = new MongoClient(connectionUri, { directConnection: true });
+ * await client.connect();
+ *
+ * // Use the client
+ * const collection = client.db('mydb').collection('users');
+ * await collection.insertOne({ name: 'Alice' });
+ *
+ * // When done
+ * await client.close();
+ * await db.stop();
+ * ```
+ */
+export class LocalSmartDb {
+    constructor(options) {
+        this.server = null;
+        this.generatedSocketPath = null;
+        this.options = options;
+    }
+    /**
+     * Generate a unique socket path in /tmp
+     */
+    generateSocketPath() {
+        const randomId = crypto.randomBytes(8).toString('hex');
+        return path.join(os.tmpdir(), `smartdb-${randomId}.sock`);
+    }
+    /**
+     * Check if a Unix socket is alive by attempting to connect.
+     */
+    static isSocketAlive(socketPath) {
+        return new Promise((resolve) => {
+            const client = net.createConnection({ path: socketPath }, () => {
+                client.destroy();
+                resolve(true);
+            });
+            client.on('error', () => {
+                resolve(false);
+            });
+            client.setTimeout(500, () => {
+                client.destroy();
+                resolve(false);
+            });
+        });
+    }
+    /**
+     * Remove stale smartdb-*.sock files from /tmp.
+     * A socket is considered stale if connecting to it fails.
+     */
+    static async cleanStaleSockets() {
+        const tmpDir = os.tmpdir();
+        let entries;
+        try {
+            entries = await fs.readdir(tmpDir);
+        }
+        catch {
+            return;
+        }
+        const socketFiles = entries.filter((f) => f.startsWith('smartdb-') && f.endsWith('.sock'));
+        for (const name of socketFiles) {
+            const fullPath = path.join(tmpDir, name);
+            try {
+                const stat = await fs.stat(fullPath);
+                if (!stat.isSocket())
+                    continue;
+                const alive = await LocalSmartDb.isSocketAlive(fullPath);
+                if (!alive) {
+                    await fs.unlink(fullPath);
+                }
+            }
+            catch {
+                // File may have been removed already; ignore
+            }
+        }
+    }
+    /**
+     * Start the local SmartDB server and return connection info
+     */
+    async start() {
+        if (this.server) {
+            throw new Error('LocalSmartDb is already running');
+        }
+        // Clean up stale sockets from previous crashed instances
+        await LocalSmartDb.cleanStaleSockets();
+        // 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({
+            socketPath: this.generatedSocketPath,
+            storage: 'file',
+            storagePath: this.options.folderPath,
+        });
+        await this.server.start();
+        return {
+            socketPath: this.generatedSocketPath,
+            connectionUri: this.server.getConnectionUri(),
+        };
+    }
+    /**
+     * Get connection info (throws if not started)
+     */
+    getConnectionInfo() {
+        if (!this.server || !this.generatedSocketPath) {
+            throw new Error('LocalSmartDb is not running. Call start() first.');
+        }
+        return {
+            socketPath: this.generatedSocketPath,
+            connectionUri: this.server.getConnectionUri(),
+        };
+    }
+    /**
+     * Get the underlying SmartdbServer instance (throws if not started)
+     */
+    getServer() {
+        if (!this.server) {
+            throw new Error('LocalSmartDb is not running. Call start() first.');
+        }
+        return this.server;
+    }
+    /**
+     * Get the connection URI
+     */
+    getConnectionUri() {
+        if (!this.server) {
+            throw new Error('LocalSmartDb is not running. Call start() first.');
+        }
+        return this.server.getConnectionUri();
+    }
+    /**
+     * Check if the server is running
+     */
+    get running() {
+        return this.server !== null && this.server.running;
+    }
+    /**
+     * Stop the local SmartDB server
+     */
+    async stop() {
+        if (this.server) {
+            await this.server.stop();
+            this.server = null;
+            this.generatedSocketPath = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts_local/index.d.ts

@@ -0,0 +1,2 @@
+export { LocalSmartDb } from './classes.localsmartdb.js';
+export type { ILocalSmartDbOptions, ILocalSmartDbConnectionInfo } from './classes.localsmartdb.js';

package/dist_ts/ts_local/index.js

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

package/dist_ts/ts_local/plugins.d.ts

@@ -0,0 +1 @@
+export {};

package/dist_ts/ts_local/plugins.js

@@ -0,0 +1,3 @@
+export {};
+// Local module plugins - currently no external dependencies needed
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3RzX2xvY2FsL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLG1FQUFtRSJ9

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[]>;