@paralect/hive 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paralect/hive",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "",
   "main": "index.js",
   "bin": {

package/starter/src/app-config/index.js

@@ -1,3 +1,4 @@
+import _ from 'lodash';
 import fs from "fs";
 import dotenv from "dotenv";
 import appConfig from "./app.js";
@@ -17,16 +18,21 @@ if (process.env.HIVE_SRC) {
   });
 }
 
-if (process.env.HIVE_SRC) {
-  let pluginConfigPath = `${process.env.HIVE_SRC}/app-config/app.js`;
-  // pluginConfig = (await import(pluginConfigPath)).default;
-  if (fs.existsSync(pluginConfigPath)) {
-    appConfig = { ...appConfig };
-  }
-}
-
 const env = process.env.APP_ENV || "development";
-const config = {
+
+let config = {
+  async init() {
+    if (process.env.HIVE_SRC) {
+      let pluginConfigPath = `${process.env.HIVE_SRC}/app-config/app.js`;
+
+      if (fs.existsSync(pluginConfigPath)) {
+        const { default: pluginConfig } = await (import(pluginConfigPath))
+        _.extend(config, pluginConfig);
+      }
+    }
+  },
+
+  _hive: {},
   env,
   port: process.env.PORT || 3001,
   domain:
@@ -52,4 +58,5 @@ const config = {
     }
   },
 };
+
 export default config;

package/starter/src/app.js

@@ -23,34 +23,35 @@ import get from "resources/health/endpoints/get";
 import scheduler from "./scheduler";
 
 const main = async () => {
+  await config.init();
   await db.init();
 
   process.on("unhandledRejection", (reason, p) => {
     console.trace(reason.stack);
     logger.error(reason.stack);
   });
-  
+
   const app = new Koa();
-  
+
   app.use(cors({ credentials: true }));
   app.use(helmet());
-  
+
   qs(app);
-  
+
   app.use(bodyParser({ enableTypes: ["json", "form", "text"] }));
   app.use(mount("/health", get.handler));
   app.use(requestLogger());
-  
+
   routes(app);
-  
+
   const server = http.createServer(app.callback());
-  
+
   server.listen(config.port, () => {
-        console.log(`Api server listening on ${config.port}, in ${process.env.NODE_ENV} mode and ${process.env.APP_ENV} environment`);
+    console.log(`Api server listening on ${config.port}, in ${process.env.NODE_ENV} mode and ${process.env.APP_ENV} environment`);
   });
- 
+
   scheduler();
-  
+
   await socketIo(server);
 };
 

package/starter/src/helpers/getMiddlewares.js

@@ -0,0 +1,38 @@
+import _ from 'lodash';
+import path from 'path';
+import fs from 'fs';
+
+const {
+  promises: { readdir },
+} = fs;
+
+
+const getFiles = async (source) => {
+  return (await readdir(source, { withFileTypes: true }))
+    .filter((file) => !file.isDirectory())
+    .map((file) => ({ fileName: file.name }));
+};
+
+export default async () => {
+  let middlewaresDirs = await getFiles(`${__dirname}/../middlewares`);
+
+  if (process.env.HIVE_SRC) {
+    let hiveMiddlewaresDirPath = `${process.env.HIVE_SRC}/middlewares`;
+
+    if (fs.existsSync(hiveMiddlewaresDirPath)) {
+      middlewaresDirs = _.uniqBy([...middlewaresDirs, ...((await getFiles(hiveMiddlewaresDirPath)).map(r => ({ fileName: r.fileName, isHive: true })))], r => r.fileName);
+    }
+  }
+
+  return Promise.all(middlewaresDirs
+    .map(({ fileName, isHive }) => ({
+      filePath: isHive ? path.resolve(`${process.env.HIVE_SRC}/middlewares/${fileName}`) : path.resolve(`${__dirname}/../middlewares/${fileName}`),
+      name: fileName.replace('.js', ''),
+    })).map(async ({ filePath, name }) => {
+      return {
+        name,
+        filePath,
+        fn: (await import(filePath)).default,
+      }
+    }));
+};

