@modular-rest/server 1.11.13 → 1.11.15

package/src/services/data_provider/service.js

@@ -1,262 +0,0 @@
-let name = "dataProvider";
-const colog = require("colog");
-let {
-  AccessTypes,
-  AccessDefinition
-} = require("../../class/security");
-
-const Mongoose = require("mongoose");
-Mongoose.set("useCreateIndex", true);
-
-let connections = {};
-let collections = {};
-let permissionDefinitions = {};
-
-let triggers = require("../../class/trigger_operator");
-let TypeCasters = require("./typeCasters");
-const {
-  config
-} = require("../../config");
-
-/**
- *
- * @param {string} dbName database name
- * @param {array} CollectionDefinitionList an array of CollectionDefinition instance
- * @param {object} mongoOption
- * @param {string} mongoOption.dbPrefix
- * @param {string} mongoOption.mongoBaseAddress
- */
-function connectToDatabaseByCollectionDefinitionList(
-  dbName,
-  collectionDefinitionList = [],
-  mongoOption
-) {
-  return new Promise((done, reject) => {
-    // Create db connection
-    //
-    const fullDbName = (mongoOption.dbPrefix || "") + dbName;
-    const connectionString = mongoOption.mongoBaseAddress;
-
-    colog.info(`- Connecting to database: ${fullDbName}`);
-
-    let connection = Mongoose.createConnection(connectionString, {
-      useUnifiedTopology: true,
-      useNewUrlParser: true,
-      dbName: fullDbName,
-    });
-
-    // Store connection
-    connections[dbName] = connection;
-
-    // add db models from schemas
-    collectionDefinitionList.forEach((collectionDefinition) => {
-      let collection = collectionDefinition.collection;
-      let schema = collectionDefinition.schema;
-
-      if (collections[dbName] == undefined) collections[dbName] = {};
-
-      if (permissionDefinitions[dbName] == undefined)
-        permissionDefinitions[dbName] = {};
-
-      // create model from schema
-      // and store in on global collection object
-      let model = connection.model(collection, schema);
-      collections[dbName][collection] = model;
-
-      // define Access Definition from component permissions
-      // and store it on global access definition object
-      permissionDefinitions[dbName][collection] = new AccessDefinition({
-        database: dbName,
-        collection: collection,
-        permissionList: collectionDefinition.permissions,
-      });
-
-      // add trigger
-      if (collectionDefinition.triggers != undefined) {
-        if (!Array.isArray(collectionDefinition.triggers)) {
-          throw "Triggers must be an array";
-        }
-
-        collectionDefinition.triggers.forEach((trigger) => {
-          trigger.database = collectionDefinition.database;
-          trigger.collection = collectionDefinition.collection;
-          triggers.addTrigger(trigger);
-        });
-      }
-    });
-
-    connection.on("connected", () => {
-      colog.success(`- ${fullDbName} database has been connected`);
-      done();
-    });
-  });
-}
-
-/**
- *
- * @param {object} option
- * @param {array} option.list an array of CollectionDefinition instance
- * @param {object} option.mongoOption
- * @param {string} option.mongoOption.dbPrefix
- * @param {string} option.mongoOption.mongoBaseAddress
- */
-async function addCollectionDefinitionByList({
-  list,
-  mongoOption
-}) {
-  let clusteredByDBName = {};
-
-  // cluster list by their database name.
-  list.forEach((collectionDefinition) => {
-    let database = collectionDefinition.database;
-    if (!clusteredByDBName[database]) clusteredByDBName[database] = [];
-    clusteredByDBName[database].push(collectionDefinition);
-  });
-
-  // connect to databases
-  for (const dbName in clusteredByDBName) {
-    if (clusteredByDBName.hasOwnProperty(dbName)) {
-      const collectionDefinitionList = clusteredByDBName[dbName];
-      await connectToDatabaseByCollectionDefinitionList(
-        dbName,
-        collectionDefinitionList,
-        mongoOption
-      );
-    }
-  }
-}
-
-/**
- * Get a collection from a database.
- * @param {string} db - The database name.
- * @param {string} collection - The collection name.
- * @returns {import('mongoose').Model} The found collection.
- */
-function getCollection(db, collection) {
-  let fountCollection;
-
-  if (collections.hasOwnProperty(db)) {
-    if (collections[db].hasOwnProperty(collection))
-      fountCollection = collections[db][collection];
-  }
-
-  return fountCollection;
-}
-
-function _getPermissionList(db, collection, operationType) {
-  let permissionList = [];
-  let permissionDefinition;
-
-  if (!permissionDefinitions.hasOwnProperty(db)) return permissionList;
-
-  try {
-    permissionDefinition = permissionDefinitions[db][collection];
-  } catch (error) {
-    return permissionList;
-  }
-
-  permissionDefinition.permissionList.forEach((permission) => {
-    if (permission.onlyOwnData == true) {
-      permissionList.push(permission);
-    } else if (operationType == AccessTypes.read && permission.read == true) {
-      permissionList.push(permission);
-    } else if (operationType == AccessTypes.write && permission.write == true) {
-      permissionList.push(permission);
-    }
-  });
-
-  return permissionList;
-}
-
-/**
- * Check access to a collection.
- * @param {string} db - The database name.
- * @param {string} collection - The collection name.
- * @param {string} operationType - The operation type.
- * @param {object} queryOrDoc - The query or document.
- * @param {import('../../class/user')} user - The user.
- * @returns {boolean} The access result.
- */
-function checkAccess(db, collection, operationType, queryOrDoc, user) {
-  let key = false;
-
-  const collectionPermissionList = _getPermissionList(
-    db,
-    collection,
-    operationType
-  );
-
-  collectionPermissionList.forEach((permission) => {
-    const collectionPermissionType = permission.type;
-
-    if (permission.onlyOwnData == true) {
-      const userId = user.id;
-
-      try {
-        key =
-          queryOrDoc[permission.ownerIdField].toString() === userId.toString();
-      } catch (error) {
-        key = false;
-      }
-    } else if (operationType == AccessTypes.read && permission.read) {
-      key = user.hasPermission(collectionPermissionType);
-    } else if (operationType == AccessTypes.write && permission.write) {
-      key = user.hasPermission(collectionPermissionType);
-    }
-  });
-
-  return key;
-}
-
-function getAsID(strId) {
-  let id;
-  try {
-    id = Mongoose.Types.ObjectId(strId);
-  } catch (e) {
-    console.log("strId did not cast objectId", e);
-  }
-
-  return id;
-}
-
-function performPopulateToQueryObject(queryObj, popArr = []) {
-  /*
-      https://mongoosejs.com/docs/populate.html
-      popArr must be contains this objects
-      { 
-        path: 'fans',
-        select: 'name -_id',
-      }
-    */
-  popArr.forEach((pop) => queryObj.populate(pop));
-  return queryObj;
-}
-
-function performAdditionalOptionsToQueryObject(queryObj, options) {
-  /**
-   * https://mongoosejs.com/docs/api/query.html#query_Query-sort
-   *
-   * Options must be contain a method name and an argument of above methods.
-   * {
-   *  sort: '-_id',
-   *  limit: 10,
-   * }
-   */
-  Object.keys(options).forEach((method) => {
-    queryObj = queryObj[method](options[method]);
-  });
-
-  return queryObj;
-}
-
-module.exports = {
-  name,
-  getCollection,
-  addCollectionDefinitionByList,
-  checkAccess,
-  getAsID,
-  performPopulateToQueryObject,
-  performAdditionalOptionsToQueryObject,
-  triggers,
-  TypeCasters,
-};

