@adaptivestone/framework 3.0.18 → 3.0.19

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+### 3.1.0 // NEXT
+
+[NEW] new comand to generate open API documentation (wip)
+
+### 3.0.19
+
+[UPDATE] update deps
+
 ### 3.0.18
 
 [UPDATE] update deps

package/commands/GetOpenApiJson.js

@@ -0,0 +1,223 @@
+const AbstractCommand = require('../modules/AbstractCommand');
+
+class GetOpenApiJson extends AbstractCommand {
+  async run() {
+    const { myDomain } = this.app.getConfig('http');
+    const openApi = {
+      openapi: '3.0.0',
+      info: {
+        title: 'Some title',
+        description: 'This is a simple API',
+        contact: {
+          email: 'you@your-company.com',
+        },
+        version: '1.0.0',
+      },
+      servers: [
+        {
+          url: 'http://localhost:3300',
+          description: 'Localhost',
+        },
+        {
+          url: myDomain,
+          description: 'Domain from config',
+        }
+      ],
+    };
+
+    const baseDocumentation = await this.app.runCliCommand('documentation');
+
+    if (!baseDocumentation) {
+      throw new Error('Problems with basic documenation generation');
+    }
+
+    openApi.components = {};
+    openApi.components.securitySchemes = {};
+
+    openApi.tags = [];
+
+    for (const controller of baseDocumentation) {
+      const controllerName = controller.contollerName.split('/')[0];
+      if (!openApi.tags.find((tag) => tag.name === controllerName)) {
+        openApi.tags.push({
+          name: controllerName,
+          description: '',
+        });
+      }
+    }
+
+    openApi.paths = {};
+
+    for (const controller of baseDocumentation) {
+      for (const route of controller.routesInfo) {
+        const routeInfo = route[Object.keys(route)?.[0]];
+        const middlewares = [
+          ...routeInfo.controllerMiddlewares,
+          ...routeInfo.routeMiddlewares,
+        ];
+
+        const securitySchemaNames = [];
+
+        if (middlewares?.length) {
+          for (const middleware of middlewares) {
+            if (middleware?.authParams?.length) {
+              for (const authParam of middleware.authParams) {
+                if (!openApi.components.securitySchemes[authParam.name]) {
+                  openApi.components.securitySchemes[authParam.name] =
+                    authParam;
+                }
+
+                securitySchemaNames.push({
+                  [authParam.name]: [],
+                });
+              }
+            }
+          }
+        }
+
+        let routeName = Object.keys(route)[0];
+
+        if (routeName === '/') {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+
+        if (routeName.slice(-1) === '/') {
+          routeName = routeName.substring(0, routeName.length - 1);
+        }
+
+        const partsRoute = routeName.split('/');
+
+        const newRoute = [];
+        const routeParameters = [];
+        for (const routeDetail of partsRoute) {
+          let routeCopy = routeDetail;
+
+          if (routeDetail.startsWith(':')) {
+            const routeChange = routeCopy.split('');
+            routeChange[0] = '{';
+            routeChange.push('}');
+            routeCopy = routeChange.join('');
+            routeParameters.push(routeCopy.replace(/^.|.$/g, ''));
+          }
+
+          newRoute.push(routeCopy);
+        }
+
+        routeName = newRoute.join('/');
+
+        if (!openApi.paths[routeName]) {
+          openApi.paths[routeName] = {};
+        }
+
+        const methodName = route[Object.keys(route)[0]].method.toLowerCase();
+        const routeTitle = route[Object.keys(route)[0]].name;
+        const routeDescription =
+          route[Object.keys(route)[0]]?.description || 'empty description';
+        const routeFields = route[Object.keys(route)[0]].fields;
+
+        if (!openApi.paths[routeName][methodName]) {
+          openApi.paths[routeName][methodName] = {};
+        }
+
+        openApi.paths[routeName][methodName].tags = [];
+
+        openApi.paths[routeName][methodName].tags.push(
+          controller.contollerName.split('/')[0],
+        );
+
+        openApi.paths[routeName][methodName].summary = routeTitle;
+        openApi.paths[routeName][methodName].description = routeDescription;
+        openApi.paths[routeName][methodName].parameters = [];
+        openApi.paths[routeName][methodName].security = securitySchemaNames;
+
+        openApi.paths[routeName][methodName].responses = {
+          200: {
+            description: 'Successfully',
+          },
+          201: {
+            description: 'The resource was created successfully',
+          },
+          400: {
+            description: 'There is a syntax error in the request',
+          },
+          401: {
+            description:
+              'Authentication is required to access the requested resource',
+          },
+          404: {
+            description:
+              'The server accepted the request, but did not find the corresponding resource at the specified URI',
+          },
+        };
+
+        for (const routeField of routeParameters) {
+          openApi.paths[routeName][methodName].parameters.push({
+            name: routeField,
+            in: 'path',
+            required: true,
+            schema: {
+              type: 'string',
+            },
+          });
+        }
+
+        if (routeFields.length) {
+          const groupBodyFields = {};
+          const requiredFields = [];
+          for (const field of routeFields) {
+            if (field.isRequired) {
+              requiredFields.push(field.name);
+            }
+
+            if (field.type === 'object') {
+              groupBodyFields[field.name] = {};
+              const objectFields = {};
+              for (const objField of field.fields) {
+                objectFields[objField.name] = {
+                  // fields file has mixed type but openApi doesnt have this type
+                  type: objField.type === 'mixed' ? 'string' : objField.type,
+                };
+              }
+
+              groupBodyFields[field.name].properties = objectFields;
+            } else {
+              groupBodyFields[field.name] = {
+                type: field.type,
+              };
+
+              if (field.type === 'array') {
+                groupBodyFields[field.name].items = {
+                  type: field.innerType,
+                };
+              }
+            }
+          }
+
+          openApi.paths[routeName][methodName].requestBody = {
+            content: {
+              'application/json': {
+                schema: {
+                  type: 'object',
+                  properties: groupBodyFields,
+                },
+              },
+            },
+          };
+
+          if (requiredFields.length) {
+            openApi.paths[routeName][methodName].requestBody.content[
+              'application/json'
+            ].schema.required = requiredFields;
+          }
+        }
+      }
+    }
+
+    const result = JSON.stringify(openApi);
+    console.log(result);
+    return result;
+  }
+}
+
+module.exports = GetOpenApiJson;

package/modules/AbstractController.js

@@ -91,12 +91,14 @@ class AbstractController extends Base {
           if (Array.isArray(M)) {
             [MiddlewareFunction, middlewareParams] = M;
           }
+
           middlewaresInfo.push({
             name: MiddlewareFunction.name,
             method,
             path: realPath,
             fullPath,
             params: middlewareParams,
+            authParams: MiddlewareFunction?.usedAuthParameters,
             MiddlewareFunction,
           });
         }
@@ -105,10 +107,11 @@ class AbstractController extends Base {
     };
 
     const routeMiddlewaresReg = parseMiddlewares(routeMiddlewares);
-    const middlewaresInfo = parseMiddlewares(this.constructor.middleware);
 
+    const middlewaresInfo = parseMiddlewares(this.constructor.middleware);
     const routesInfo = [];
     let routeObjectClone = {};
+    const routeObjests = [];
 
     /**
      *  Register controller middleware
@@ -140,7 +143,6 @@ class AbstractController extends Base {
             middleware.path === path && middleware.method === verb,
         );
         let routeObject = routes[verb][path];
-        routeObjectClone = merge({}, routeObject);
         if (Object.prototype.toString.call(routeObject) !== '[object Object]') {
           routeObject = {
             handler: routeObject,
@@ -174,6 +176,7 @@ class AbstractController extends Base {
           name: fnName,
           description: routeObject?.description,
           method: verb.toUpperCase(),
+          fields: routeObject?.request?.fields,
           path,
           fullPath,
         });
@@ -269,6 +272,8 @@ class AbstractController extends Base {
             });
           },
         );
+
+        routeObjectClone = merge({}, routeObject);
       }
     }
 
@@ -300,35 +305,42 @@ class AbstractController extends Base {
     /**
      * Generate documentation
      */
-    if (!this.app.httpServer) {
+
+    const processingFields = (fieldsByRoute) => {
       const fields = [];
-      if (routeObjectClone.request) {
-        const reqFields = routeObjectClone.request.fields;
-        const entries = Object.entries(reqFields);
-        entries.forEach(([key, value]) => {
-          const field = {};
-          field.name = key;
-          field.type = value.type;
-          if (value.exclusiveTests) {
-            field.isRequired = value.exclusiveTests.required;
-          }
+      if (!fieldsByRoute) {
+        return fields;
+      }
+      const entries = Object.entries(fieldsByRoute);
+      entries.forEach(([key, value]) => {
+        const field = {};
+        field.name = key;
+        field.type = value.type;
+        if (value.exclusiveTests) {
+          field.isRequired = value.exclusiveTests.required;
+        }
+        if (value?.innerType) {
+          field.innerType = value?.innerType?.type;
+        }
 
-          if (value.fields) {
-            field.fields = [];
-            // eslint-disable-next-line no-shadow
-            const entries = Object.entries(value.fields);
-            // eslint-disable-next-line no-shadow
-            entries.forEach(([key, value]) => {
-              field.fields.push({
-                name: key,
-                type: value.type,
-              });
+        if (value.fields) {
+          field.fields = [];
+          // eslint-disable-next-line no-shadow
+          const entries = Object.entries(value.fields);
+          // eslint-disable-next-line no-shadow
+          entries.forEach(([key, value]) => {
+            field.fields.push({
+              name: key,
+              type: value.type,
             });
-          }
-          fields.push(field);
-        });
-      }
+          });
+        }
+        fields.push(field);
+      });
+      return fields;
+    };
 
+    if (!this.app.httpServer) {
       this.app.documentation.push({
         contollerName: this.getConstructorName(),
         routesInfo: routesInfo.map((route) => ({
@@ -336,17 +348,20 @@ class AbstractController extends Base {
             method: route.method,
             name: route.name,
             description: route?.description,
-            fields,
+            fields: processingFields(route.fields),
             routeMiddlewares: routeMiddlewaresReg
               // eslint-disable-next-line consistent-return
               .map((middleware) => {
                 if (
                   route.fullPath.toUpperCase() ===
-                  middleware.fullPath.toUpperCase()
+                    middleware.fullPath.toUpperCase() ||
+                  middleware.fullPath.toUpperCase() ===
+                    `${route.fullPath.toUpperCase()}*`
                 ) {
                   return {
                     name: middleware.name,
                     params: middleware.params,
+                    authParams: middleware.authParams,
                   };
                 }
               })
@@ -357,9 +372,15 @@ class AbstractController extends Base {
                   .filter(
                     (middleware) =>
                       middleware.fullPath.toUpperCase() ===
-                      route.fullPath.toUpperCase(),
+                        route.fullPath.toUpperCase() ||
+                      middleware.fullPath.toUpperCase() ===
+                        `${route.fullPath.toUpperCase()}*`,
                   )
-                  .map(({ name, params }) => ({ name, params })),
+                  .map(({ name, params, authParams }) => ({
+                    name,
+                    params,
+                    authParams,
+                  })),
               ),
             ],
           },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptivestone/framework",
-  "version": "3.0.18",
+  "version": "3.0.19",
   "description": "Adaptive stone node js framework",
   "main": "src/index.js",
   "engines": {
@@ -16,7 +16,8 @@
     "prod": "nodemon ./cluster.js",
     "test": "jest",
     "codestyle": "prettier --check '**/*.(js|jsx|ts|tsx|json|css|scss|md)'",
-    "prepare": "husky install"
+    "prepare": "husky install",
+    "cli": "node cliCommand"
   },
   "jest": {
     "setupFilesAfterEnv": [
@@ -56,9 +57,9 @@
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-import": "^2.23.4",
-    "eslint-plugin-jest": "^26.0.0",
+    "eslint-plugin-jest": "^27.0.0",
     "husky": "^8.0.0",
-    "jest": "^28.0.0",
+    "jest": "^29.0.0",
     "lint-staged": "^13.0.0",
     "mongodb-memory-server": "^8.0.2",
     "nodemon": "^2.0.12",

package/services/http/middleware/AbstractMiddleware.js

@@ -7,7 +7,11 @@ class AbstractMiddleware extends Base {
   }
 
   static get description() {
-    return ' Middleware description. Please provide own';
+    return 'Middleware description. Please provide own';
+  }
+
+  static get usedAuthParameters() {
+    return [];
   }
 
   async middleware(req, res, next) {

package/services/http/middleware/GetUserByToken.js

@@ -5,6 +5,17 @@ class GetUserByToken extends AbstractMiddleware {
     return 'Grab a token and try to parse the user from it. It user exist will add req.appInfo.user variable';
   }
 
+  static get usedAuthParameters() {
+    return [
+      {
+        name: 'Authorization',
+        type: 'apiKey',
+        in: 'header',
+        description: this?.description,
+      },
+    ];
+  }
+
   async middleware(req, res, next) {
     let { token } = req.body;
     this.logger.verbose(