spindb 0.46.5 → 0.47.1

package/dist/engines/ferretdb/index.js

@@ -21,15 +21,18 @@ import { paths } from '../../config/paths.js';
 import { getEngineDefaults } from '../../config/defaults.js';
 import { platformService, isWindows } from '../../core/platform-service.js';
 import { configManager } from '../../core/config-manager.js';
+import { getDefaultUsername, loadCredentials } from '../../core/credential-manager.js';
 import { containerManager } from '../../core/container-manager.js';
 import { logDebug, logWarning, assertValidDatabaseName, assertValidUsername, } from '../../core/error-handler.js';
 import { processManager } from '../../core/process-manager.js';
 import { spawnAsync } from '../../core/spawn-utils.js';
 import { ferretdbBinaryManager } from './binary-manager.js';
+import { buildMongoUri, normalizeMongoHost, } from '../mongo-uri.js';
 import { SUPPORTED_MAJOR_VERSIONS, FALLBACK_VERSION_MAP, DEFAULT_DOCUMENTDB_VERSION, DEFAULT_V1_POSTGRESQL_VERSION, normalizeVersion, normalizeDocumentDBVersion, isV1, } from './version-maps.js';
 import { getBinaryUrls, isPlatformSupported } from './binary-urls.js';
 import { detectBackupFormat as detectBackupFormatImpl, restoreBackup, } from './restore.js';
 import { createBackup } from './backup.js';
+import { Engine, } from '../../types/index.js';
 import { parseMongoDBResult } from '../../core/query-parser.js';
 const execAsync = promisify(exec);
 const ENGINE = 'ferretdb';
@@ -974,6 +977,71 @@ export class FerretDBEngine extends BaseEngine {
             }
         }
     }