package/src/services/data_provider/typeCasters.js

@@ -1,10 +0,0 @@
-const Mongoose = require('mongoose');
-
-module.exports = {
-  'ObjectId': Mongoose.Types.ObjectId,
-  'Date': (dateValue) => {
-      const strDate = dateValue.toString();
-      const mongoDateFormateInString = new Date(strDate).toISOString().split('T')[0];
-      return new Date(mongoDateFormateInString);
-  }
-}

package/src/services/file/db.js

@@ -1,29 +0,0 @@
-var mongoose = require("mongoose");
-var Schemas = require("../../class/db_schemas");
-
-let CollectionDefinition = require("../../class/collection_definition");
-let { Permission, PermissionTypes } = require("../../class/security");
-const { config } = require("../../config");
-
-module.exports = [
-  new CollectionDefinition({
-    db: "cms",
-    collection: "file",
-    schema: Schemas.file,
-    permissions: [
-      new Permission({
-        type: PermissionTypes.upload_file_access,
-        read: true,
-        write: true,
-        onlyOwnData: false,
-      }),
-      new Permission({
-        type: PermissionTypes.remove_file_access,
-        read: true,
-        write: true,
-        onlyOwnData: false,
-      }),
-    ],
-    triggers: config.fileTriggers || [],
-  }),
-];

package/src/services/file/router.js

