@modular-rest/server 1.10.4 → 1.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modular-rest/server",
-  "version": "1.10.4",
+  "version": "1.11.1",
   "description": "a nodejs module based on KOAJS for developing Rest-APIs in a modular solution.",
   "main": "src/index.js",
   "scripts": {
@@ -43,4 +43,4 @@
     "@types/koa__cors": "^5.0.0",
     "typescript": "^5.3.3"
   }
-}
+}

package/src/application.js

@@ -112,11 +112,11 @@ async function createRest(options) {
    * - Setting up default services
    */
 
-  // Plug in default routes
+  // 1. Plug in default routes
   await Combination.combineRoutesByFilePath(path.join(defaultServiceRoot), app);
 
   // Collect default databaseDefinitions
-  let defaultDatabaseDefinitionList =
+  const defaultDatabaseDefinitionList =
     await Combination.combineModulesByFilePath({
       rootDirectory: defaultServiceRoot,
       filename: {
@@ -126,13 +126,13 @@ async function createRest(options) {
       combineWithRoot: true,
     });
 
-  // Plug in default databaseDefinitions
+  // 2. Plug in default databaseDefinitions
   await DataProvider.addCollectionDefinitionByList({
     list: defaultDatabaseDefinitionList,
     mongoOption: config.mongo,
   });
 
-  // Setting up default services
+  // 3. Setting up default services
   try {
     await require("./helper/presetup_services").setup(options);
   } catch (e) {
@@ -176,6 +176,15 @@ async function createRest(options) {
         config.verificationCodeGeneratorMethod
       );
     }
+
+    // 4. plug in modular functions
+    await Combination.combineFunctionsByFilePath({
+      rootDirectory: config.modulesPath,
+      filename: {
+        name: "functions",
+        extension: ".js",
+      },
+    });
   }
 
   /**

package/src/class/combinator.js

@@ -1,5 +1,6 @@
-let Router = require("koa-router");
-let directory = require("./directory.js");
+const Router = require("koa-router");
+const directory = require("./directory.js");
+const { addFunction } = require("./../services/functions/service.js");
 
 class Combinator {
   async combineRoutesByFilePath(rootDirectory, app) {
@@ -42,8 +43,8 @@ class Combinator {
   }) {
     // find route paths
     let rootObject_temp;
-    let option = { name: filename.name, filter: [filename.extension] };
-    let modulesPath = await directory
+    const option = { name: filename.name, filter: [filename.extension] };
+    const modulesPath = await directory
       .find(rootDirectory, option)
       .then()
       .catch((e) => {
@@ -52,9 +53,9 @@ class Combinator {
 
     // create and combine routes into the app
     for (let i = 0; i < modulesPath.length; i++) {
-      let moduleObject = require(modulesPath[i]);
+      const moduleObject = require(modulesPath[i]);
 
-      //act by otherOption
+      // act by otherOption
       if (combineWithRoot) {
         if (moduleObject.name) delete moduleObject.name;
 
@@ -69,7 +70,7 @@ class Combinator {
       }
       // default act
       else {
-        let name = moduleObject.name;
+        const name = moduleObject.name;
         rootObject_temp[name] = moduleObject;
       }
     }
@@ -84,6 +85,37 @@ class Combinator {
     return rootObject_temp;
   }
 
+  async combineFunctionsByFilePath({ rootDirectory, filename }) {
+    // find route paths
+    const option = { name: filename.name, filter: [filename.extension] };
+    const functionsPaths = await directory
+      .find(rootDirectory, option)
+      .then()
+      .catch((e) => {
+        console.log(e);
+      });
+
+    // create and combine routes into the app
+    for (let i = 0; i < functionsPaths.length; i++) {
+      const modularFunctions = require(functionsPaths[i]);
+
+      if (!modularFunctions.functions) {
+        throw new Error(
+          `Module file ${functionsPaths[i]} does not have functions property.`
+        );
+      }
+
+      // if array
+      if (modularFunctions.functions.length) {
+        for (const moduleFunction of modularFunctions.functions) {
+          addFunction(moduleFunction);
+        }
+      } else {
+        addFunction(modularFunctions.functions);
+      }
+    }
+  }
+
   extendObj(obj, src) {
     for (var key in src) {
       if (src.hasOwnProperty(key)) obj[key] = src[key];

package/src/index.js

@@ -7,6 +7,7 @@ const paginator = require("./class/paginator");
 const reply = require("./class/reply");
 const validator = require("./class/validator");
 const { getCollection } = require("./services/data_provider/service");
+const { defineFunction } = require("./services/functions/service");
 const TypeCasters = require("./services/data_provider/typeCasters");
 
 // Base class
@@ -28,6 +29,7 @@ module.exports = {
 
   // Service utilities
   getCollection,
+  defineFunction,
 
   // Database
   CollectionDefinition,

package/src/services/functions/router.js

@@ -0,0 +1,34 @@
+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", { e: 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", { e: e.message })));
+  }
+});
+
+module.exports.name = name;
+module.exports.main = functionRouter;

package/src/services/functions/service.js

@@ -0,0 +1,72 @@
+const functions = [];
+
+/**
+ * @typedef {import('../../class/security.js').PermissionType} PermissionType
+ */
+
+/**
+ * Defines a function with a given name, permission types, and callback.
+ *
+ * @param {Object} params - The parameters for the function.
+ * @param {string} params.name - The name of the function.
+ * @param {[PermissionType]} params.permissionTypes - The permission types for the function.
+ * @param {Function} params.callback - The callback to be executed by the function.
+ */
+function defineFunction({ name, permissionTypes, callback }) {
+  // Check if the function already exists
+  const existingFunction = functions.find((f) => f.name === name);
+  if (existingFunction) {
+    throw new Error(`Function with name ${name} already exists`);
+  }
+
+  // Check if the permission types provided
+  if (!permissionTypes || !permissionTypes.length) {
+    throw new Error(`Permission types not provided for function ${name}`);
+  }
+
+  // Check if the callback is a function
+  if (typeof callback !== "function") {
+    throw new Error(`Callback is not a function for function ${name}`);
+  }
+
+  // Add the function to the list of functions
+  return { name, permissionTypes, callback };
+}
+
+function runFunction(name, args, user) {
+  return new Promise((resolve, reject) => {
+    const func = functions.find((f) => f.name === name);
+    if (!func) {
+      reject(new Error(`Function with name ${name} not found`));
+    }
+
+    const hasPermission = func.permissionTypes.some((permissionType) =>
+      user.hasPermission(permissionType)
+    );
+
+    if (!!hasPermission) {
+      reject(
+        new Error(`User does not have permission to run function ${name}`)
+      );
+
+      console.log("Function permissions", func.permissionTypes);
+      console.log("User permissions", user.permissionGroup);
+    } else {
+      try {
+        resolve(func.callback(args));
+      } catch (e) {
+        reject(e);
+      }
+    }
+  });
+}
+
+function addFunction(func) {
+  functions.push(func);
+}
+
+module.exports = {
+  defineFunction,
+  runFunction,
+  addFunction,
+};