@wocker/mongodb-plugin 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kris Papercut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+# @wocker/mongodb-plugin
+
+###### Docker workspace for web projects
+
+## Installation
+
+**Note:** It is recommended to install Wocker globally to ensure accessibility from any directory in your terminal.
+
+```shell
+npm i -g @wocker/ws
+```
+
+```shell
+ws plugin:add mongodb
+```
+
+
+### Completion
+
+Wocker comes with shell completion support to enhance your development workflow. To enable shell completion, run the following command:
+
+```bash
+source <(ws completion script)
+```
+
+This will enable tab completion for `ws` commands, providing a more convenient and efficient way to interact with the tool.
+
+
+## Documentation
+
+Wocker is a powerful tool for managing your web project's Docker workspace. It provides a convenient and efficient way to set up and manage your Docker containers.
+
+For more information and detailed usage, please refer to the [documentation](https://kearisp.github.io/wocker).

package/lib/controllers/MongodbController.d.ts

@@ -0,0 +1,11 @@
+import { MongodbService } from "../services/MongodbService";
+export declare class MongodbController {
+    protected readonly mongodbService: MongodbService;
+    constructor(mongodbService: MongodbService);
+    create(name?: string): Promise<void>;
+    destroy(name: string, yes?: boolean, force?: boolean): Promise<void>;
+    start(name?: string, restart?: boolean): Promise<void>;
+    stop(name?: string): Promise<void>;
+    list(): Promise<string>;
+    getNames(): Promise<string[]>;
+}

package/lib/controllers/MongodbController.js

@@ -0,0 +1,114 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongodbController = void 0;
+const core_1 = require("@wocker/core");
+const MongodbService_1 = require("../services/MongodbService");
+let MongodbController = class MongodbController {
+    constructor(mongodbService) {
+        this.mongodbService = mongodbService;
+    }
+    create(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.mongodbService.create(name);
+        });
+    }
+    destroy(name, yes, force) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.mongodbService.stop(name);
+            yield this.mongodbService.destroy(name, yes, force);
+            yield this.mongodbService.admin();
+        });
+    }
+    start(name, restart) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.mongodbService.start(name, restart);
+            yield this.mongodbService.admin();
+        });
+    }
+    stop(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.mongodbService.stop(name);
+            yield this.mongodbService.admin();
+        });
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mongodbService.list();
+        });
+    }
+    getNames() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [];
+        });
+    }
+};
+exports.MongodbController = MongodbController;
+__decorate([
+    (0, core_1.Command)("mongodb:create [name]"),
+    __param(0, (0, core_1.Param)("name")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "create", null);
+__decorate([
+    (0, core_1.Command)("mongodb:destroy <name>"),
+    __param(0, (0, core_1.Param)("name")),
+    __param(1, (0, core_1.Option)("yes", { alias: "y" })),
+    __param(2, (0, core_1.Option)("force", { alias: "f" })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Boolean, Boolean]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "destroy", null);
+__decorate([
+    (0, core_1.Command)("mongodb:start [name]"),
+    __param(0, (0, core_1.Param)("name")),
+    __param(1, (0, core_1.Option)("restart", { alias: "r" })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Boolean]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "start", null);
+__decorate([
+    (0, core_1.Command)("mongodb:stop [name]"),
+    __param(0, (0, core_1.Param)("name")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "stop", null);
+__decorate([
+    (0, core_1.Command)("mongodb:ls"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "list", null);
+__decorate([
+    (0, core_1.Completion)("name", "mongodb:start [name]"),
+    (0, core_1.Completion)("name", "mongodb:stop [name]"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], MongodbController.prototype, "getNames", null);
+exports.MongodbController = MongodbController = __decorate([
+    (0, core_1.Controller)(),
+    __metadata("design:paramtypes", [MongodbService_1.MongodbService])
+], MongodbController);

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export default class MongodbPlugin {
+    load(): Promise<void>;
+}

package/lib/index.js

@@ -0,0 +1,38 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@wocker/core");
+const MongodbController_1 = require("./controllers/MongodbController");
+const MongodbService_1 = require("./services/MongodbService");
+let MongodbPlugin = class MongodbPlugin {
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(">_<");
+        });
+    }
+};
+MongodbPlugin = __decorate([
+    (0, core_1.Plugin)({
+        name: "mongodb",
+        controllers: [MongodbController_1.MongodbController],
+        providers: [
+            core_1.PluginConfigService,
+            MongodbService_1.MongodbService
+        ]
+    })
+], MongodbPlugin);
+exports.default = MongodbPlugin;

package/lib/makes/Config.d.ts

@@ -0,0 +1,15 @@
+import { ConfigCollection } from "@wocker/core";
+import { Database, DatabaseProps } from "./Database";
+export type ConfigProps = {
+    default?: string;
+    databases?: DatabaseProps[];
+};
+export declare abstract class Config {
+    default?: string;
+    databases: ConfigCollection<Database, DatabaseProps>;
+    constructor(props: ConfigProps);
+    getDatabase(name?: string): Database;
+    removeDatabase(name: string): void;
+    abstract save(): Promise<void>;
+    toJSON(): ConfigProps;
+}

package/lib/makes/Config.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const core_1 = require("@wocker/core");
+const Database_1 = require("./Database");
+class Config {
+    constructor(props) {
+        const { default: defaultDatabase, databases = [] } = props;
+        this.default = defaultDatabase;
+        this.databases = new core_1.ConfigCollection(Database_1.Database, databases);
+    }
+    getDatabase(name) {
+        if (!name) {
+            if (!this.default) {
+                throw new Error("Default database is not defined");
+            }
+            const database = this.databases.getConfig(this.default);
+            if (!database) {
+                throw new Error(`Default database ${this.default} not found`);
+            }
+            return database;
+        }
+        const database = this.databases.getConfig(name);
+        if (!database) {
+            throw new Error(`Database ${name} not found`);
+        }
+        return database;
+    }
+    removeDatabase(name) {
+        const database = this.databases.getConfig(name);
+        if (!database) {
+            throw new Error(`Storage ${name} not found`);
+        }
+        this.databases.removeConfig(name);
+    }
+    toJSON() {
+        return {
+            default: this.default,
+            databases: this.databases.toArray()
+        };
+    }
+}
+exports.Config = Config;

package/lib/makes/Database.d.ts

@@ -0,0 +1,17 @@
+import { Config, ConfigProperties } from "@wocker/core";
+export type DatabaseProps = ConfigProperties & {
+    username: string;
+    password: string;
+    configStorage?: string;
+    storage?: string;
+};
+export declare class Database extends Config<DatabaseProps> {
+    username: string;
+    password: string;
+    configStorage: string;
+    storage: string;
+    constructor(props: DatabaseProps);
+    get containerName(): string;
+    get defaultStorage(): string;
+    get defaultConfigStorage(): string;
+}

package/lib/makes/Database.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+const core_1 = require("@wocker/core");
+class Database extends core_1.Config {
+    constructor(props) {
+        super(props);
+        const { username, password, configStorage, storage } = props;
+        this.username = username;
+        this.password = password;
+        this.configStorage = configStorage || this.defaultConfigStorage;
+        this.storage = storage || this.defaultStorage;
+    }
+    get containerName() {
+        return `mongodb-${this.name}.ws`;
+    }
+    get defaultStorage() {
+        return `wocker-mongodb-${this.name}`;
+    }
+    get defaultConfigStorage() {
+        return `wocker-mongodb-config-${this.name}`;
+    }
+}
+exports.Database = Database;

package/lib/services/MongodbService.d.ts

@@ -0,0 +1,18 @@
+import { AppConfigService, PluginConfigService, DockerService, ProxyService } from "@wocker/core";
+import { Config } from "../makes/Config";
+export declare class MongodbService {
+    protected readonly appConfigService: AppConfigService;
+    protected readonly pluginConfigService: PluginConfigService;
+    protected readonly dockerService: DockerService;
+    protected readonly proxyService: ProxyService;
+    adminContainerName: string;
+    constructor(appConfigService: AppConfigService, pluginConfigService: PluginConfigService, dockerService: DockerService, proxyService: ProxyService);
+    protected _config?: Config;
+    get config(): Config;
+    create(name?: string): Promise<void>;
+    destroy(name: string, yes?: boolean, force?: boolean): Promise<void>;
+    start(name?: string, restart?: boolean): Promise<void>;
+    admin(): Promise<void>;
+    stop(name?: string): Promise<void>;
+    list(): Promise<string>;
+}

package/lib/services/MongodbService.js

@@ -0,0 +1,261 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongodbService = void 0;
+const core_1 = require("@wocker/core");
+const utils_1 = require("@wocker/utils");
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const Config_1 = require("../makes/Config");
+const Database_1 = require("../makes/Database");
+let MongodbService = class MongodbService {
+    constructor(appConfigService, pluginConfigService, dockerService, proxyService) {
+        this.appConfigService = appConfigService;
+        this.pluginConfigService = pluginConfigService;
+        this.dockerService = dockerService;
+        this.proxyService = proxyService;
+        this.adminContainerName = "dbadmin-mongodb.workspace";
+    }
+    get config() {
+        if (!this._config) {
+            const data = this.pluginConfigService.fs.exists("config.json")
+                ? this.pluginConfigService.fs.readJSON("config.json")
+                : {
+                    default: "default",
+                    databases: [
+                        {
+                            name: "default",
+                            username: "root",
+                            password: "toor",
+                            configStorage: "wocker-mongoconfig-default",
+                            storage: "wocker-mongodb-default"
+                        }
+                    ]
+                };
+            const fs = this.pluginConfigService.fs;
+            this._config = new class extends Config_1.Config {
+                save() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        if (!fs.exists()) {
+                            fs.mkdir("", {
+                                recursive: true
+                            });
+                        }
+                        yield fs.writeJSON("config.json", this.toJSON());
+                    });
+                }
+            }(data);
+        }
+        return this._config;
+    }
+    create(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (name && this.config.databases.getConfig(name)) {
+                throw new Error(`${name}`);
+            }
+            if (!name) {
+                name = (yield (0, utils_1.promptText)({
+                    message: "Mongodb name:",
+                    type: "string",
+                    validate: (name) => {
+                        if (!name) {
+                            return "Name is required";
+                        }
+                        if (this.config.databases.getConfig(name)) {
+                            return `Database name "${name}" is already taken`;
+                        }
+                        return true;
+                    }
+                }));
+            }
+            let username = "";
+            if (!username) {
+                username = yield (0, utils_1.promptText)({
+                    message: "Username:",
+                    type: "string"
+                });
+            }
+            let password = "";
+            if (!password) {
+                password = yield (0, utils_1.promptText)({
+                    message: "Password:",
+                    type: "string"
+                });
+            }
+            const database = new Database_1.Database({
+                name,
+                username,
+                password
+            });
+            this.config.databases.setConfig(database);
+            yield this.config.save();
+        });
+    }
+    destroy(name, yes, force) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.appConfigService.isVersionGTE || !this.appConfigService.isVersionGTE("1.0.19")) {
+                throw new Error("Please update @wocker/ws");
+            }
+            const database = this.config.getDatabase(name);
+            if (!force && database.name === this.config.default) {
+                throw new Error(`Can't delete default database.`);
+            }
+            if (!yes) {
+                const confirm = yield (0, utils_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
+                });
+                if (!confirm) {
+                    throw new Error("Aborted");
+                }
+            }
+            if (database.configStorage === database.defaultConfigStorage && (yield this.dockerService.hasVolume(database.configStorage))) {
+                yield this.dockerService.rmVolume(database.configStorage);
+            }
+            if (database.storage === database.defaultStorage && (yield this.dockerService.hasVolume(database.storage))) {
+                yield this.dockerService.rmVolume(database.storage);
+            }
+            this.config.removeDatabase(database.name);
+            yield this.config.save();
+        });
+    }
+    start(name, restart) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.appConfigService.isVersionGTE || !this.appConfigService.isVersionGTE("1.0.19")) {
+                throw new Error("Please update @wocker/ws");
+            }
+            const database = this.config.getDatabase(name);
+            if (restart) {
+                yield this.dockerService.removeContainer(database.containerName);
+            }
+            let container = yield this.dockerService.getContainer(database.containerName);
+            if (!container) {
+                container = yield this.dockerService.createContainer({
+                    name: database.containerName,
+                    restart: "always",
+                    image: "mongo:latest",
+                    env: {
+                        MONGO_INITDB_ROOT_USERNAME: database.username,
+                        MONGO_INITDB_ROOT_PASSWORD: database.password,
+                        MONGO_ROOT_USER: database.username,
+                        MONGO_ROOT_PASSWORD: database.password
+                    },
+                    volumes: [
+                        `${database.configStorage}:/data/configdb`,
+                        `${database.storage}:/data/db`
+                    ]
+                });
+            }
+            const { State: { Running } } = yield container.inspect();
+            if (!Running) {
+                console.info(`Starting ${database.name} service...`);
+                yield container.start();
+            }
+        });
+    }
+    admin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connections = [];
+            for (const database of this.config.databases.items) {
+                try {
+                    const container = yield this.dockerService.getContainer(database.containerName);
+                    if (!container) {
+                        continue;
+                    }
+                    const { State: { Running } } = yield container.inspect();
+                    if (Running) {
+                        connections.push(`mongodb://${database.username}:${database.password}@${database.containerName}:27017`);
+                        // Multiple servers are not supported by mongo-express
+                        break;
+                    }
+                }
+                catch (ignore) { }
+            }
+            yield this.dockerService.removeContainer(this.adminContainerName);
+            if (connections.length === 0) {
+                return;
+            }
+            let container = yield this.dockerService.getContainer(this.adminContainerName);
+            if (!container) {
+                console.info("Mongodb Admin starting...");
+                yield this.dockerService.pullImage("mongo-express:latest");
+                container = yield this.dockerService.createContainer({
+                    name: this.adminContainerName,
+                    image: "mongo-express:latest",
+                    restart: "always",
+                    env: {
+                        VIRTUAL_HOST: this.adminContainerName,
+                        VIRTUAL_PORT: "80",
+                        VCAP_APP_HOST: this.adminContainerName,
+                        PORT: "80",
+                        ME_CONFIG_BASICAUTH: "false",
+                        ME_CONFIG_BASICAUTH_USERNAME: "",
+                        ME_CONFIG_BASICAUTH_PASSWORD: "",
+                        ME_CONFIG_MONGODB_ENABLE_ADMIN: "true",
+                        ME_CONFIG_MONGODB_URL: connections.join(",")
+                    }
+                });
+            }
+            const { State: { Running } } = yield container.inspect();
+            if (!Running) {
+                yield container.start();
+                yield this.proxyService.start();
+            }
+        });
+    }
+    stop(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const database = this.config.getDatabase(name);
+            console.info(`Stopping ${database.name}...`);
+            yield this.dockerService.removeContainer(database.containerName);
+        });
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const table = new cli_table3_1.default({
+                head: [
+                    "Name",
+                    "Username",
+                    "Host",
+                    "Storages"
+                ]
+            });
+            for (const database of this.config.databases.items) {
+                table.push([
+                    database.name,
+                    database.username,
+                    database.containerName,
+                    `${database.configStorage}\n${database.storage}`
+                ]);
+            }
+            return table.toString();
+        });
+    }
+};
+exports.MongodbService = MongodbService;
+exports.MongodbService = MongodbService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.AppConfigService,
+        core_1.PluginConfigService,
+        core_1.DockerService,
+        core_1.ProxyService])
+], MongodbService);

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "@wocker/mongodb-plugin",
+    "version": "1.0.0-beta.0",
+    "author": "Kris Papercut <krispcut@gmail.com>",
+    "description": "Mongodb plugin for wocker",
+    "license": "MIT",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "keywords": [
+        "wocker",
+        "plugin",
+        "mongodb"
+    ],
+    "homepage": "https://kearisp.github.io/wocker/plugins/mongodb",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/kearisp/wocker-mongodb-plugin.git"
+    },
+    "bugs": {
+        "url": "https://github.com/kearisp/wocker-mongodb-plugin/issues"
+    },
+    "scripts": {
+        "prepare": "npm run build",
+        "watch": "tsc -w",
+        "build": "tsc",
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "dependencies": {
+        "@wocker/core": "^1.0.20",
+        "@wocker/utils": "^1.0.8",
+        "cli-table3": "^0.6.5"
+    },
+    "devDependencies": {
+        "@types/node": ">=20.17.6",
+        "typescript": "^5.6.3"
+    }
+}