@@ -1,92 +0,0 @@
-let Router = require('koa-router');
-let validateObject = require('../../class/validator');
-let reply = require('../../class/reply').create;
-let name = 'file';
-
-let { AccessTypes } = require('./../../class/security');
-
-let DataService = require('./../data_provider/service');
-let service = require('./service');
-let middleware = require('../../middlewares');
-let fileRouter = new Router();
-
-fileRouter.use('/', middleware.auth, async (ctx, next) => {
-    await next();
-});
-
-fileRouter.post('/', async (ctx) => {
-
-    let body = ctx.request.body;
-
-    // validate result
-	let bodyValidate = validateObject(body, 'tag');
-
-	// fields validation
-	if (!bodyValidate.isValid) {
-		ctx.status = 412;
-		ctx.body = reply('e', { 'e': bodyValidate.requires });
-		return;
-	}
-
-    // Access validation
-    let hasAccess = DataService.checkAccess('cms', 'file', AccessTypes.write, body, ctx.state.user);
-    if (!hasAccess) {
-        ctx.throw(403, 'access denied');
-        return
-    }
-
-    let file = ctx.request.files.file;
-    let result;
-
-    if (!file) {
-        ctx.status = 412;
-        result = reply('f',
-            { 'message': 'file field required' });
-    }
-
-    else {
-        await service.storeFile({
-            file: file,
-            ownerId: ctx.state.user.id,
-            tag: body.tag
-        })
-            .then((file) => {
-                result = reply('s', { file });
-            })
-            .catch((error) => {
-                ctx.status = 412;
-                result = reply('e', error);
-            });
-    }
-
-    ctx.body = result;
-});
-
-fileRouter.delete('/', async (ctx) => {
-    let body = ctx.request.query;
-    // validate
-    let bodyValidate = validateObject(body, 'id');
-
-    let result;
-
-    if (!bodyValidate.isValid) {
-        ctx.status = 412;
-        result = reply('f', { 'message': 'some fields required.', 'error': bodyValidate.requires });
-    }
-
-    else {
-        await service.removeFile(body.id)
-            .then(() => {
-                result = reply('s');
-            })
-            .catch((e) => {
-                ctx.status = 412;
-                result = reply('e', { 'error': e });
-            });
-    }
-
-    ctx.body = result;
-});
-
-module.exports.name = name;
-module.exports.main = fileRouter;

package/src/services/file/service.js