package/starter/src/helpers/schema/db.schema.js

@@ -4,7 +4,7 @@ export default z
   .object({
     _id: z.string(),
 
-    createdOn: z.coerce.date(),
-    updatedOn: z.coerce.date(),
+    createdOn: z.coerce.date().default(() => new Date()),
+    updatedOn: z.coerce.date().default(() => new Date()),
   })
   .strict();

package/starter/src/routes/index.js

@@ -1,13 +1,16 @@
 import _ from "lodash";
 import getResources from "helpers/getResources";
+import getMiddlewares from "helpers/getMiddlewares";
 import getResourceEndpoints from "helpers/getResourceEndpoints";
 import mount from "koa-mount";
 import Router from "@koa/router";
 import validate from "middlewares/validate";
 import db from "db";
 import tryToAttachUser from "middlewares/global/tryToAttachUser";
-import attachCustomErrors from "./middlewares/attachCustomErrors.js";
-import routeErrorHandler from "./middlewares/routeErrorHandler.js";
+import attachCustomErrors from "./middlewares/attachCustomErrors";
+import routeErrorHandler from "./middlewares/routeErrorHandler";
+import isAuthorized from "middlewares/isAuthorized";
+import config from 'app-config';
 
 const requestLogService = db.createService("_request_logs");
 
@@ -59,8 +62,10 @@ const defineRoutes = async (app) => {
   app.use(attachCustomErrors);
   app.use(routeErrorHandler);
   app.use(tryToAttachUser);
-  
-  const resources = await getResources();
+
+ 
+
+  const [resources, allMiddlewares] = await Promise.all([getResources(), getMiddlewares()]);
 
   _.each(resources, async ({ name: resourceName }) => {
     const resourceRouter = new Router();
@@ -68,7 +73,7 @@ const defineRoutes = async (app) => {
     const endpoints = await Promise.all((await getResourceEndpoints(resourceName))
       .map(async ({ file: endpointFile, name }) => {
         let endpointDef = (await import(endpointFile));
-        
+
         if (!endpointDef.endpoint) {
           console.log('missing endpoint for', name);
         }
@@ -92,15 +97,15 @@ const defineRoutes = async (app) => {
 
     endpoints.forEach(({ endpoint, requestSchema, middlewares = [], handler }) => {
       const additionalMiddlewares = [];
-      
+
       if (requestSchema) {
         additionalMiddlewares.push(validate(requestSchema));
       }
-      
+
       let targetRouter;
 
       let url = endpoint.absoluteUrl || endpoint.url;
-      
+
       if (url.startsWith("$HOST/")) {
         url = url.replace("$HOST", "");
         targetRouter = globalRouter;
@@ -110,6 +115,30 @@ const defineRoutes = async (app) => {
         targetRouter = resourceRouter;
       }
 
+      middlewares = middlewares.map(middleware => {
+        if (_.isString(middleware)) {
+          if (!allMiddlewares.find(m => m.name === middleware)) {
+            throw new Error(`Middleware ${middleware} not found`);
+          }
+
+          middleware = allMiddlewares.find(m => m.name === middleware).fn;
+        } else if (_.isArray(middleware)) {
+          const [middlewareName, ...middlewareParams] = middleware;
+          
+          if (!allMiddlewares.find(m => m.name === middlewareName)) {
+            throw new Error(`Middleware ${middlewareName} not found`);
+          }
+
+          middleware = allMiddlewares.find(m => m.name === middlewareName).fn(...middlewareParams);
+        }
+
+        return middleware;
+      });
+
+      if (config._hive.isRequireAuthAllEndpoints && !endpoint.isNoAuthRequired) {
+        app.use(isAuthorized);
+      }
+
       targetRouter[endpoint.method?.toLowerCase() || "get"](
         url,
         async (ctx, next) => {