+    async getLocalAuth(containerName) {
+        const savedCreds = await loadCredentials(containerName, Engine.FerretDB, getDefaultUsername(Engine.FerretDB));
+        if (!savedCreds) {
+            return null;
+        }
+        return {
+            username: savedCreds.username,
+            password: savedCreds.password,
+            authDatabase: savedCreds.database || 'admin',
+        };
+    }
+    async buildLocalMongoshArgs(container, database, options) {
+        const savedCreds = await this.getLocalAuth(container.name);
+        const connectHost = normalizeMongoHost(container.bindAddress);
+        const args = savedCreds
+            ? [
+                buildMongoUri(container.port, database, savedCreds, connectHost),
+            ]
+            : ['--host', connectHost, '--port', String(container.port), database];
+        if (options?.quiet) {
+            args.push('--quiet');
+        }
+        return args;
+    }
+    async runLocalMongosh(container, database, options) {
+        const mongosh = await this.getMongoshPath();
+        const args = await this.buildLocalMongoshArgs(container, database, {
+            quiet: options.quiet,
+        });
+        if (options.eval) {
+            args.push('--eval', options.eval);
+        }
+        if (options.file) {
+            args.push('--file', options.file);
+        }
+        return new Promise((resolve, reject) => {
+            const proc = spawn(mongosh, args, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            const timeout = setTimeout(() => {
+                proc.kill('SIGTERM');
+                reject(new Error(`${options.file ? 'mongosh file execution' : 'mongosh command'} timed out after ${(options.timeoutMs ?? 10000) / 1000} seconds`));
+            }, options.timeoutMs ?? 10000);
+            proc.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+            proc.on('close', (code) => {
+                clearTimeout(timeout);
+                if (code !== 0) {
+                    reject(new Error(stderr || `mongosh exited with code ${code}`));
+                    return;
+                }
+                resolve({ stdout, stderr });
+            });
+        });
+    }
     // Get FerretDB server status
     async status(container) {
         const { name, port } = container;
@@ -1024,50 +1092,22 @@ export class FerretDBEngine extends BaseEngine {
     }
     // Restore a backup
     async restore(container, backupPath, options = {}) {
-        const { backendPort } = container;
-        const database = options.database || 'ferretdb';
-        if (!backendPort) {
-            throw new Error('Backend port not set - start the container first');
-        }
+        const database = options.database || container.database || 'test';
         // Validate database name before restore (defense-in-depth)
         assertValidDatabaseName(database);
-        const result = await restoreBackup(container, backupPath, {
+        return restoreBackup(container, backupPath, {
+            containerName: container.name,
+            port: container.port,
             database,
             drop: options.drop !== false,
+            sourceDatabase: options.sourceDatabase,
+            containerVersion: container.version,
         });
-        // Restart FerretDB proxy so it picks up the restored data.
-        // pg_restore writes directly to PostgreSQL, but FerretDB's proxy
-        // caches schema/collection metadata in memory and won't see
-        // the restored collections until restarted.
-        const containerDir = paths.getContainerPath(container.name, {
-            engine: ENGINE,
-        });
-        try {
-            await this.stopFerretDBProcess(containerDir);
-            // start() detects PG is already running and only launches the proxy
-            await this.start(container);
-        }
-        catch (error) {
-            const err = error;
-            logWarning(`Failed to restart FerretDB proxy after restore: ${err.message}`);
-            // Retry once — transient issues (port race, slow PG) can resolve on second attempt
-            try {
-                await this.stopFerretDBProcess(containerDir).catch(() => { });
-                await this.start(container);
-            }
-            catch {
-                throw new Error(`Restore succeeded but FerretDB proxy failed to restart. ` +
-                    `Data is safely in PostgreSQL. Run 'spindb start ${container.name}' to restart manually. ` +
-                    `Original error: ${err.message}`);
-            }
-        }
-        return result;
     }
     // Get connection string (MongoDB-compatible)
     getConnectionString(container, database) {
         const { port } = container;
         const db = database || container.database || 'test';
-        // No authentication required - FerretDB runs with --no-auth for local dev
         return `mongodb://127.0.0.1:${port}/${db}`;
     }
     // Get PostgreSQL backend connection string (for debugging)
@@ -1098,14 +1138,14 @@ export class FerretDBEngine extends BaseEngine {
     }
     // Open mongosh interactive shell
     async connect(container, database) {
-        const { port } = container;
-        const db = database || 'test';
+        const db = database || container.database || 'test';
         const mongosh = await this.getMongoshPath();
+        const args = await this.buildLocalMongoshArgs(container, db);
         const spawnOptions = {
             stdio: 'inherit',
         };
         return new Promise((resolve, reject) => {
-            const proc = spawn(mongosh, ['--host', '127.0.0.1', '--port', String(port), db], spawnOptions);
+            const proc = spawn(mongosh, args, spawnOptions);
             proc.on('error', reject);
             proc.on('close', () => resolve());
         });
@@ -1118,19 +1158,16 @@ export class FerretDBEngine extends BaseEngine {
      */
     async createDatabase(container, database) {
         assertValidDatabaseName(database);
-        const { port } = container;
         try {
-            const mongosh = await this.getMongoshPath();
             // Create a temp collection then immediately drop it to force database creation
             // without leaving any visible marker collections.
             // Pre-drop in case a previous run was interrupted and left a stale collection.
             // NOTE: Use db.getCollection() instead of db._spindb_init shorthand because
             // mongosh doesn't support shorthand notation for collection names starting with underscore.
-            const script = 'try { db.getCollection("_spindb_init").drop(); } catch(e) {} db.createCollection("_spindb_init"); db.getCollection("_spindb_init").drop();';
-            const cmd = isWindows()
-                ? `"${mongosh}" --host 127.0.0.1 --port ${port} ${database} --eval "${script.replace(/"/g, '\\"')}"`
-                : `"${mongosh}" --host 127.0.0.1 --port ${port} ${database} --eval '${script}'`;
-            await execAsync(cmd, { timeout: 10000 });
+            await this.runLocalMongosh(container, database, {
+                eval: 'try { db.getCollection("_spindb_init").drop(); } catch(e) {} db.createCollection("_spindb_init"); db.getCollection("_spindb_init").drop();',
+                timeoutMs: 10000,
+            });
             logDebug(`Database "${database}" created via temp collection`);
         }
         catch (error) {
@@ -1141,13 +1178,11 @@ export class FerretDBEngine extends BaseEngine {
     // Drop a database
     async dropDatabase(container, database) {
         assertValidDatabaseName(database);
-        const { port } = container;
         try {
-            const mongosh = await this.getMongoshPath();
-            const cmd = isWindows()
-                ? `"${mongosh}" --host 127.0.0.1 --port ${port} ${database} --eval "db.dropDatabase()"`
-                : `"${mongosh}" --host 127.0.0.1 --port ${port} ${database} --eval 'db.dropDatabase()'`;
-            await execAsync(cmd, { timeout: 10000 });
+            await this.runLocalMongosh(container, database, {
+                eval: 'db.dropDatabase()',
+                timeoutMs: 10000,
+            });
         }
         catch (error) {
             logDebug(`dropDatabase result: ${error}`);
@@ -1155,16 +1190,15 @@ export class FerretDBEngine extends BaseEngine {
     }
     // Get the size of the database in bytes
     async getDatabaseSize(container) {
-        const { port, database } = container;
+        const { database } = container;
         const db = database || 'test';
         assertValidDatabaseName(db);
         try {
-            const mongosh = await this.getMongoshPath();
-            const script = 'JSON.stringify(db.stats())';
-            const cmd = isWindows()
-                ? `"${mongosh}" --host 127.0.0.1 --port ${port} ${db} --quiet --eval "${script}"`
-                : `"${mongosh}" --host 127.0.0.1 --port ${port} ${db} --quiet --eval '${script}'`;
-            const { stdout } = await execAsync(cmd, { timeout: 10000 });
+            const { stdout } = await this.runLocalMongosh(container, db, {
+                eval: 'JSON.stringify(db.stats())',
+                quiet: true,
+                timeoutMs: 10000,
+            });
             // Extract JSON from output
             const firstBrace = stdout.indexOf('{');
             const lastBrace = stdout.lastIndexOf('}');
@@ -1228,70 +1262,22 @@ export class FerretDBEngine extends BaseEngine {
     }
     // Run a JavaScript file or inline script against the database
     async runScript(container, options) {
-        const { port } = container;
         const db = options.database || container.database || 'test';
-        const mongosh = await this.getMongoshPath();
         if (options.file) {
-            const spawnOptions = {
-                stdio: 'inherit',
-            };
-            return new Promise((resolve, reject) => {
-                const proc = spawn(mongosh, [
-                    '--host',
-                    '127.0.0.1',
-                    '--port',
-                    String(port),
-                    db,
-                    '--file',
-                    options.file,
-                ], spawnOptions);
-                proc.on('error', reject);
-                proc.on('close', (code) => {
-                    if (code === 0) {
-                        resolve();
-                    }
-                    else {
-                        reject(new Error(`mongosh exited with code ${code}`));
-                    }
-                });
+            await this.runLocalMongosh(container, db, {
+                file: options.file,
+                timeoutMs: 60000,
             });
         }
         else if (options.sql) {
-            // sql field is actually JS for MongoDB-compatible databases
-            const script = options.sql;
-            return new Promise((resolve, reject) => {
-                const proc = spawn(mongosh, ['--host', '127.0.0.1', '--port', String(port), db, '--eval', script], { stdio: ['pipe', 'pipe', 'pipe'] });
-                let stdout = '';
-                let stderr = '';
-                proc.stdout?.on('data', (data) => {
-                    stdout += data.toString();
-                });
-                proc.stderr?.on('data', (data) => {
-                    stderr += data.toString();
-                });
-                // 60 second timeout
-                const timeout = setTimeout(() => {
-                    proc.kill('SIGTERM');
-                    reject(new Error('mongosh timed out after 60 seconds'));
-                }, 60000);
-                proc.on('error', (err) => {
-                    clearTimeout(timeout);
-                    reject(err);
-                });
-                proc.on('close', (code) => {
-                    clearTimeout(timeout);
-                    if (stdout)
-                        process.stdout.write(stdout);
-                    if (stderr)
-                        process.stderr.write(stderr);
-                    if (code === 0) {
-                        resolve();
-                    }
-                    else {
-                        reject(new Error(`mongosh exited with code ${code}`));
-                    }
-                });
+            const { stdout, stderr } = await this.runLocalMongosh(container, db, {
+                eval: options.sql,
+                timeoutMs: 60000,
             });
+            if (stdout)
+                process.stdout.write(stdout);
+            if (stderr)
+                process.stderr.write(stderr);
         }
         else {
             throw new Error('Either file or sql option must be provided');
@@ -1324,42 +1310,33 @@ export class FerretDBEngine extends BaseEngine {
                     'Shell commands like "show dbs" and "use dbname" are not supported in executeQuery.');
             }
         }
-        // Wrap query in async IIFE to properly await cursor.toArray()
-        // This prevents JSON.stringify from serializing a Promise
         const script = `(async () => { const res = ${normalizedQuery}; return JSON.stringify(res.toArray ? await res.toArray() : await Promise.resolve(res)); })()`;
-        return new Promise((resolve, reject) => {
-            let args;
-            if (options?.host) {
-                // Remote: build a connection URI for mongosh
-                const user = options.username
-                    ? encodeURIComponent(options.username)
-                    : '';
-                const pass = options.password
-                    ? encodeURIComponent(options.password)
-                    : '';
-                const auth = user ? `${user}:${pass}@` : '';
-                const host = options.host;
-                const isSrv = options.scheme === 'mongodb+srv';
-                const scheme = isSrv ? 'mongodb+srv' : 'mongodb';
-                const portSuffix = isSrv ? '' : `:${port}`;
-                const sslParam = options.ssl && !isSrv ? 'tls=true' : '';
-                const uri = `${scheme}://${auth}${host}${portSuffix}/${db}${sslParam ? `?${sslParam}` : ''}`;
-                args = [uri, '--quiet', '--eval', script];
-            }
-            else if (options?.password) {
-                // Local with auth: build URI with credentials
-                const user = options.username
-                    ? encodeURIComponent(options.username)
-                    : '';
-                const pass = encodeURIComponent(options.password);
-                const auth = user ? `${user}:${pass}@` : '';
-                const uri = `mongodb://${auth}127.0.0.1:${port}/${db}`;
-                args = [uri, '--quiet', '--eval', script];
-            }
-            else {
-                args = [
+        let args;
+        if (options?.host) {
+            const user = options.username ? encodeURIComponent(options.username) : '';
+            const pass = options.password ? encodeURIComponent(options.password) : '';
+            const auth = user ? `${user}:${pass}@` : '';
+            const host = options.host;
+            const isSrv = options.scheme === 'mongodb+srv';
+            const scheme = isSrv ? 'mongodb+srv' : 'mongodb';
+            const portSuffix = isSrv ? '' : `:${port}`;
+            const sslParam = options.ssl && !isSrv ? 'tls=true' : '';
+            const uri = `${scheme}://${auth}${host}${portSuffix}/${db}${sslParam ? `?${sslParam}` : ''}`;
+            args = [uri, '--quiet', '--eval', script];
+        }
+        else {
+            const savedCreds = await this.getLocalAuth(container.name);
+            const connectHost = normalizeMongoHost(container.bindAddress);
+            args = savedCreds
+                ? [
+                    buildMongoUri(port, db, savedCreds, connectHost),
+                    '--quiet',
+                    '--eval',
+                    script,
+                ]
+                : [
                     '--host',
-                    '127.0.0.1',
+                    connectHost,
                     '--port',
                     String(port),
                     db,
@@ -1367,17 +1344,18 @@ export class FerretDBEngine extends BaseEngine {
                     '--eval',
                     script,
                 ];
-            }
+        }
+        const { stdout, stderr } = await new Promise((resolve, reject) => {
             const proc = spawn(mongosh, args, {
-                stdio: ['pipe', 'pipe', 'pipe'],
+                stdio: ['ignore', 'pipe', 'pipe'],
             });
-            let stdout = '';
-            let stderr = '';
+            let stdoutBuf = '';
+            let stderrBuf = '';
             proc.stdout?.on('data', (data) => {
-                stdout += data.toString();
+                stdoutBuf += data.toString();
             });
             proc.stderr?.on('data', (data) => {
-                stderr += data.toString();
+                stderrBuf += data.toString();
             });
             const timeout = setTimeout(() => {
                 proc.kill('SIGTERM');
@@ -1390,87 +1368,67 @@ export class FerretDBEngine extends BaseEngine {
             proc.on('close', (code) => {
                 clearTimeout(timeout);
                 if (code !== 0) {
-                    reject(new Error(stderr || `mongosh exited with code ${code}`));
+                    reject(new Error(`${stderrBuf || `mongosh exited with code ${code}`}${stdoutBuf ? `\nOutput: ${stdoutBuf}` : ''}`));
                     return;
                 }
-                try {
-                    // Extract JSON from output (mongosh may output extra info)
-                    const jsonStart = stdout.indexOf('[');
-                    const jsonEnd = stdout.lastIndexOf(']');
-                    if (jsonStart !== -1 && jsonEnd !== -1 && jsonEnd > jsonStart) {
-                        const jsonStr = stdout.substring(jsonStart, jsonEnd + 1);
-                        resolve(parseMongoDBResult(jsonStr));
-                    }
-                    else {
-                        // Try parsing as single object or scalar
-                        const objStart = stdout.indexOf('{');
-                        const objEnd = stdout.lastIndexOf('}');
-                        if (objStart !== -1 && objEnd !== -1 && objEnd > objStart) {
-                            const jsonStr = stdout.substring(objStart, objEnd + 1);
-                            resolve(parseMongoDBResult(jsonStr));
-                        }
-                        else {
-                            // Return as scalar result
-                            resolve({
-                                columns: ['result'],
-                                rows: [{ result: stdout.trim() }],
-                                rowCount: 1,
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    reject(new Error(`Failed to parse query result: ${error instanceof Error ? error.message : error}`));
-                }
+                resolve({ stdout: stdoutBuf, stderr: stderrBuf });
             });
         });
+        if (stderr && !stdout.trim()) {
+            throw new Error(`${stderr}${stdout ? `\nOutput: ${stdout}` : ''}`);
+        }
+        const jsonMatch = stdout.match(/\[[\s\S]*\]|\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            return {
+                columns: ['result'],
+                rows: [{ result: stdout.trim() }],
+                rowCount: 1,
+            };
+        }
+        return parseMongoDBResult(jsonMatch[0]);
     }
     /**
      * List all user databases, excluding system databases (admin, config, local).
      * FerretDB uses MongoDB protocol, so same approach as MongoDB.
      */
     async listDatabases(container) {
-        const { port } = container;
         const mongosh = await this.getMongoshPath();
         return new Promise((resolve, reject) => {
-            // Use JSON output for reliable parsing
             const script = `JSON.stringify(db.adminCommand({listDatabases: 1}).databases.map(d => d.name))`;
-            const args = [
-                '--quiet',
-                '--host',
-                '127.0.0.1',
-                '--port',
-                String(port),
-                '--eval',
-                script,
-            ];
-            const proc = spawn(mongosh, args, {
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-            let stdout = '';
-            let stderr = '';
-            proc.stdout?.on('data', (data) => {
-                stdout += data.toString();
-            });
-            proc.stderr?.on('data', (data) => {
-                stderr += data.toString();
-            });
-            proc.on('error', reject);
-            proc.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(stderr || `mongosh exited with code ${code}`));
-                    return;
-                }
-                try {
-                    const allDatabases = JSON.parse(stdout.trim());
-                    const systemDatabases = ['admin', 'config', 'local'];
-                    const databases = allDatabases.filter((db) => !systemDatabases.includes(db));
-                    resolve(databases);
-                }
-                catch (error) {
-                    reject(new Error(`Failed to parse database list: ${error}`));
-                }
-            });
+            const launch = async () => {
+                const args = await this.buildLocalMongoshArgs(container, 'admin', {
+                    quiet: true,
+                });
+                args.push('--eval', script);
+                const proc = spawn(mongosh, args, {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                let stdout = '';
+                let stderr = '';
+                proc.stdout?.on('data', (data) => {
+                    stdout += data.toString();
+                });
+                proc.stderr?.on('data', (data) => {
+                    stderr += data.toString();
+                });
+                proc.on('error', reject);
+                proc.on('close', (code) => {
+                    if (code !== 0) {
+                        reject(new Error(stderr || `mongosh exited with code ${code}`));
+                        return;
+                    }
+                    try {
+                        const allDatabases = JSON.parse(stdout.trim());
+                        const systemDatabases = ['admin', 'config', 'local'];
+                        const databases = allDatabases.filter((db) => !systemDatabases.includes(db));
+                        resolve(databases);
+                    }
+                    catch (error) {
+                        reject(new Error(`Failed to parse database list: ${error}`));
+                    }
+                });
+            };
+            void launch().catch(reject);
         });
     }
     async createUser(container, options) {
@@ -1480,12 +1438,9 @@ export class FerretDBEngine extends BaseEngine {
         const db = database ?? container.database ?? 'admin';
         assertValidDatabaseName(db);
         const mongosh = await this.getMongoshPath();
-        // Same as MongoDB - auth disabled with --no-auth but user is still created
-        // Use JSON.stringify for password to safely escape all special characters in JS context
-        // Pass script via stdin to avoid exposing passwords in process listings
         const jsonPwd = JSON.stringify(password);
         const script = `db.getSiblingDB('${db}').createUser({user:'${username}',pwd:${jsonPwd},roles:[{role:'readWrite',db:'${db}'}]})`;
-        const mongoshArgs = ['--host', '127.0.0.1', '--port', String(port), 'admin'];
+        const mongoshArgs = await this.buildLocalMongoshArgs(container, 'admin');
         const runMongoshViaStdin = (js) => new Promise((resolve, reject) => {
             const proc = spawn(mongosh, mongoshArgs, {
                 stdio: ['pipe', 'pipe', 'pipe'],