@wocker/mongodb-plugin 1.0.14-beta.0 → 1.0.14-beta.1

package/lib/controllers/MongodbController.d.ts

@@ -2,14 +2,20 @@ 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, containerPort?: number): Promise<void>;
-    upgrade(name?: string, imageName?: string, imageVersion?: string, volume?: string, configVolume?: string, containerPort?: number, enableAdmin?: boolean, disableAdmin?: boolean): Promise<void>;
+    mongosh(name?: string, database?: string): Promise<void>;
+    init(adminHostname?: string): Promise<void>;
+    create(name?: string, username?: string, password?: string, image?: string, containerPort?: number): Promise<void>;
+    upgrade(name?: string, image?: 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>;
+    use(name?: string): Promise<string | undefined>;
     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[]>;
+    getDatabases(name?: string): Promise<string[]>;
+    getDumpDatabases(name?: string): Promise<string[]>;
+    getBackupFilenames(name?: string, database?: string): Promise<string[]>;
+    getRestoreFilenames(name?: string, database?: string): Promise<string[]>;
 }

package/lib/controllers/MongodbController.js

@@ -28,24 +28,32 @@ let MongodbController = class MongodbController {
     constructor(mongodbService) {
         this.mongodbService = mongodbService;
     }
-    create(name, username, password, imageName, imageVersion, containerPort) {
+    mongosh(name, database) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.mongodbService.mongosh(name, database);
+        });
+    }
+    init(adminHostname) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.mongodbService.init(adminHostname);
+        });
+    }
+    create(name, username, password, image, containerPort) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.mongodbService.create({
                 name,
                 username,
                 password,
-                imageName,
-                imageVersion,
+                image,
                 containerPort
             });
         });
     }
-    upgrade(name, imageName, imageVersion, volume, configVolume, containerPort, enableAdmin, disableAdmin) {
+    upgrade(name, image, volume, configVolume, containerPort, enableAdmin, disableAdmin) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.mongodbService.upgrade({
                 name,
-                imageName,
-                imageVersion,
+                image,
                 volume,
                 configVolume,
                 containerPort
@@ -69,6 +77,10 @@ let MongodbController = class MongodbController {
     }
     use(name) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!name) {
+                const database = this.mongodbService.config.getDefault();
+                return database.name;
+            }
             this.mongodbService.use(name);
         });
     }
@@ -110,8 +122,83 @@ let MongodbController = class MongodbController {
             });
         });
     }
