@wocker/mongodb-plugin 1.0.7 → 1.0.9-beta.0

package/lib/controllers/MongodbController.d.ts

@@ -2,12 +2,14 @@ import { MongodbService } from "../services/MongodbService";
 export declare class MongodbController {
     protected readonly mongodbService: MongodbService;
     constructor(mongodbService: MongodbService);
-    create(name?: string, username?: string, password?: string, imageName?: string, imageVersion?: string): Promise<void>;
-    upgrade(name?: string, imageName?: string, imageVersion?: string, volume?: string, configVolume?: string): Promise<void>;
+    create(name?: string, username?: string, password?: string, imageName?: string, imageVersion?: string, containerPort?: number): Promise<void>;
+    upgrade(name?: string, imageName?: string, imageVersion?: string, volume?: string, configVolume?: string, containerPort?: number, enableAdmin?: boolean, disableAdmin?: boolean): Promise<void>;
     destroy(name: string, yes?: boolean, force?: boolean): Promise<void>;
     use(name: string): Promise<void>;
     start(name?: string, restart?: boolean): Promise<void>;
     stop(name?: string): Promise<void>;
     list(): Promise<string>;
+    backup(service?: string, database?: string, file?: string, del?: boolean): Promise<void>;
+    restore(service?: string, database?: string, file?: string): Promise<void>;
     getNames(): Promise<string[]>;
 }

package/lib/controllers/MongodbController.js

@@ -28,26 +28,36 @@ let MongodbController = class MongodbController {
     constructor(mongodbService) {
         this.mongodbService = mongodbService;
     }
-    create(name, username, password, imageName, imageVersion) {
+    create(name, username, password, imageName, imageVersion, containerPort) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.mongodbService.create({
                 name,
                 username,
                 password,
                 imageName,
-                imageVersion
+                imageVersion,
+                containerPort
             });
         });
     }
-    upgrade(name, imageName, imageVersion, volume, configVolume) {
+    upgrade(name, imageName, imageVersion, volume, configVolume, containerPort, enableAdmin, disableAdmin) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.mongodbService.upgrade({
                 name,
                 imageName,
                 imageVersion,
                 volume,
-                configVolume
+                configVolume,
+                containerPort
             });
+            if (typeof enableAdmin !== "undefined") {
+                this.mongodbService.config.admin.enabled = true;
+                this.mongodbService.config.save();
+            }
+            if (typeof disableAdmin !== "undefined") {
+                this.mongodbService.config.admin.enabled = false;
+                this.mongodbService.config.save();
+            }
         });
     }
     destroy(name, yes, force) {
@@ -79,6 +89,20 @@ let MongodbController = class MongodbController {
             return this.mongodbService.list();
         });
     }
