@wocker/mongodb-plugin 1.0.7 → 1.0.8

package/lib/controllers/MongodbController.d.ts

@@ -9,5 +9,7 @@ export declare class MongodbController {
     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

@@ -79,6 +79,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) => {
@@ -198,9 +212,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/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)) {
@@ -169,10 +173,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);
@@ -268,6 +272,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({

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@wocker/mongodb-plugin",
-    "version": "1.0.7",
+    "version": "1.0.8",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Mongodb plugin for wocker",
     "license": "MIT",
@@ -28,7 +28,8 @@
     "dependencies": {
         "@wocker/core": "^1.0.22",
         "@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",