@paralect/hive 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paralect/hive",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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";
@@ -8,21 +9,32 @@ dotenv.config({ path: `${__dirname}/.env.app` });
 console.log('process.env.HIVE_SRC', process.env.HIVE_SRC)
 
 if (process.env.HIVE_SRC) {
+  dotenv.config({
+    path: `${process.env.HIVE_SRC}/app-config/.env`,
+  });
+
   dotenv.config({
     path: `${process.env.HIVE_SRC}/app-config/.env.app`,
   });
 }
 
-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";
+
+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))
+console.log('plugin config', pluginConfig);
+_.extend(config, pluginConfig);
+
+    }
   }
-}
 
-const env = process.env.APP_ENV || "development";
-const config = {
+}, 
+ _hive: {},
   env,
   port: process.env.PORT || 3001,
   domain:
@@ -47,5 +59,4 @@ const config = {
       throw Error(`Config [${configKey}] is missing`);
     }
   },
-};
-export default config;
+};

package/starter/src/app.js

@@ -8,7 +8,7 @@ if (process.env.HIVE_SRC) {
 
 import Koa from "koa";
 import http from "http";
-import config from "app-config";
+import config, { init as initConfig } from "app-config";
 import logger from "logger";
 import cors from "@koa/cors";
 import helmet from "koa-helmet";
@@ -23,34 +23,35 @@ import get from "resources/health/endpoints/get";
 import scheduler from "./scheduler";
 
 const main = async () => {
+  await initConfig();
   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/db.js

@@ -29,7 +29,7 @@ db.init = async () => {
       db.schemas[schemaName] = schema;
       db.services[schemaName] = db.createService(`${resourceName}`, {
         validate: (obj) => { 
-          return schema.passthrough().parseAsync(obj)
+          return { value: schema.passthrough().parse(obj) };
         },
       });
 

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) => {

package/starter/src/scheduler.js

@@ -1,21 +1,32 @@
+import path from 'path';
+import fs from 'fs';
 import moment from 'moment';
 import schedule from 'node-schedule';
 import requireDir from 'require-dir';
 
 export default () => {
-  requireDir(`${process.env.HIVE_SRC || "."}/scheduler/handlers`, {
-    mapValue: (handler, handlerName) => {
-      console.log(
-        `[scheduler] Registering handler ${handlerName} with cron ${handler.cron}`
-      );
+  const paths = [path.resolve(__dirname, './scheduler/handlers')];
+  if (process.env.HIVE_SRC) {
+    paths.push(path.resolve(process.env.HIVE_SRC, './scheduler/handlers'))
+  }
 
-      schedule.scheduleJob(handler.cron, () => {
-        console.log(
-          `[scheduler] ${moment().format()} executing ${handlerName} with cron ${handler.cron
-          }`
-        );
-        handler.handler();
+  paths.forEach((pathName) => {
+    if (fs.existsSync(pathName)) {
+      requireDir(pathName, {
+        mapValue: (handler, handlerName) => {
+          console.log(
+            `[scheduler] Registering handler ${handlerName} with cron ${handler.cron}`
+          );
+
+          schedule.scheduleJob(handler.cron, () => {
+            console.log(
+              `[scheduler] ${moment().format()} executing ${handlerName} with cron ${handler.cron
+              }`
+            );
+            handler.handler();
+          });
+        },
       });
-    },
+    }
   });
 }