oxygen-cli 1.40.2 → 1.42.0

package/build/ox_modules/module-mongo.js

@@ -0,0 +1,265 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+require("source-map-support/register");
+var _OxygenModule = _interopRequireDefault(require("../core/OxygenModule"));
+var _OxygenError = _interopRequireDefault(require("../errors/OxygenError"));
+var _helper = _interopRequireDefault(require("../errors/helper"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/*
+ * Copyright (C) 2015-current CloudBeat Limited
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ */
+const {
+  MongoClient
+} = require('mongodb');
+const MODULE_NAME = 'mongo';
+
+/**
+ * @name shell
+ * @description Provides methods for working with operating system shell.
+ */
+class MongoDbModule extends _OxygenModule.default {
+  constructor(options, context, rs, logger, modules, services) {
+    super(options, context, rs, logger, modules, services);
+    this._alwaysInitialized = false;
+    this._isInitialized = false;
+    this.client;
+    this.db;
+    this.collection;
+  }
+  /**
+   * @summary Initializes MongoDB session.
+   * @function init
+   * @param {string} hostOrUrl - Host name or full URL of the target MongoDB server.
+   * @param {string} dbName - Database name. You can change it later using "setDatabase" method.
+   * @param {string} [username] - Optional username for authentication.
+   * @param {string} [password] - Optional password for authentication.
+   * @param {string} [authSource=admin] - Optional authentication source. Default value is "admin".
+   * @param {number} [port=27017] - Optional MongoDB server port. Default value is 27017.
+   */
+  async init(hostOrUrl, dbName, username, password, authSource = 'admin', port = 27017) {
+    if (!hostOrUrl || typeof hostOrUrl !== 'string') {
+      throw new Error('MongoDB host name or full URL is not specified!');
+    } else if (!dbName) {
+      throw new Error('MongoDB database name is not specified!');
+    }
+    const isFullUrl = /^mongodb(\+srv)?:\/\//i.test(hostOrUrl);
+    const uri = isFullUrl ? hostOrUrl : (() => {
+      if (username) {
+        const encUsername = encodeURIComponent(username);
+        const encPassword = password ? encodeURIComponent(password) : undefined;
+        return `mongodb://${encUsername}:${encPassword || ''}@${hostOrUrl}:${port}/${dbName}?authSource=${authSource}`;
+      }
+      return `mongodb://${hostOrUrl}:${port}/${dbName}?authSource=${authSource}`;
+    })();
+    this.client = new MongoClient(uri, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true
+    });
+    try {
+      await this.client.connect();
+      this.db = this.client.db(dbName);
+      this._isInitialized = true;
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+
+  /**
+   * @summary Sets the current database to perform further actions.
+   * @function setDatabase 
+   * @param {string} dbName - Database name.
+   */
+  setDatabase(dbName) {
+    this.db = this.client.db(dbName);
+  }
+
+  /**
+   * @summary Sets the current collection to perform further actions.
+   * @function setCollection 
+   * @param {string} collectionName - Collection name.
+   */
+  setCollection(collectionName) {
+    if (!this.db) {
+      return false;
+    }
+    this.collection = this.db.collection(collectionName);
+    return true;
+  }
+
+  /**
+   * @summary Finds documents in the current collection.
+   * @function find 
+   * @param {object} filter - The filter predicate.
+   * @param {object} options - Optional settings for the command.
+   * @return {object} A list of documents.
+   */
+  async find(filter, options) {
+    if (!this.collection) {
+      return undefined;
+    }
+    try {
+      return await this.collection.find(filter, options).toArray();
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+
+  /**
+   * @summary Gets the number of documents matching the filter.
+   * @function countDocuments 
+   * @param {object} filter - The filter for the count.
+   * @param {object} options - Optional settings for the command.
+   * @return {number} Number of documents matching the filter.
+   */
+  async countDocuments(filter, options) {
+    if (!this.collection) {
+      return undefined;
+    }
+    try {
+      return await this.collection.countDocuments(filter, options);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+
+  /**
+   * @summary Inserts a single document into a collection.
+   * @function insertOne 
+   * @param {object} doc - The document to insert.
+   * @param {object} options - Optional settings for the command.
+   */
+  async insertOne(doc, options) {
+    if (!this.collection) {
+      return undefined;
+    }
+    try {
+      return await this.collection.insertOne(doc, options);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+
+  /**
+   * @summary Inserts an array of documents into a collection.
+   * @function insertMany 
+   * @param {object} docs - The documents to insert.
+   * @param {object} options - Optional settings for the command.
+   */
+  async insertMany(docs, options) {
+    if (!this.collection) {
+      return undefined;
+    }
+    try {
+      return await this.collection.insertMany(docs, options);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+
+  /**
+   * @summary Update a single document in a collection.
+   * @function updateOne 
+   * @param {object} filter - The filter used to select the document to replace.
+   * @param {UpdateFilter<TSchema>|Document[]} update - The modifications to apply.
+   * @param {object} options - Optional settings for the command.
+   */
+  async updateOne(filter, update) {
+    if (!this.collection) {
+      return undefined;
+    }
+    try {
+      return await this.collection.updateOne(filter, update);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+
+  /**
+   * @summary Update multiple documents in a collection.
+   * @function updateMany 
+   * @param {object} filter - The filter used to select the document to update.
+   * @param {UpdateFilter<TSchema>|Document[]} update - The modifications to apply.
+   * @param {object} options - Optional settings for the command.
+   */
+  async updateMany(filter, update, options) {
+    if (!this.collection) {
+      return undefined;
+    }
+    try {
+      return await this.collection.updateMany(filter, update, options);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+
+  /**
+   * @summary Replace a document in a collection with another document.
+   * @function replaceOne 
+   * @param {object} filter - The filter used to select the document to replace.
+   * @param {object} doc - The Document that replaces the matching document.
+   * @param {object} options - Optional settings for the command.
+   */
+  async replaceOne(filter, doc) {
+    if (!this.collection) {
+      return undefined;
+    }
+    try {
+      return await this.collection.replaceOne(filter, doc);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+
+  /**
+   * @summary Delete a document from a collection.
+   * @function deleteOne 
+   * @param {object} filter - The filter used to select the document to remove.
+   * @param {object} options - Optional settings for the command.
+   */
+  async deleteOne(filter) {
+    if (!this.collection) {
+      return undefined;
+    }
+    try {
+      return await this.collection.deleteOne(filter);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+  /**
+   * @summary Delete multiple documents from a collection.
+   * @function deleteMany 
+   * @param {object} filter - The filter used to select the documents to remove.
+   * @param {object} options - Optional settings for the command.
+   */
+  async deleteMany(filter) {
+    if (!this.collection) {
+      return undefined;
+    }
+    try {
+      return await this.collection.deleteMany(filter);
+    } catch (e) {
+      throw new _OxygenError.default(_helper.default.errorCode.MONGODB_ERROR, e.message, null, true, e);
+    }
+  }
+
+  /**
+   * @summary Gets module name
+   * @function name
+   * @return {String} Constant value "shell".
+   */
+  get name() {
+    return MODULE_NAME;
+  }
+}
+exports.default = MongoDbModule;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_OxygenModule","_interopRequireDefault","require","_OxygenError","_helper","e","__esModule","default","MongoClient","MODULE_NAME","MongoDbModule","OxygenModule","constructor","options","context","rs","logger","modules","services","_alwaysInitialized","_isInitialized","client","db","collection","init","hostOrUrl","dbName","username","password","authSource","port","Error","isFullUrl","test","uri","encUsername","encodeURIComponent","encPassword","undefined","useNewUrlParser","useUnifiedTopology","connect","OxError","errHelper","errorCode","MONGODB_ERROR","message","setDatabase","setCollection","collectionName","find","filter","toArray","countDocuments","insertOne","doc","insertMany","docs","updateOne","update","updateMany","replaceOne","deleteOne","deleteMany","name","exports"],"sources":["../../src/ox_modules/module-mongo.js"],"sourcesContent":["/*\r\n * Copyright (C) 2015-current CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\nconst { MongoClient } = require('mongodb');\r\nimport OxygenModule from '../core/OxygenModule';\r\nimport OxError from '../errors/OxygenError';\r\nimport errHelper from '../errors/helper';\r\n\r\nconst MODULE_NAME = 'mongo';\r\n\r\n/**\r\n * @name shell\r\n * @description Provides methods for working with operating system shell.\r\n */\r\nexport default class MongoDbModule extends OxygenModule {\r\n    constructor(options, context, rs, logger, modules, services) {\r\n        super(options, context, rs, logger, modules, services);\r\n        this._alwaysInitialized = false;\r\n        this._isInitialized = false;\r\n        this.client;\r\n        this.db;\r\n        this.collection;\r\n    }\r\n    /**\r\n     * @summary Initializes MongoDB session.\r\n     * @function init\r\n     * @param {string} hostOrUrl - Host name or full URL of the target MongoDB server.\r\n     * @param {string} dbName - Database name. You can change it later using \"setDatabase\" method.\r\n     * @param {string} [username] - Optional username for authentication.\r\n     * @param {string} [password] - Optional password for authentication.\r\n     * @param {string} [authSource=admin] - Optional authentication source. Default value is \"admin\".\r\n     * @param {number} [port=27017] - Optional MongoDB server port. Default value is 27017.\r\n     */\r\n    async init(\r\n        hostOrUrl,\r\n        dbName,\r\n        username,\r\n        password,\r\n        authSource = 'admin',\r\n        port = 27017,\r\n    ) {\r\n        if (!hostOrUrl || typeof hostOrUrl !== 'string') {\r\n            throw new Error('MongoDB host name or full URL is not specified!');\r\n        }\r\n        else if (!dbName) {\r\n            throw new Error('MongoDB database name is not specified!');\r\n        }\r\n        const isFullUrl = /^mongodb(\\+srv)?:\\/\\//i.test(hostOrUrl);\r\n        const uri = isFullUrl\r\n            ? hostOrUrl\r\n            : (() => {\r\n                if (username) {\r\n                    const encUsername = encodeURIComponent(username);\r\n                    const encPassword = password ? encodeURIComponent(password) : undefined;\r\n                    return `mongodb://${encUsername}:${encPassword || ''}@${hostOrUrl}:${port}/${dbName}?authSource=${authSource}`;\r\n                }\r\n                return `mongodb://${hostOrUrl}:${port}/${dbName}?authSource=${authSource}`;\r\n            })();\r\n        this.client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });\r\n        try {\r\n            await this.client.connect();\r\n            this.db = this.client.db(dbName);\r\n            this._isInitialized = true;\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Sets the current database to perform further actions.\r\n     * @function setDatabase \r\n     * @param {string} dbName - Database name.\r\n     */\r\n    setDatabase(dbName) {\r\n        this.db = this.client.db(dbName);\r\n    }\r\n\r\n    /**\r\n     * @summary Sets the current collection to perform further actions.\r\n     * @function setCollection \r\n     * @param {string} collectionName - Collection name.\r\n     */\r\n    setCollection(collectionName) {\r\n        if (!this.db) {\r\n            return false;\r\n        }\r\n        this.collection = this.db.collection(collectionName);\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @summary Finds documents in the current collection.\r\n     * @function find \r\n     * @param {object} filter - The filter predicate.\r\n     * @param {object} options - Optional settings for the command.\r\n     * @return {object} A list of documents.\r\n     */\r\n    async find(filter, options) {\r\n        if (!this.collection) {\r\n            return undefined;\r\n        }\r\n        try {\r\n            return await this.collection.find(filter, options).toArray();\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Gets the number of documents matching the filter.\r\n     * @function countDocuments \r\n     * @param {object} filter - The filter for the count.\r\n     * @param {object} options - Optional settings for the command.\r\n     * @return {number} Number of documents matching the filter.\r\n     */\r\n    async countDocuments(filter, options) {\r\n        if (!this.collection) {\r\n            return undefined;\r\n        }\r\n        try {\r\n            return await this.collection.countDocuments(filter, options);\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Inserts a single document into a collection.\r\n     * @function insertOne \r\n     * @param {object} doc - The document to insert.\r\n     * @param {object} options - Optional settings for the command.\r\n     */\r\n    async insertOne(doc, options) {\r\n        if (!this.collection) {\r\n            return undefined;\r\n        }\r\n        try {\r\n            return await this.collection.insertOne(doc, options);\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Inserts an array of documents into a collection.\r\n     * @function insertMany \r\n     * @param {object} docs - The documents to insert.\r\n     * @param {object} options - Optional settings for the command.\r\n     */\r\n    async insertMany(docs, options) {\r\n        if (!this.collection) {\r\n            return undefined;\r\n        }\r\n        try {\r\n            return await this.collection.insertMany(docs, options);\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Update a single document in a collection.\r\n     * @function updateOne \r\n     * @param {object} filter - The filter used to select the document to replace.\r\n     * @param {UpdateFilter<TSchema>|Document[]} update - The modifications to apply.\r\n     * @param {object} options - Optional settings for the command.\r\n     */\r\n    async updateOne(filter, update) {\r\n        if (!this.collection) {\r\n            return undefined;\r\n        }\r\n        try {\r\n            return await this.collection.updateOne(filter, update);\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Update multiple documents in a collection.\r\n     * @function updateMany \r\n     * @param {object} filter - The filter used to select the document to update.\r\n     * @param {UpdateFilter<TSchema>|Document[]} update - The modifications to apply.\r\n     * @param {object} options - Optional settings for the command.\r\n     */\r\n    async updateMany(filter, update, options) {\r\n        if (!this.collection) {\r\n            return undefined;\r\n        }\r\n        try {\r\n            return await this.collection.updateMany(filter, update, options);\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Replace a document in a collection with another document.\r\n     * @function replaceOne \r\n     * @param {object} filter - The filter used to select the document to replace.\r\n     * @param {object} doc - The Document that replaces the matching document.\r\n     * @param {object} options - Optional settings for the command.\r\n     */\r\n    async replaceOne(filter, doc) {\r\n        if (!this.collection) {\r\n            return undefined;\r\n        }\r\n        try {\r\n            return await this.collection.replaceOne(filter, doc);\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Delete a document from a collection.\r\n     * @function deleteOne \r\n     * @param {object} filter - The filter used to select the document to remove.\r\n     * @param {object} options - Optional settings for the command.\r\n     */\r\n    async deleteOne(filter) {\r\n        if (!this.collection) {\r\n            return undefined;\r\n        }\r\n        try {\r\n            return await this.collection.deleteOne(filter);\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\r\n        }\r\n    }\r\n    /**\r\n     * @summary Delete multiple documents from a collection.\r\n     * @function deleteMany \r\n     * @param {object} filter - The filter used to select the documents to remove.\r\n     * @param {object} options - Optional settings for the command.\r\n     */\r\n    async deleteMany(filter) {\r\n        if (!this.collection) {\r\n            return undefined;\r\n        }\r\n        try {\r\n            return await this.collection.deleteMany(filter);\r\n        }\r\n        catch (e) {\r\n            throw new OxError(errHelper.errorCode.MONGODB_ERROR, e.message, null, true, e);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Gets module name\r\n     * @function name\r\n     * @return {String} Constant value \"shell\".\r\n     */\r\n    get name() {\r\n        return MODULE_NAME;\r\n    }\r\n}"],"mappings":"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","ignoreList":[]}