+    getDatabases(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const service = this.mongodbService.config.getDatabaseOrDefault(name);
+                return yield this.mongodbService.getDatabases(service);
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    getDumpDatabases(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const service = this.mongodbService.config.getDatabaseOrDefault(name);
+                return yield this.mongodbService.getDumpDatabases(service);
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    getBackupFilenames(name, database) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!database) {
+                return [];
+            }
+            try {
+                const service = this.mongodbService.config.getDatabaseOrDefault(name);
+                return yield this.mongodbService.getDumpFiles(service, database);
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    getRestoreFilenames(name, database) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!database) {
+                return [];
+            }
+            try {
+                const service = this.mongodbService.config.getDatabaseOrDefault(name);
+                return yield this.mongodbService.getDumpFiles(service, database);
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
 };
 exports.MongodbController = MongodbController;
+__decorate([
+    (0, core_1.Command)("mongodb [name]"),
+    (0, core_1.Description)("Opens an interactive mongosh session for a specified MongoDB service."),
+    __param(0, (0, core_1.Param)("name")),
+    __param(1, (0, core_1.Option)("database", {
+        type: "string",
+        alias: "d",
+        description: "<name> Specify the database to connect to"
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "mongosh", null);
+__decorate([
+    (0, core_1.Command)("mongodb:init"),
+    (0, core_1.Description)("Initializes the MongoDB configuration."),
+    __param(0, (0, core_1.Option)("admin-hostname", {
+        type: "string",
+        alias: "A",
+        description: "Specifies the mongo-express hostname."
+    })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "init", null);
 __decorate([
     (0, core_1.Command)("mongodb:create [name]"),
     (0, core_1.Description)("Creates a MongoDB service with configurable credentials, host, and storage options."),
@@ -129,17 +216,12 @@ __decorate([
     __param(3, (0, core_1.Option)("image", {
         type: "string",
         alias: "i",
-        description: "The image name to start the service with",
-    })),
-    __param(4, (0, core_1.Option)("image-version", {
-        type: "string",
-        alias: "I",
-        description: "The image version to start the service with"
+        description: "The image to start the service with, e.g. \"mongo:6\""
     })),
-    __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(4, (0, core_1.Option)("container-port")),
+    __param(4, (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, Number]),
+    __metadata("design:paramtypes", [String, String, String, String, Number]),
     __metadata("design:returntype", Promise)
 ], MongodbController.prototype, "create", null);
 __decorate([
@@ -149,29 +231,24 @@ __decorate([
     __param(1, (0, core_1.Option)("image", {
         type: "string",
         alias: "i",
-        description: "The image name to start the service with"
+        description: "The image to start the service with, e.g. \"mongo:6\""
     })),
-    __param(2, (0, core_1.Option)("image-version", {
-        type: "string",
-        alias: "I",
-        description: "The image version to start the service with"
-    })),
-    __param(3, (0, core_1.Option)("volume", {
+    __param(2, (0, core_1.Option)("volume", {
         type: "string",
         alias: "v",
         description: "The volume name to start the service with"
     })),
-    __param(4, (0, core_1.Option)("config-volume", {
+    __param(3, (0, core_1.Option)("config-volume", {
         type: "string",
         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")),
+    __param(4, (0, core_1.Option)("container-port")),
+    __param(4, (0, core_1.Description)("Port on which the database container will be accessible on the host")),
+    __param(5, (0, core_1.Option)("enable-admin")),
+    __param(6, (0, core_1.Option)("disable-admin")),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, String, String, String, Number, Boolean, Boolean]),
+    __metadata("design:paramtypes", [String, String, String, String, Number, Boolean, Boolean]),
     __metadata("design:returntype", Promise)
 ], MongodbController.prototype, "upgrade", null);
 __decorate([
@@ -193,8 +270,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], MongodbController.prototype, "destroy", null);
 __decorate([
-    (0, core_1.Command)("mongodb:use <name>"),
-    (0, core_1.Description)("Sets a specified MongoDB service as the default."),
+    (0, core_1.Command)("mongodb:use [name]"),
+    (0, core_1.Description)("Sets a specified MongoDB service as the default, or prints the current default when no name is given."),
     __param(0, (0, core_1.Param)("name")),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
@@ -253,7 +330,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], MongodbController.prototype, "restore", null);
 __decorate([
-    (0, core_1.Completion)("name", "mongodb:use <name>"),
+    (0, core_1.Completion)("name", "mongodb [name]"),
+    (0, core_1.Completion)("name", "mongodb:use [name]"),
     (0, core_1.Completion)("name", "mongodb:start [name]"),
     (0, core_1.Completion)("name", "mongodb:stop [name]"),
     (0, core_1.Completion)("name", "mongodb:restore [name]"),
@@ -264,6 +342,37 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Promise)
 ], MongodbController.prototype, "getNames", null);
+__decorate([
+    (0, core_1.Completion)("database", "mongodb:backup [name]"),
+    (0, core_1.Completion)("database", "mongodb [name]"),
+    __param(0, (0, core_1.Param)("name")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "getDatabases", null);
+__decorate([
+    (0, core_1.Completion)("database", "mongodb:restore [name]"),
+    __param(0, (0, core_1.Param)("name")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "getDumpDatabases", null);
+__decorate([
+    (0, core_1.Completion)("filename", "mongodb:backup [name]"),
+    __param(0, (0, core_1.Param)("name")),
+    __param(1, (0, core_1.Option)("database")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "getBackupFilenames", null);
+__decorate([
+    (0, core_1.Completion)("file-name", "mongodb:restore [name]"),
+    __param(0, (0, core_1.Param)("name")),
+    __param(1, (0, core_1.Option)("database")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "getRestoreFilenames", null);
 exports.MongodbController = MongodbController = __decorate([
     (0, core_1.Controller)(),
     (0, core_1.Description)("MongoDB commands"),

package/lib/makes/Database.d.ts

@@ -1,6 +1,9 @@
 export type DatabaseProps = {
     name: string;
+    image?: string;
+    /** @deprecated use "image" */
     imageName?: string;
+    /** @deprecated use "image" */
     imageVersion?: string;
     username: string;
     password: string;
@@ -12,16 +15,16 @@ export type DatabaseProps = {
 };
 export declare class Database {
     name: string;
-    imageName?: string;
-    imageVersion?: string;
     username: string;
     password: string;
     containerPort?: number;
+    protected _image?: string;
     protected _configVolume?: string;
     protected _volume?: string;
     constructor(props: DatabaseProps);
     get containerName(): string;
     get image(): string;
+    set image(image: string | undefined);
     get volume(): string;
     set volume(volume: string);
     get configVolume(): string;

package/lib/makes/Database.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Database = void 0;
+const utils_1 = require("@wocker/utils");
 class Database {
     constructor(props) {
-        const { name, imageName, imageVersion, username, password, configStorage, configVolume, storage, volume, containerPort } = props;
+        const { name, image, imageName, imageVersion, username, password, configStorage, configVolume, storage, volume, containerPort } = props;
         this.name = name;
-        this.imageName = imageName;
-        this.imageVersion = imageVersion;
+        this._image = image || (imageName ? new utils_1.Image(imageName, imageVersion).toString() : undefined);
         this.username = username;
         this.password = password;
         this._configVolume = configStorage || configVolume;
@@ -17,11 +17,20 @@ class Database {
         return `mongodb-${this.name}.ws`;
     }
     get image() {
-        const imageName = this.imageName || "mongo", imageVersion = this.imageVersion;
-        if (!imageVersion) {
-            return imageName;
+        if (!this._image) {
+            return "mongo:latest";
         }
-        return `${imageName}:${imageVersion}`;
+        return this._image;
+    }
+    set image(image) {
+        if (!image) {
+            delete this._image;
+            return;
+        }
+        if (!utils_1.Image.isValid(image)) {
+            throw new Error(`Invalid image ${image}`);
+        }
+        this._image = image;
     }
     get volume() {
         if (!this._volume) {
@@ -50,8 +59,7 @@ class Database {
     toObject() {
         return {
             name: this.name,
-            imageName: this.imageName,
-            imageVersion: this.imageVersion,
+            image: this._image,
             username: this.username,
             password: this.password,
             volume: this._volume,

package/lib/makes/MongodbPluginConfig.d.ts

@@ -2,16 +2,17 @@ import { PluginConfig } from "@wocker/core";
 import { Database, DatabaseProps } from "./Database";
 export type AdminConfig = {
     enabled: boolean;
+    hostname: string;
 };
 export type ConfigProps = {
     default?: string;
-    databases?: DatabaseProps[];
     admin?: AdminConfig;
+    databases?: DatabaseProps[];
 };
 export declare class MongodbPluginConfig extends PluginConfig {
     default?: string;
-    databases: Database[];
     admin: AdminConfig;
+    databases: Database[];
     constructor(data: ConfigProps);
     setDatabase(database: Database): void;
     hasDatabase(name: string): boolean;

package/lib/makes/MongodbPluginConfig.js

@@ -6,12 +6,13 @@ const Database_1 = require("./Database");
 class MongodbPluginConfig extends core_1.PluginConfig {
     constructor(data) {
         super(data);
-        const { default: defaultDatabase, databases = [], admin: { enabled: enabledAdmin = true } = {} } = data;
+        const { default: defaultDatabase, admin: { enabled: enabledAdmin = true, hostname: adminHostname = "dbadmin-mongodb.workspace" } = {}, databases = [] } = data;
         this.default = defaultDatabase;
-        this.databases = databases.map(database => new Database_1.Database(database));
         this.admin = {
-            enabled: enabledAdmin
+            enabled: enabledAdmin,
+            hostname: adminHostname
         };
+        this.databases = databases.map(database => new Database_1.Database(database));
     }
     setDatabase(database) {
         let exists = false;
@@ -64,10 +65,10 @@ class MongodbPluginConfig extends core_1.PluginConfig {
     toObject() {
         return {
             default: this.default,
+            admin: this.admin,
             databases: this.databases.length > 0
                 ? this.databases.map((database) => database.toObject())
-                : [],
-            admin: this.admin
+                : []
         };
     }
 }

package/lib/services/MongodbService.d.ts

@@ -6,10 +6,11 @@ export declare class MongodbService {
     protected readonly dockerService: DockerService;
     protected readonly proxyService: ProxyService;
     protected _config?: MongodbPluginConfig;
-    adminContainerName: string;
     constructor(pluginConfigService: PluginConfigService, dockerService: DockerService, proxyService: ProxyService);
     get config(): MongodbPluginConfig;
     get fs(): FileSystem;
+    mongosh(name?: string, database?: string): Promise<void>;
+    init(adminHostname?: string): Promise<void>;
     create(props?: Partial<DatabaseProps>): Promise<void>;
     upgrade(props: Partial<DatabaseProps>): Promise<void>;
     destroy(name: string, yes?: boolean, force?: boolean): Promise<void>;
@@ -17,6 +18,8 @@ export declare class MongodbService {
     start(name?: string, restart?: boolean): Promise<void>;
     admin(): Promise<void>;
     stop(name?: string): Promise<void>;
+    getDumpDatabases(service: Database): Promise<string[]>;
+    getDumpFiles(service: Database, database: string): Promise<string[]>;
     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>;

package/lib/services/MongodbService.js

@@ -23,6 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongodbService = void 0;
 const core_1 = require("@wocker/core");
+const prompts_1 = require("@wocker/prompts");
 const utils_1 = require("@wocker/utils");
 const format_1 = require("date-fns/format");
 const cli_table3_1 = __importDefault(require("cli-table3"));
@@ -33,7 +34,6 @@ let MongodbService = class MongodbService {
         this.pluginConfigService = pluginConfigService;
         this.dockerService = dockerService;
         this.proxyService = proxyService;
-        this.adminContainerName = "dbadmin-mongodb.workspace";
     }
     get config() {
         if (!this._config) {
@@ -44,6 +44,44 @@ let MongodbService = class MongodbService {
     get fs() {
         return this.pluginConfigService.fs;
     }
+    mongosh(name, database) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const service = this.config.getDatabaseOrDefault(name);
+            const container = yield this.dockerService.getContainer(service.containerName);
+            if (!container) {
+                throw new Error(`Service "${service.name}" is not started`);
+            }
+            if (!database && process.stdin.isTTY) {
+                database = yield (0, prompts_1.promptSelect)({
+                    message: "Database:",
+                    options: yield this.getDatabases(service)
+                });
+            }
+            yield this.dockerService.exec(service.containerName, {
+                cmd: [
+                    "mongosh",
+                    "--username", service.username,
+                    "--password", service.password,
+                    ...(database ? [database] : [])
+                ],
+                tty: true
+            });
+        });
+    }
+    init(adminHostname) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = this.config;
+            if (!adminHostname) {
+                adminHostname = (yield (0, prompts_1.promptInput)({
+                    message: "Admin hostname",
+                    required: true,
+                    default: config.admin.hostname
+                }));
+            }
+            config.admin.hostname = adminHostname;
+            config.save();
+        });
+    }
     create() {
         return __awaiter(this, arguments, void 0, function* (props = {}) {
             if (props.name && this.config.hasDatabase(props.name)) {
@@ -51,7 +89,7 @@ let MongodbService = class MongodbService {
                 delete props.name;
             }
             if (!props.name) {
-                props.name = (yield (0, utils_1.promptInput)({
+                props.name = (yield (0, prompts_1.promptInput)({
                     message: "Mongodb name",
                     type: "text",
                     validate: (name) => {
@@ -66,19 +104,19 @@ let MongodbService = class MongodbService {
                 }));
             }
             if (!props.username) {
-                props.username = yield (0, utils_1.promptInput)({
+                props.username = yield (0, prompts_1.promptInput)({
                     message: "Username:",
                     type: "text",
                     required: true
                 });
             }
             if (!props.password) {
-                props.password = (yield (0, utils_1.promptInput)({
+                props.password = (yield (0, prompts_1.promptInput)({
                     message: "Password:",
                     type: "password",
                     required: true
                 }));
-                const confirmPassword = yield (0, utils_1.promptInput)({
+                const confirmPassword = yield (0, prompts_1.promptInput)({
                     message: "Confirm password:",
                     type: "password",
                     required: true
@@ -88,12 +126,12 @@ let MongodbService = class MongodbService {
                 }
             }
             if (!props.containerPort) {
-                const needPort = yield (0, utils_1.promptConfirm)({
+                const needPort = yield (0, prompts_1.promptConfirm)({
                     message: "Do you need to expose container port?",
                     default: false
                 });
                 if (needPort) {
-                    props.containerPort = yield (0, utils_1.promptInput)({
+                    props.containerPort = yield (0, prompts_1.promptInput)({
                         required: true,
                         message: "Container port:",
                         type: "number",
@@ -104,8 +142,7 @@ let MongodbService = class MongodbService {
             }
             const database = new Database_1.Database({
                 name: props.name,
-                imageName: props.imageName,
-                imageVersion: props.imageVersion,
+                image: props.image,
                 username: props.username,
                 password: props.password,
                 containerPort: props.containerPort
@@ -118,12 +155,8 @@ let MongodbService = class MongodbService {
         return __awaiter(this, void 0, void 0, function* () {
             const service = this.config.getDatabaseOrDefault(props.name);
             let changed = false;
-            if (props.imageName) {
-                service.imageName = props.imageName;
-                changed = true;
-            }
-            if (props.imageVersion) {
-                service.imageVersion = props.imageVersion;
+            if (props.image) {
+                service.image = props.image;
                 changed = true;
             }
             if (props.volume) {
@@ -154,7 +187,7 @@ let MongodbService = class MongodbService {
                 throw new Error(`Can't delete default database.`);
             }
             if (!yes) {
-                const confirm = yield (0, utils_1.promptConfirm)({
+                const confirm = yield (0, prompts_1.promptConfirm)({
                     message: `Are you sure you want to delete the "${database.name}" database? This action cannot be undone and all data will be lost.`,
                     default: false
                 });
@@ -226,6 +259,7 @@ let MongodbService = class MongodbService {
     }
     admin() {
         return __awaiter(this, void 0, void 0, function* () {
+            const hostname = this.config.admin.hostname;
             const connections = [];
             for (const database of this.config.databases) {
                 try {
@@ -242,22 +276,22 @@ let MongodbService = class MongodbService {
                 }
                 catch (ignore) { }
             }
-            yield this.dockerService.removeContainer(this.adminContainerName);
+            yield this.dockerService.removeContainer(hostname);
             if (!this.config.admin.enabled || connections.length === 0) {
                 return;
             }
-            let container = yield this.dockerService.getContainer(this.adminContainerName);
+            let container = yield this.dockerService.getContainer(hostname);
             if (!container) {
                 console.info("Mongodb Admin starting...");
                 yield this.dockerService.pullImage("mongo-express:latest");
                 container = yield this.dockerService.createContainer({
-                    name: this.adminContainerName,
+                    name: hostname,
                     image: "mongo-express:latest",
                     restart: "always",
                     env: {
-                        VIRTUAL_HOST: this.adminContainerName,
+                        VIRTUAL_HOST: hostname,
                         VIRTUAL_PORT: "80",
-                        VCAP_APP_HOST: this.adminContainerName,
+                        VCAP_APP_HOST: hostname,
                         PORT: "80",
                         ME_CONFIG_BASICAUTH: "false",
                         ME_CONFIG_BASICAUTH_USERNAME: "",
@@ -281,11 +315,27 @@ let MongodbService = class MongodbService {
             yield this.dockerService.removeContainer(database.containerName);
         });
     }
+    getDumpDatabases(service) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.fs.exists(`dump/${service.name}`)) {
+                return [];
+            }
+            return this.fs.readdir(`dump/${service.name}`);
+        });
+    }
+    getDumpFiles(service, database) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.fs.exists(`dump/${service.name}/${database}`)) {
+                return [];
+            }
+            return this.fs.readdir(`dump/${service.name}/${database}`);
+        });
+    }
     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)({
+                database = yield (0, prompts_1.promptSelect)({
                     message: "Database",
                     required: true,
                     options: yield this.getDatabases(service)
@@ -302,8 +352,8 @@ let MongodbService = class MongodbService {
                 "mongodump",
                 "--authenticationDatabase", "admin",
                 "--host", `${service.containerName}:27017`,
-                "--username", "root",
-                "--password", "toor",
+                "--username", service.username,
+                "--password", service.password,
                 "--db", database,
                 "--archive",
                 "--gzip"
@@ -329,29 +379,29 @@ let MongodbService = class MongodbService {
         return __awaiter(this, void 0, void 0, function* () {
             const service = this.config.getDatabaseOrDefault(name);
             if (!database) {
-                const databases = this.fs.readdir(`dumps/${service.name}`);
+                const databases = yield this.getDumpDatabases(service);
                 if (databases.length === 0) {
                     throw new Error(`No backups were found for the "${service.name}" service`);
                 }
-                database = yield (0, utils_1.promptSelect)({
+                database = yield (0, prompts_1.promptSelect)({
                     message: "Database",
                     required: true,
                     options: databases
                 });
             }
             if (!filename) {
-                const files = this.fs.readdir(`dumps/${service.name}/${database}`);
+                const files = yield this.getDumpFiles(service, database);
                 if (files.length === 0) {
                     throw new Error(`No backup files found for the "${database}" database`);
                 }
-                filename = yield (0, utils_1.promptSelect)({
+                filename = yield (0, prompts_1.promptSelect)({
                     message: "File",
                     required: true,
                     options: files
                 });
             }
             if (!confirm) {
-                confirm = yield (0, utils_1.promptConfirm)({
+                confirm = yield (0, prompts_1.promptConfirm)({
                     message: "Are you sure you want to delete?",
                     default: false
                 });
@@ -359,7 +409,7 @@ let MongodbService = class MongodbService {
             if (!confirm) {
                 throw new Error("Canceled");
             }
-            this.fs.rm(`dumps/${service.name}/${database}/${filename}`);
+            this.fs.rm(`dump/${service.name}/${database}/${filename}`);
             console.info(`File "${filename}" deleted`);
             const otherFiles = this.fs.readdir(`dump/${service.name}/${database}`);
             if (otherFiles.length === 0) {
@@ -374,28 +424,28 @@ let MongodbService = class MongodbService {
         return __awaiter(this, void 0, void 0, function* () {
             const service = this.config.getDatabaseOrDefault(name);
             if (!database) {
-                const databases = this.fs.readdir(`dumps/${service.name}`);
+                const databases = yield this.getDumpDatabases(service);
                 if (databases.length === 0) {
                     throw new Error(`No backups were found for the "${service.name}" service`);
                 }
-                database = yield (0, utils_1.promptSelect)({
+                database = yield (0, prompts_1.promptSelect)({
                     message: "Database",
                     required: true,
                     options: databases
                 });
             }
             if (!filename) {
-                const files = this.fs.readdir(`dumps/${service.name}/${database}`);
+                const files = yield this.getDumpFiles(service, database);
                 if (files.length === 0) {
                     throw new Error(`No backup files found for the "${database}" database`);
                 }
-                filename = yield (0, utils_1.promptSelect)({
+                filename = yield (0, prompts_1.promptSelect)({
                     message: "File",
                     required: true,
                     options: files
                 });
             }
-            const file = this.fs.createReadStream(`dumps/${service.name}/${database}/${filename}`);
+            const file = this.fs.createReadStream(`dump/${service.name}/${database}/${filename}`);
             const stream = yield this.dockerService.exec(service.containerName, [
                 "mongorestore",
                 "--authenticationDatabase", "admin",
@@ -463,16 +513,31 @@ let MongodbService = class MongodbService {
                     "Username",
                     "Host",
                     "Image",
-                    "Storages"
+                    "Storages",
+                    "Status",
+                    "IP"
                 ]
             });
             for (const database of this.config.databases) {
+                let status = "stopped";
+                let ip = "-";
+                try {
+                    const container = yield this.dockerService.getContainer(database.containerName);
+                    if (container) {
+                        const { State: { Running }, NetworkSettings: { Networks: { workspace: { IPAddress } } } } = yield container.inspect();
+                        status = Running ? "running" : "stopped";
+                        ip = IPAddress || "-";
+                    }
+                }
+                catch (ignore) { }
                 table.push([
                     database.name + (database.name === this.config.default ? " (default)" : ""),
                     database.username,
                     database.containerName + (database.containerPort ? `:${database.containerPort}` : ""),
                     database.image,
-                    `${database.configVolume}\n${database.volume}`
+                    `${database.configVolume}\n${database.volume}`,
+                    status,
+                    ip
                 ]);
             }
             return table.toString();

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@wocker/mongodb-plugin",
     "type": "commonjs",
-    "version": "1.0.14-beta.0",
+    "version": "1.0.14-beta.1",
     "author": "Kris Papercut <krispcut@gmail.com>",
     "description": "Mongodb plugin for wocker",
     "license": "MIT",
@@ -28,6 +28,7 @@
     },
     "dependencies": {
         "@wocker/core": "^1.1.0",
+        "@wocker/prompts": "^1.0.0",
         "@wocker/utils": "^2.0.3",
         "cli-table3": "^0.6.5",
         "date-fns": "^4.1.0"