@@ -1,231 +0,0 @@
-const fs = require("file-system");
-const pathModule = require("path");
-const DataProvider = require("./../data_provider/service");
-const triggerService = require("./../../class/trigger_operator");
-const { config } = require("./../../config");
-
-class FileService {
-  constructor() {
-    this.directory = null;
-  }
-
-  setUploadDirectory(directory) {
-    this.directory = directory;
-  }
-
-  /**
-   *
-   * @param {string} fileType
-   * @param {string} tag
-   *
-   * @returns storedFile
-   * @returns storedFile.fileName
-   * @returns storedFile.directory
-   * @returns storedFile.fullPath
-   * @returns storedFile.fileFormat
-   */
-  createStoredDetail(fileType, tag) {
-    const typeParts = fileType.split("/");
-    const fileFormat = typeParts[1] || typeParts[0] || "unknown";
-
-    const time = new Date().getTime();
-    const fileName = `${time}.${fileFormat}`;
-
-    const fullPath = pathModule.join(
-      FileService.instance.directory,
-      fileFormat,
-      tag,
-      fileName
-    );
-
-    return { fileName, fullPath, fileFormat };
-  }
-
-  /**
-   * Stores a file, removes the given temporary file, and submits file details into the database.
-   *
-   * @param {Object} options - The options for storing the file.
-   * @param {Object} options.file - The file to be stored.
-   * @param {string} options.file.path - The path of the file.
-   * @param {string} options.file.type - The type of the file.
-   * @param {string} options.file.name - The original name of the file.
-   * @param {number} options.file.size - The size of the file.
-   * @param {string} options.ownerId - The ID of the owner of the file.
-   * @param {string} options.tag - The tag associated with the file.
-   * @param {boolean} [options.removeFileAfterStore=true] - Whether to remove the file after storing it.
-   *
-   * @returns {Promise} A promise that resolves with the document of the stored file.
-   *
-   * @throws {string} If the upload directory has not been set.
-   */
-  storeFile({ file, ownerId, tag, removeFileAfterStore = true }) {
-    if (!FileService.instance.directory)
-      throw "upload directory has not been set.";
-
-    let storedFile;
-
-    return (
-      new Promise(async (done, reject) => /**
-       * Store file and remove temp file
-       */ {
-        storedFile = FileService.instance.createStoredDetail(file.type, tag);
-
-        fs.copyFile(file.path, storedFile.fullPath, {
-          done: (err) => {
-            if (err) reject(err);
-            else done();
-
-            // remove temp file
-            if (removeFileAfterStore) fs.fs.unlinkSync(file.path);
-          },
-        });
-      })
-        /**
-         * Submit file detail into database
-         */
-        .then(() => {
-          // Get collection model for access to relative collection
-          const CollectionModel = DataProvider.getCollection("cms", "file");
-
-          const data = {
-            owner: ownerId,
-            fileName: storedFile.fileName,
-            originalName: file.name,
-            format: storedFile.fileFormat,
-            tag,
-            size: file.size,
-          };
-
-          // Create new document
-          const doc = new CollectionModel(data);
-
-          return doc.save().then((savedDoc) => {
-            triggerService.call("insert-one", "cms", "file", {
-              query: null,
-              queryResult: savedDoc,
-            });
-
-            return savedDoc;
-          });
-        })
-        .catch((err) => {
-          // remove stored file
-          fs.fs.unlinkSync(storedFile.fullPath);
-
-          throw err;
-        })
-    );
-  }
-
-  /**
-   * Removes a file from the disk.
-   *
-   * @param {string} path - The path of the file to be removed.
-   * @returns {Promise} A promise that resolves if the file is successfully removed, and rejects if an error occurs.
-   */
-  removeFromDisc(path) {
-    return new Promise((done, reject) => {
-      fs.fs.unlink(path, (err) => {
-        if (err) reject();
-        else done();
-      });
-    });
-  }
-
-  /**
-   * Removes a file from the database and the disk.
-   *
-   * @param {string} fileId - The ID of the file to be removed.
-   * @returns {Promise} A promise that resolves if the file is successfully removed, and rejects if an error occurs.
-   * @throws Will throw an error if upload directory has not been set.
-   */
-  removeFile(fileId) {
-    if (!FileService.instance.directory)
-      throw "upload directory has not been set.";
-
-    return new Promise(async (done, reject) => {
-      let CollectionModel = DataProvider.getCollection("cms", "file");
-      let fileDoc = await CollectionModel.findOne({ _id: fileId }).exec();
-
-      if (!fileDoc) {
-        reject("file not found");
-        return;
-      }
-
-      await CollectionModel.deleteOne({ _id: fileId })
-        .exec()
-        .then(() => {
-          // create file path
-          const filePath = pathModule.join(
-            FileService.instance.directory,
-            fileDoc.format,
-            fileDoc.tag,
-            fileDoc.fileName
-          );
-
-          // Remove file from disc
-          return FileService.instance
-            .removeFromDisc(filePath)
-            .catch(async (err) => {
-              // Recreate fileDoc if removing file operation has error
-              await new CollectionModel(fileDoc).save();
-
-              throw err;
-            });
-        })
-        .then(() => {
-          triggerService.call("remove-one", "cms", "file", {
-            query: { _id: fileId },
-            queryResult: null,
-          });
-        })
-        .then(done)
-        .catch(reject);
-    });
-  }
-
-  /**
-   * Retrieves a file from the database.
-   *
-   * @param {string} fileId - The ID of the file to be retrieved.
-   * @returns {Promise} A promise that resolves with the file document, or rejects if an error occurs.
-   */
-  getFile(fileId) {
-    const CollectionModel = DataProvider.getCollection("cms", "file");
-
-    return CollectionModel.findOne({ _id: fileId }).exec();
-  }
-
-  /**
-   * Retrieves the link of a file.
-   *
-   * @param {string} fileId - The ID of the file to get the link for.
-   * @returns {Promise} A promise that resolves with the file link, or rejects if an error occurs.
-   */
-  async getFileLink(fileId) {
-    const fileDoc = await FileService.instance.getFile(fileId);
-
-    const link =
-      config.staticPath.rootPath +
-      `/${fileDoc.format}/${fileDoc.tag}/` +
-      fileDoc.fileName;
-
-    return link;
-  }
-
-  async getFilePath(fileId) {
-    const { fileName, format, tag } = await FileService.instance.getFile(
-      fileId
-    );
-    const fullPath = pathModule.join(
-      FileService.instance.directory,
-      format,
-      tag,
-      fileName
-    );
-    return fullPath;
-  }
-}
-
-FileService.instance = new FileService();
-module.exports = FileService.instance;

package/src/services/functions/router.js

@@ -1,37 +0,0 @@
-const Router = require("koa-router");
-const service = require("./service");
-const middleware = require("../../middlewares");
-const validateObject = require("../../class/validator");
-const reply = require("../../class/reply").create;
-
-const functionRouter = new Router();
-const name = "function";
-
-functionRouter.use("/", middleware.auth, async (ctx, next) => {
-  const body = ctx.request.body;
-  const bodyValidated = validateObject(body, "name args");
-
-  // fields validation
-  if (!bodyValidated.isValid) {
-    ctx.throw(
-      412,
-      JSON.stringify(reply("e", { error: bodyValidated.requires }))
-    );
-  }
-
-  await next();
-});
-
-functionRouter.post(`/run`, middleware.auth, async (ctx) => {
-  const { name, args } = ctx.request.body;
-
-  try {
-    const result = await service.runFunction(name, args, ctx.state.user);
-    ctx.body = JSON.stringify(reply("s", { data: result }));
-  } catch (e) {
-    ctx.throw(400, JSON.stringify(reply("e", { error: e.message })));
-  }
-});
-
-module.exports.name = name;
-module.exports.main = functionRouter;