@push.rocks/smartmongo 2.0.14 → 2.2.0

package/dist_ts/congodb/server/handlers/AdminHandler.d.ts

@@ -0,0 +1,100 @@
+import * as plugins from '../../congodb.plugins.js';
+import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+/**
+ * AdminHandler - Handles administrative commands
+ */
+export declare class AdminHandler implements ICommandHandler {
+    handle(context: IHandlerContext): Promise<plugins.bson.Document>;
+    /**
+     * Handle ping command
+     */
+    private handlePing;
+    /**
+     * Handle listDatabases command
+     */
+    private handleListDatabases;
+    /**
+     * Handle listCollections command
+     */
+    private handleListCollections;
+    /**
+     * Handle drop command (drop collection)
+     */
+    private handleDrop;
+    /**
+     * Handle dropDatabase command
+     */
+    private handleDropDatabase;
+    /**
+     * Handle create command (create collection)
+     */
+    private handleCreate;
+    /**
+     * Handle serverStatus command
+     */
+    private handleServerStatus;
+    /**
+     * Handle buildInfo command
+     */
+    private handleBuildInfo;
+    /**
+     * Handle whatsmyuri command
+     */
+    private handleWhatsMyUri;
+    /**
+     * Handle getLog command
+     */
+    private handleGetLog;
+    /**
+     * Handle hostInfo command
+     */
+    private handleHostInfo;
+    /**
+     * Handle replSetGetStatus command
+     */
+    private handleReplSetGetStatus;
+    /**
+     * Handle saslStart command (authentication)
+     */
+    private handleSaslStart;
+    /**
+     * Handle saslContinue command
+     */
+    private handleSaslContinue;
+    /**
+     * Handle endSessions command
+     */
+    private handleEndSessions;
+    /**
+     * Handle abortTransaction command
+     */
+    private handleAbortTransaction;
+    /**
+     * Handle commitTransaction command
+     */
+    private handleCommitTransaction;
+    /**
+     * Handle collStats command
+     */
+    private handleCollStats;
+    /**
+     * Handle dbStats command
+     */
+    private handleDbStats;
+    /**
+     * Handle connectionStatus command
+     */
+    private handleConnectionStatus;
+    /**
+     * Handle currentOp command
+     */
+    private handleCurrentOp;
+    /**
+     * Handle collMod command
+     */
+    private handleCollMod;
+    /**
+     * Handle renameCollection command
+     */
+    private handleRenameCollection;
+}

package/dist_ts/congodb/server/handlers/AdminHandler.js