+    backup(service, database, file, del) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (del) {
+                yield this.mongodbService.deleteBackup(service, database, file);
+                return;
+            }
+            yield this.mongodbService.backup(service, database);
+        });
+    }
+    restore(service, database, file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.mongodbService.restore(service, database, file);
+        });
+    }
     getNames() {
         return __awaiter(this, void 0, void 0, function* () {
             return this.mongodbService.config.databases.map((database) => {
@@ -112,8 +136,10 @@ __decorate([
         alias: "I",
         description: "The image version to start the service with"
     })),
+    __param(5, (0, core_1.Option)("container-port")),
+    __param(5, (0, core_1.Description)("Port on which the database container will be accessible on the host")),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, String, String, String]),
+    __metadata("design:paramtypes", [String, String, String, String, String, Number]),
     __metadata("design:returntype", Promise)
 ], MongodbController.prototype, "create", null);
 __decorate([
@@ -140,8 +166,12 @@ __decorate([
         alias: "V",
         description: "The config volume name to start the service with"
     })),
+    __param(5, (0, core_1.Option)("container-port")),
+    __param(5, (0, core_1.Description)("Port on which the database container will be accessible on the host")),
+    __param(6, (0, core_1.Option)("enable-admin")),
+    __param(7, (0, core_1.Option)("disable-admin")),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, String, String, String]),
+    __metadata("design:paramtypes", [String, String, String, String, String, Number, Boolean, Boolean]),
     __metadata("design:returntype", Promise)
 ], MongodbController.prototype, "upgrade", null);
 __decorate([
@@ -198,9 +228,34 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], MongodbController.prototype, "list", null);
+__decorate([
+    (0, core_1.Command)("mongodb:backup [name]"),
+    __param(0, (0, core_1.Param)("name")),
+    __param(1, (0, core_1.Option)("database", "d")),
+    __param(1, (0, core_1.Description)("Database name to back up")),
+    __param(2, (0, core_1.Option)("filename", "f")),
+    __param(2, (0, core_1.Description)("Name of the backup file")),
+    __param(3, (0, core_1.Option)("delete", "D")),
+    __param(3, (0, core_1.Description)("Delete the specified backup file")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, Boolean]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "backup", null);
+__decorate([
+    (0, core_1.Command)("mongodb:restore [name]"),
+    __param(0, (0, core_1.Param)("name")),
+    __param(1, (0, core_1.Option)("database", "d")),
+    __param(1, (0, core_1.Description)("Database name to restore")),
+    __param(2, (0, core_1.Option)("file-name", "f")),
+    __param(2, (0, core_1.Description)("File name")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "restore", null);
 __decorate([
     (0, core_1.Completion)("name", "mongodb:start [name]"),
     (0, core_1.Completion)("name", "mongodb:stop [name]"),
+    (0, core_1.Completion)("name", "mongodb:backup [name]"),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)

package/lib/makes/Config.d.ts

@@ -1,11 +1,16 @@
 import { Database, DatabaseProps } from "./Database";
+export type AdminConfig = {
+    enabled: boolean;
+};
 export type ConfigProps = {
     default?: string;
     databases?: DatabaseProps[];
+    admin?: AdminConfig;
 };
 export declare abstract class Config {
     default?: string;
     databases: Database[];
+    admin: AdminConfig;
     constructor(props: ConfigProps);
     setDatabase(database: Database): void;
     hasDatabase(name: string): boolean;

package/lib/makes/Config.js

@@ -4,9 +4,12 @@ exports.Config = void 0;
 const Database_1 = require("./Database");
 class Config {
     constructor(props) {
-        const { default: defaultDatabase, databases = [] } = props;
+        const { default: defaultDatabase, databases = [], admin: { enabled: enabledAdmin = true } = {} } = props;
         this.default = defaultDatabase;
         this.databases = databases.map(database => new Database_1.Database(database));
+        this.admin = {
+            enabled: enabledAdmin
+        };
     }
     setDatabase(database) {
         let exists = false;
@@ -61,7 +64,8 @@ class Config {
             default: this.default,
             databases: this.databases.length > 0
                 ? this.databases.map((database) => database.toObject())
-                : []
+                : [],
+            admin: this.admin
         };
     }
 }

package/lib/makes/Database.d.ts

@@ -8,6 +8,7 @@ export type DatabaseProps = {
     storage?: string;
     volume?: string;
     configVolume?: string;
+    containerPort?: number;
 };
 export declare class Database {
     name: string;
@@ -15,6 +16,7 @@ export declare class Database {
     imageVersion?: string;
     username: string;
     password: string;
+    containerPort?: number;
     protected _configVolume?: string;
     protected _volume?: string;
     constructor(props: DatabaseProps);

package/lib/makes/Database.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Database = void 0;
 class Database {
     constructor(props) {
-        const { name, imageName, imageVersion, username, password, configStorage, configVolume, storage, volume } = props;
+        const { name, imageName, imageVersion, username, password, configStorage, configVolume, storage, volume, containerPort } = props;
         this.name = name;
         this.imageName = imageName;
         this.imageVersion = imageVersion;
@@ -11,6 +11,7 @@ class Database {
         this.password = password;
         this._configVolume = configStorage || configVolume;
         this._volume = storage || volume;
+        this.containerPort = containerPort;
     }
     get containerName() {
         return `mongodb-${this.name}.ws`;
@@ -54,7 +55,8 @@ class Database {
             username: this.username,
             password: this.password,
             volume: this._volume,
-            configVolume: this._configVolume
+            configVolume: this._configVolume,
+            containerPort: this.containerPort
         };
     }
 }

package/lib/services/MongodbService.d.ts

@@ -1,6 +1,6 @@
-import { AppConfigService, PluginConfigService, DockerService, ProxyService } from "@wocker/core";
+import { AppConfigService, PluginConfigService, DockerService, ProxyService, FileSystem } from "@wocker/core";
 import { Config } from "../makes/Config";
-import { DatabaseProps } from "../makes/Database";
+import { Database, DatabaseProps } from "../makes/Database";
 export declare class MongodbService {
     protected readonly appConfigService: AppConfigService;
     protected readonly pluginConfigService: PluginConfigService;
@@ -10,6 +10,7 @@ export declare class MongodbService {
     adminContainerName: string;
     constructor(appConfigService: AppConfigService, pluginConfigService: PluginConfigService, dockerService: DockerService, proxyService: ProxyService);
     get config(): Config;
+    get fs(): FileSystem;
     create(props?: Partial<DatabaseProps>): Promise<void>;
     upgrade(props: Partial<DatabaseProps>): Promise<void>;
     destroy(name: string, yes?: boolean, force?: boolean): Promise<void>;
@@ -17,5 +18,9 @@ export declare class MongodbService {
     start(name?: string, restart?: boolean): Promise<void>;
     admin(): Promise<void>;
     stop(name?: string): Promise<void>;
+    backup(name?: string, database?: string): Promise<void>;
+    deleteBackup(name?: string, database?: string, filename?: string, confirm?: boolean): Promise<void>;
+    restore(name?: string, database?: string, filename?: string): Promise<void>;
+    getDatabases(service: Database): Promise<string[]>;
     list(): Promise<string>;
 }

package/lib/services/MongodbService.js

@@ -24,6 +24,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongodbService = void 0;
 const core_1 = require("@wocker/core");
 const utils_1 = require("@wocker/utils");
+const format_1 = require("date-fns/format");
 const cli_table3_1 = __importDefault(require("cli-table3"));
 const Config_1 = require("../makes/Config");
 const Database_1 = require("../makes/Database");
@@ -54,6 +55,9 @@ let MongodbService = class MongodbService {
         }
         return this._config;
     }
+    get fs() {
+        return this.pluginConfigService.fs;
+    }
     create() {
         return __awaiter(this, arguments, void 0, function* (props = {}) {
             if (props.name && this.config.hasDatabase(props.name)) {
@@ -97,6 +101,21 @@ let MongodbService = class MongodbService {
                     throw new Error("Passwords do not match");
                 }
             }
+            if (!props.containerPort) {
+                const needPort = yield (0, utils_1.promptConfirm)({
+                    message: "Do you need to expose container port?",
+                    default: false
+                });
+                if (needPort) {
+                    props.containerPort = yield (0, utils_1.promptInput)({
+                        required: true,
+                        message: "Container port:",
+                        type: "number",
+                        min: 1,
+                        default: 27017
+                    });
+                }
+            }
             const database = new Database_1.Database({
                 name: props.name,
                 imageName: props.imageName,
@@ -128,6 +147,10 @@ let MongodbService = class MongodbService {
                 service.configVolume = props.configVolume;
                 changed = true;
             }
+            if (props.containerPort) {
+                service.containerPort = props.containerPort;
+                changed = true;
+            }
             if (changed) {
                 this.config.setDatabase(service);
                 this.config.save();
@@ -169,10 +192,10 @@ let MongodbService = class MongodbService {
     }
     start(name, restart) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.pluginConfigService.isVersionGTE("1.0.19")) {
+            if (!this.pluginConfigService.isVersionGTE("1.0.22")) {
                 throw new Error("Please update @wocker/ws");
             }
-            if (!name || !this.config.default) {
+            if (!name && !this.config.default) {
                 yield this.create();
             }
             const database = this.config.getDatabaseOrDefault(name);
@@ -201,7 +224,10 @@ let MongodbService = class MongodbService {
                     volumes: [
                         `${database.configVolume}:/data/configdb`,
                         `${database.volume}:/data/db`
-                    ]
+                    ],
+                    ports: database.containerPort ? [
+                        `${database.containerPort}:27017`
+                    ] : undefined
                 });
             }
             const { State: { Running } } = yield container.inspect();
@@ -230,7 +256,7 @@ let MongodbService = class MongodbService {
                 catch (ignore) { }
             }
             yield this.dockerService.removeContainer(this.adminContainerName);
-            if (connections.length === 0) {
+            if (!this.config.admin.enabled || connections.length === 0) {
                 return;
             }
             let container = yield this.dockerService.getContainer(this.adminContainerName);
@@ -268,6 +294,171 @@ let MongodbService = class MongodbService {
             yield this.dockerService.removeContainer(database.containerName);
         });
     }
+    backup(name, database) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const service = this.config.getDatabaseOrDefault(name);
+            if (!database) {
+                database = yield (0, utils_1.promptSelect)({
+                    message: "Database",
+                    required: true,
+                    options: yield this.getDatabases(service)
+                });
+            }
+            if (!this.fs.exists(`dump/${service.name}/${database}`)) {
+                this.fs.mkdir(`dump/${service.name}/${database}`, {
+                    recursive: true
+                });
+            }
+            let filename = (0, format_1.formatDate)(new Date(), "yyyy-MM-dd HH-mm") + ".sql";
+            const fileStream = this.fs.createWriteStream(`dump/${service.name}/${database}/${filename}`);
+            const stream = yield this.dockerService.exec(service.containerName, [
+                "mongodump",
+                "--authenticationDatabase", "admin",
+                "--host", `${service.containerName}:27017`,
+                "--username", "root",
+                "--password", "toor",
+                "--db", database,
+                "--archive",
+                "--gzip"
+            ], false);
+            stream.on("data", (chunk) => {
+                fileStream.write((0, utils_1.demuxOutput)(chunk));
+            });
+            try {
+                yield new Promise((resolve, reject) => {
+                    stream.on("end", resolve);
+                    stream.on("error", reject);
+                });
+            }
+            finally {
+                fileStream.close();
+            }
+        });
+    }
+    deleteBackup(name, database, filename, confirm) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const service = this.config.getDatabaseOrDefault(name);
+            if (!database) {
+                const databases = this.fs.readdir(`dumps/${service.name}`);
+                if (databases.length === 0) {
+                    throw new Error(`No backups were found for the "${service.name}" service`);
+                }
+                database = yield (0, utils_1.promptSelect)({
+                    message: "Database",
+                    required: true,
+                    options: databases
+                });
+            }
+            if (!filename) {
+                const files = this.fs.readdir(`dumps/${service.name}/${database}`);
+                if (files.length === 0) {
+                    throw new Error(`No backup files found for the "${database}" database`);
+                }
+                filename = yield (0, utils_1.promptSelect)({
+                    message: "File",
+                    required: true,
+                    options: files
+                });
+            }
+            if (!confirm) {
+                confirm = yield (0, utils_1.promptConfirm)({
+                    message: "Are you sure you want to delete?",
+                    default: false
+                });
+            }
+            if (!confirm) {
+                throw new Error("Canceled");
+            }
+            this.fs.rm(`dumps/${service.name}/${database}/${filename}`);
+            console.info(`File "${filename}" deleted`);
+            const otherFiles = this.fs.readdir(`dump/${service.name}/${database}`);
+            if (otherFiles.length === 0) {
+                this.fs.rm(`dump/${service.name}/${database}`, {
+                    force: true,
+                    recursive: true
+                });
+            }
+        });
+    }
+    restore(name, database, filename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const service = this.config.getDatabaseOrDefault(name);
+            if (!database) {
+                const databases = this.fs.readdir(`dumps/${service.name}`);
+                if (databases.length === 0) {
+                    throw new Error(`No backups were found for the "${service.name}" service`);
+                }
+                database = yield (0, utils_1.promptSelect)({
+                    message: "Database",
+                    required: true,
+                    options: databases
+                });
+            }
+            if (!filename) {
+                const files = this.fs.readdir(`dumps/${service.name}/${database}`);
+                if (files.length === 0) {
+                    throw new Error(`No backup files found for the "${database}" database`);
+                }
+                filename = yield (0, utils_1.promptSelect)({
+                    message: "File",
+                    required: true,
+                    options: files
+                });
+            }
+            const file = this.fs.createReadStream(`dumps/${service.name}/${database}/${filename}`);
+            const stream = yield this.dockerService.exec(service.containerName, [
+                "mongorestore",
+                "--authenticationDatabase", "admin",
+                "--host", `${service.containerName}:27017`,
+                "--username", service.username,
+                "--password", service.password,
+                "--db", database,
+                "--drop",
+                "--gzip",
+                "--archive"
+            ], false);
+            yield new Promise((resolve, reject) => {
+                file.on("data", (data) => {
+                    stream.write(data);
+                });
+                file.on("error", (err) => {
+                    stream.destroy();
+                    reject(err);
+                });
+                stream.on("finish", () => {
+                    resolve();
+                });
+                stream.on("error", (err) => {
+                    file.close();
+                    reject(err);
+                });
+            });
+        });
+    }
+    getDatabases(service) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stream = yield this.dockerService.exec(service.containerName, [
+                "mongosh",
+                "--username", service.username,
+                "--password", service.password,
+                "--quiet",
+                "--eval", "db.getMongo().getDBNames().forEach(function(i){print(i)})"
+            ], false);
+            const res = yield new Promise((resolve, reject) => {
+                let res = "";
+                stream.on("data", (chunk) => {
+                    res += (0, utils_1.demuxOutput)(chunk).toString();
+                });
+                stream.on("end", () => {
+                    resolve(res);
+                });
+                stream.on("error", reject);
+            });
+            return res.split(/\r?\n/).filter((database) => {
+                return !!database;
+            });
+        });
+    }
     list() {
         return __awaiter(this, void 0, void 0, function* () {
             const table = new cli_table3_1.default({
@@ -283,7 +474,7 @@ let MongodbService = class MongodbService {
                 table.push([
                     database.name + (database.name === this.config.default ? " (default)" : ""),
                     database.username,
-                    database.containerName,
+                    database.containerName + (database.containerPort ? `:${database.containerPort}` : ""),
                     database.image,
                     `${database.configVolume}\n${database.volume}`
                 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/mongodb-plugin",
-    "version": "1.0.7",
+    "version": "1.0.9-beta.0",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Mongodb plugin for wocker",
     "license": "MIT",
@@ -26,12 +26,13 @@
         "test": "echo \"Error: no test specified\" && exit 1"
     },
     "dependencies": {
-        "@wocker/core": "^1.0.22",
+        "@wocker/core": "^1.0.24",
         "@wocker/utils": "^2.0.3",
-        "cli-table3": "^0.6.5"
+        "cli-table3": "^0.6.5",
+        "date-fns": "^4.1.0"
     },
     "devDependencies": {
-        "@types/node": "^22.14.1",
+        "@types/node": "^24.0.13",
         "typescript": "^5.8.3"
     }
 }