@@ -0,0 +1,568 @@
+import * as plugins from '../../congodb.plugins.js';
+/**
+ * AdminHandler - Handles administrative commands
+ */
+export class AdminHandler {
+    async handle(context) {
+        const { command } = context;
+        // Determine which command to handle
+        if (command.ping !== undefined) {
+            return this.handlePing(context);
+        }
+        else if (command.listDatabases !== undefined) {
+            return this.handleListDatabases(context);
+        }
+        else if (command.listCollections !== undefined) {
+            return this.handleListCollections(context);
+        }
+        else if (command.drop !== undefined) {
+            return this.handleDrop(context);
+        }
+        else if (command.dropDatabase !== undefined) {
+            return this.handleDropDatabase(context);
+        }
+        else if (command.create !== undefined) {
+            return this.handleCreate(context);
+        }
+        else if (command.serverStatus !== undefined) {
+            return this.handleServerStatus(context);
+        }
+        else if (command.buildInfo !== undefined) {
+            return this.handleBuildInfo(context);
+        }
+        else if (command.whatsmyuri !== undefined) {
+            return this.handleWhatsMyUri(context);
+        }
+        else if (command.getLog !== undefined) {
+            return this.handleGetLog(context);
+        }
+        else if (command.hostInfo !== undefined) {
+            return this.handleHostInfo(context);
+        }
+        else if (command.replSetGetStatus !== undefined) {
+            return this.handleReplSetGetStatus(context);
+        }
+        else if (command.saslStart !== undefined) {
+            return this.handleSaslStart(context);
+        }
+        else if (command.saslContinue !== undefined) {
+            return this.handleSaslContinue(context);
+        }
+        else if (command.endSessions !== undefined) {
+            return this.handleEndSessions(context);
+        }
+        else if (command.abortTransaction !== undefined) {
+            return this.handleAbortTransaction(context);
+        }
+        else if (command.commitTransaction !== undefined) {
+            return this.handleCommitTransaction(context);
+        }
+        else if (command.collStats !== undefined) {
+            return this.handleCollStats(context);
+        }
+        else if (command.dbStats !== undefined) {
+            return this.handleDbStats(context);
+        }
+        else if (command.connectionStatus !== undefined) {
+            return this.handleConnectionStatus(context);
+        }
+        else if (command.currentOp !== undefined) {
+            return this.handleCurrentOp(context);
+        }
+        else if (command.collMod !== undefined) {
+            return this.handleCollMod(context);
+        }
+        else if (command.renameCollection !== undefined) {
+            return this.handleRenameCollection(context);
+        }
+        return {
+            ok: 0,
+            errmsg: 'Unknown admin command',
+            code: 59,
+            codeName: 'CommandNotFound',
+        };
+    }
+    /**
+     * Handle ping command
+     */
+    async handlePing(context) {
+        return { ok: 1 };
+    }
+    /**
+     * Handle listDatabases command
+     */
+    async handleListDatabases(context) {
+        const { storage, command } = context;
+        const dbNames = await storage.listDatabases();
+        const nameOnly = command.nameOnly || false;
+        if (nameOnly) {
+            return {
+                ok: 1,
+                databases: dbNames.map(name => ({ name })),
+            };
+        }
+        // Build database list with sizes
+        const databases = [];
+        let totalSize = 0;
+        for (const name of dbNames) {
+            const collections = await storage.listCollections(name);
+            let dbSize = 0;
+            for (const collName of collections) {
+                const docs = await storage.findAll(name, collName);
+                // Estimate size (rough approximation)
+                dbSize += docs.reduce((sum, doc) => sum + JSON.stringify(doc).length, 0);
+            }
+            totalSize += dbSize;
+            databases.push({
+                name,
+                sizeOnDisk: dbSize,
+                empty: dbSize === 0,
+            });
+        }
+        return {
+            ok: 1,
+            databases,
+            totalSize,
+            totalSizeMb: totalSize / (1024 * 1024),
+        };
+    }
+    /**
+     * Handle listCollections command
+     */
+    async handleListCollections(context) {
+        const { storage, database, command } = context;
+        const filter = command.filter || {};
+        const nameOnly = command.nameOnly || false;
+        const cursor = command.cursor || {};
+        const batchSize = cursor.batchSize || 101;
+        const collNames = await storage.listCollections(database);
+        let collections = [];
+        for (const name of collNames) {
+            // Apply name filter
+            if (filter.name && filter.name !== name) {
+                // Check regex
+                if (filter.name.$regex) {
+                    const regex = new RegExp(filter.name.$regex, filter.name.$options);
+                    if (!regex.test(name))
+                        continue;
+                }
+                else {
+                    continue;
+                }
+            }
+            if (nameOnly) {
+                collections.push({ name });
+            }
+            else {
+                collections.push({
+                    name,
+                    type: 'collection',
+                    options: {},
+                    info: {
+                        readOnly: false,
+                        uuid: new plugins.bson.UUID(),
+                    },
+                    idIndex: {
+                        v: 2,
+                        key: { _id: 1 },
+                        name: '_id_',
+                    },
+                });
+            }
+        }
+        return {
+            ok: 1,
+            cursor: {
+                id: plugins.bson.Long.fromNumber(0),
+                ns: `${database}.$cmd.listCollections`,
+                firstBatch: collections,
+            },
+        };
+    }
+    /**
+     * Handle drop command (drop collection)
+     */
+    async handleDrop(context) {
+        const { storage, database, command } = context;
+        const collection = command.drop;
+        const existed = await storage.dropCollection(database, collection);
+        if (!existed) {
+            return {
+                ok: 0,
+                errmsg: `ns not found ${database}.${collection}`,
+                code: 26,
+                codeName: 'NamespaceNotFound',
+            };
+        }
+        return { ok: 1, ns: `${database}.${collection}` };
+    }
+    /**
+     * Handle dropDatabase command
+     */
+    async handleDropDatabase(context) {
+        const { storage, database } = context;
+        await storage.dropDatabase(database);
+        return { ok: 1, dropped: database };
+    }
+    /**
+     * Handle create command (create collection)
+     */
+    async handleCreate(context) {
+        const { storage, database, command } = context;
+        const collection = command.create;
+        // Check if already exists
+        const exists = await storage.collectionExists(database, collection);
+        if (exists) {
+            return {
+                ok: 0,
+                errmsg: `Collection ${database}.${collection} already exists.`,
+                code: 48,
+                codeName: 'NamespaceExists',
+            };
+        }
+        await storage.createCollection(database, collection);
+        return { ok: 1 };
+    }
+    /**
+     * Handle serverStatus command
+     */
+    async handleServerStatus(context) {
+        const { server } = context;
+        const uptime = server.getUptime();
+        const connections = server.getConnectionCount();
+        return {
+            ok: 1,
+            host: `${server.host}:${server.port}`,
+            version: '7.0.0',
+            process: 'congodb',
+            pid: process.pid,
+            uptime,
+            uptimeMillis: uptime * 1000,
+            uptimeEstimate: uptime,
+            localTime: new Date(),
+            mem: {
+                resident: Math.floor(process.memoryUsage().rss / (1024 * 1024)),
+                virtual: Math.floor(process.memoryUsage().heapTotal / (1024 * 1024)),
+                supported: true,
+            },
+            connections: {
+                current: connections,
+                available: 1000 - connections,
+                totalCreated: connections,
+                active: connections,
+            },
+            network: {
+                bytesIn: 0,
+                bytesOut: 0,
+                numRequests: 0,
+            },
+            storageEngine: {
+                name: 'congodb',
+                supportsCommittedReads: true,
+                persistent: false,
+            },
+        };
+    }
+    /**
+     * Handle buildInfo command
+     */
+    async handleBuildInfo(context) {
+        return {
+            ok: 1,
+            version: '7.0.0',
+            gitVersion: 'congodb',
+            modules: [],
+            allocator: 'system',
+            javascriptEngine: 'none',
+            sysInfo: 'deprecated',
+            versionArray: [7, 0, 0, 0],
+            openssl: {
+                running: 'disabled',
+                compiled: 'disabled',
+            },
+            buildEnvironment: {
+                distmod: 'congodb',
+                distarch: process.arch,
+                cc: '',
+                ccflags: '',
+                cxx: '',
+                cxxflags: '',
+                linkflags: '',
+                target_arch: process.arch,
+                target_os: process.platform,
+            },
+            bits: 64,
+            debug: false,
+            maxBsonObjectSize: 16777216,
+            storageEngines: ['congodb'],
+        };
+    }
+    /**
+     * Handle whatsmyuri command
+     */
+    async handleWhatsMyUri(context) {
+        const { server } = context;
+        return {
+            ok: 1,
+            you: `127.0.0.1:${server.port}`,
+        };
+    }
+    /**
+     * Handle getLog command
+     */
+    async handleGetLog(context) {
+        const { command } = context;
+        if (command.getLog === '*') {
+            return {
+                ok: 1,
+                names: ['global', 'startupWarnings'],
+            };
+        }
+        return {
+            ok: 1,
+            totalLinesWritten: 0,
+            log: [],
+        };
+    }
+    /**
+     * Handle hostInfo command
+     */
+    async handleHostInfo(context) {
+        return {
+            ok: 1,
+            system: {
+                currentTime: new Date(),
+                hostname: 'localhost',
+                cpuAddrSize: 64,
+                memSizeMB: Math.floor(process.memoryUsage().heapTotal / (1024 * 1024)),
+                numCores: 1,
+                cpuArch: process.arch,
+                numaEnabled: false,
+            },
+            os: {
+                type: process.platform,
+                name: process.platform,
+                version: process.version,
+            },
+            extra: {},
+        };
+    }
+    /**
+     * Handle replSetGetStatus command
+     */
+    async handleReplSetGetStatus(context) {
+        // We're standalone, not a replica set
+        return {
+            ok: 0,
+            errmsg: 'not running with --replSet',
+            code: 76,
+            codeName: 'NoReplicationEnabled',
+        };
+    }
+    /**
+     * Handle saslStart command (authentication)
+     */
+    async handleSaslStart(context) {
+        // We don't require authentication, but we need to respond properly
+        // to let drivers know auth is "successful"
+        return {
+            ok: 1,
+            conversationId: 1,
+            done: true,
+            payload: Buffer.from([]),
+        };
+    }
+    /**
+     * Handle saslContinue command
+     */
+    async handleSaslContinue(context) {
+        return {
+            ok: 1,
+            conversationId: 1,
+            done: true,
+            payload: Buffer.from([]),
+        };
+    }
+    /**
+     * Handle endSessions command
+     */
+    async handleEndSessions(context) {
+        return { ok: 1 };
+    }
+    /**
+     * Handle abortTransaction command
+     */
+    async handleAbortTransaction(context) {
+        // Transactions are not fully supported, but acknowledge the command
+        return { ok: 1 };
+    }
+    /**
+     * Handle commitTransaction command
+     */
+    async handleCommitTransaction(context) {
+        // Transactions are not fully supported, but acknowledge the command
+        return { ok: 1 };
+    }
+    /**
+     * Handle collStats command
+     */
+    async handleCollStats(context) {
+        const { storage, database, command } = context;
+        const collection = command.collStats;
+        const exists = await storage.collectionExists(database, collection);
+        if (!exists) {
+            return {
+                ok: 0,
+                errmsg: `ns not found ${database}.${collection}`,
+                code: 26,
+                codeName: 'NamespaceNotFound',
+            };
+        }
+        const docs = await storage.findAll(database, collection);
+        const size = docs.reduce((sum, doc) => sum + JSON.stringify(doc).length, 0);
+        const count = docs.length;
+        const avgObjSize = count > 0 ? size / count : 0;
+        const indexes = await storage.getIndexes(database, collection);
+        return {
+            ok: 1,
+            ns: `${database}.${collection}`,
+            count,
+            size,
+            avgObjSize,
+            storageSize: size,
+            totalIndexSize: 0,
+            indexSizes: indexes.reduce((acc, idx) => {
+                acc[idx.name] = 0;
+                return acc;
+            }, {}),
+            nindexes: indexes.length,
+        };
+    }
+    /**
+     * Handle dbStats command
+     */
+    async handleDbStats(context) {
+        const { storage, database } = context;
+        const collections = await storage.listCollections(database);
+        let totalSize = 0;
+        let totalObjects = 0;
+        for (const collName of collections) {
+            const docs = await storage.findAll(database, collName);
+            totalObjects += docs.length;
+            totalSize += docs.reduce((sum, doc) => sum + JSON.stringify(doc).length, 0);
+        }
+        return {
+            ok: 1,
+            db: database,
+            collections: collections.length,
+            views: 0,
+            objects: totalObjects,
+            avgObjSize: totalObjects > 0 ? totalSize / totalObjects : 0,
+            dataSize: totalSize,
+            storageSize: totalSize,
+            indexes: collections.length, // At least _id index per collection
+            indexSize: 0,
+            totalSize,
+        };
+    }
+    /**
+     * Handle connectionStatus command
+     */
+    async handleConnectionStatus(context) {
+        return {
+            ok: 1,
+            authInfo: {
+                authenticatedUsers: [],
+                authenticatedUserRoles: [],
+            },
+        };
+    }
+    /**
+     * Handle currentOp command
+     */
+    async handleCurrentOp(context) {
+        return {
+            ok: 1,
+            inprog: [],
+        };
+    }
+    /**
+     * Handle collMod command
+     */
+    async handleCollMod(context) {
+        // We don't support modifying collection options, but acknowledge the command
+        return { ok: 1 };
+    }
+    /**
+     * Handle renameCollection command
+     */
+    async handleRenameCollection(context) {
+        const { storage, command } = context;
+        const from = command.renameCollection;
+        const to = command.to;
+        const dropTarget = command.dropTarget || false;
+        if (!from || !to) {
+            return {
+                ok: 0,
+                errmsg: 'renameCollection requires both source and target',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        // Parse namespace (format: "db.collection")
+        const fromParts = from.split('.');
+        const toParts = to.split('.');
+        if (fromParts.length < 2 || toParts.length < 2) {
+            return {
+                ok: 0,
+                errmsg: 'Invalid namespace format',
+                code: 73,
+                codeName: 'InvalidNamespace',
+            };
+        }
+        const fromDb = fromParts[0];
+        const fromColl = fromParts.slice(1).join('.');
+        const toDb = toParts[0];
+        const toColl = toParts.slice(1).join('.');
+        // Check if source exists
+        const sourceExists = await storage.collectionExists(fromDb, fromColl);
+        if (!sourceExists) {
+            return {
+                ok: 0,
+                errmsg: `source namespace ${from} does not exist`,
+                code: 26,
+                codeName: 'NamespaceNotFound',
+            };
+        }
+        // Check if target exists
+        const targetExists = await storage.collectionExists(toDb, toColl);
+        if (targetExists) {
+            if (dropTarget) {
+                await storage.dropCollection(toDb, toColl);
+            }
+            else {
+                return {
+                    ok: 0,
+                    errmsg: `target namespace ${to} already exists`,
+                    code: 48,
+                    codeName: 'NamespaceExists',
+                };
+            }
+        }
+        // Same database rename
+        if (fromDb === toDb) {
+            await storage.renameCollection(fromDb, fromColl, toColl);
+        }
+        else {
+            // Cross-database rename: copy documents then drop source
+            await storage.createCollection(toDb, toColl);
+            const docs = await storage.findAll(fromDb, fromColl);
+            for (const doc of docs) {
+                await storage.insertOne(toDb, toColl, doc);
+            }
+            await storage.dropCollection(fromDb, fromColl);
+        }
+        return { ok: 1 };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AdminHandler.js","sourceRoot":"","sources":["../../../../ts/congodb/server/handlers/AdminHandler.ts"],"names":[],"mappings":"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"}