@adaptivestone/framework 5.0.0-beta.4 → 5.0.0-beta.40

package/modules/AbstractController.js

@@ -1,413 +0,0 @@
-/* eslint-disable no-restricted-syntax */
-/* eslint-disable guard-for-in */
-import express from 'express';
-
-import Base from './Base.js';
-import GetUserByToken from '../services/http/middleware/GetUserByToken.js';
-import Auth from '../services/http/middleware/Auth.js';
-import ValidateService from '../services/validate/ValidateService.js';
-import DocumentationGenerator from '../services/documentation/DocumentationGenerator.js';
-/**
- * Abstract controller. You should extend any controller from them.
- * Place you cintroller into controller folder and it be inited in auto way.
- * By default name of route will be controller name not file name. But please name it in same ways.
- * You can overwrite base controllers byt creating controllers with tha same file name (yes file name, not class name)
- * In most cases you will want to have a 'home' route that not include controller name. For this case please check '  getHttpPath'
- */
-class AbstractController extends Base {
-  constructor(app, prefix, isExpressMergeParams = false) {
-    const time = Date.now();
-    super(app);
-    this.prefix = prefix;
-    this.router = express.Router({
-      mergeParams: isExpressMergeParams,
-    });
-    const { routes } = this;
-    let httpPath = this.getHttpPath();
-
-    // @ts-ignore
-    if (this.getExpressPath) {
-      this.logger.warn(
-        `getExpressPath deprecated. Please use getHttpPath instead. Will be removed on v5`,
-      );
-      // @ts-ignore
-      httpPath = this.getExpressPath();
-    }
-
-    /**
-     * Grab route middleware onlo one Map
-     */
-    const routeMiddlewares = new Map();
-    Object.entries(routes).forEach(([method, methodRoutes]) => {
-      Object.entries(methodRoutes).forEach(([route, routeParam]) => {
-        if (routeParam?.middleware) {
-          const fullRoute = method.toUpperCase() + route;
-
-          if (!routeMiddlewares.has(fullRoute)) {
-            routeMiddlewares.set(fullRoute, []);
-          }
-
-          routeMiddlewares.set(fullRoute, [
-            ...routeMiddlewares.get(fullRoute),
-            ...routeParam.middleware,
-          ]);
-        }
-      });
-    });
-
-    const routeMiddlewaresReg = this.parseMiddlewares(
-      routeMiddlewares,
-      httpPath,
-    );
-    const middlewaresInfo = this.parseMiddlewares(
-      // @ts-ignore
-      this.constructor.middleware,
-      httpPath,
-    );
-
-    const routesInfo = [];
-
-    /**
-     *  Register controller middleware
-     */
-    for (const middleware of middlewaresInfo) {
-      this.router[middleware.method](
-        middleware.path,
-        new middleware.MiddlewareFunction(
-          this.app,
-          middleware.params,
-        ).getMiddleware(),
-      );
-    }
-
-    /**
-     *  Register routes itself
-     */
-    for (const verb in routes) {
-      if (typeof this.router[verb] !== 'function') {
-        this.logger.error(
-          `Method ${verb} not exist for router. Please check your codebase`,
-        );
-        // eslint-disable-next-line no-continue
-        continue;
-      }
-      for (const path in routes[verb]) {
-        const routeAdditionalMiddlewares = routeMiddlewaresReg.filter(
-          (middleware) =>
-            middleware.path === path && middleware.method === verb,
-        );
-
-        let routeObject = routes[verb][path];
-        if (Object.prototype.toString.call(routeObject) !== '[object Object]') {
-          routeObject = {
-            handler: routeObject,
-            request: null,
-            query: null,
-            middleware: null,
-          };
-
-          if (typeof routeObject.handler !== 'function') {
-            this.logger.error(
-              `Can't resolve function '${
-                routeObject.handler
-              }' for controller '${this.getConstructorName()}'`,
-            );
-            // eslint-disable-next-line no-continue
-            continue;
-          }
-        }
-
-        let fnName = routeObject.handler;
-        if (typeof fnName === 'function') {
-          fnName = fnName.name;
-        }
-
-        const fullPath = `/${httpPath}/${path}`
-          .split('//')
-          .join('/')
-          .split('//')
-          .join('/');
-
-        routesInfo.push({
-          name: fnName,
-          description: routeObject?.description,
-          method: verb.toUpperCase(),
-          fields: routeObject?.request?.fields,
-          queryFields: routeObject?.query?.fields,
-          path,
-          fullPath,
-        });
-        // this.logger.verbose(
-        //   `Controller '${this.getConstructorName()}' register function '${fnName}'  for method '${verb}' and path '${path}' Full path '${fullPath}'`,
-        // );
-
-        let additionalMiddlewares;
-
-        if (routeAdditionalMiddlewares.length > 0) {
-          additionalMiddlewares = Array.from(
-            routeAdditionalMiddlewares,
-            ({ MiddlewareFunction, params }) =>
-              new MiddlewareFunction(this.app, params).getMiddleware(),
-          );
-        }
-
-        this.router[verb](
-          path,
-          additionalMiddlewares || [],
-          async (req, res, next) => {
-            const requestObj = {
-              query: req.query,
-              body: req.body,
-              appInfo: req.appInfo,
-            };
-            try {
-              req.appInfo.request = await new ValidateService(
-                this.app,
-                routeObject?.request,
-              ).validateReqData(requestObj, {
-                selectedReqData: req.body,
-                additionalMiddlewareFieldsData: {
-                  middlewaresInfo,
-                  routeMiddlewaresReg,
-                  options: {
-                    method: verb,
-                    path: fullPath,
-                    prefix: 'request',
-                  },
-                },
-              });
-              req.appInfo.query = await new ValidateService(
-                this.app,
-                routeObject?.query,
-              ).validateReqData(requestObj, {
-                selectedReqData: req.query,
-                additionalMiddlewareFieldsData: {
-                  middlewaresInfo,
-                  routeMiddlewaresReg,
-                  options: {
-                    method: verb,
-                    path: fullPath,
-                    prefix: 'query',
-                  },
-                },
-              });
-            } catch (err) {
-              return res.status(400).json({
-                errors: err.message,
-              });
-            }
-            // req.body = new Proxy(req.body, {
-            //   get: (target, prop) => {
-            //     this.logger.warn(
-            //       'Please not use "req.body" directly. Implement "request" and use "req.appInfo.request" ',
-            //     );
-            //     return target[prop];
-            //   },
-            // });
-            // req.query = new Proxy(req.query, {
-            //   get: (target, prop) => {
-            //     this.logger.warn(
-            //       'Please not use "req.query" directly. Implement "query" and use "req.appInfo.query" ',
-            //     );
-            //     return target[prop];
-            //   },
-            // });
-
-            if (!routeObject.handler) {
-              this.logger.error(`Route object have no handler defined`);
-              return res.status(500).json({
-                message:
-                  'Platform error 2. Please check later or contact support',
-              });
-            }
-
-            if (routeObject.handler.constructor.name !== 'AsyncFunction') {
-              const error =
-                "Handler should be AsyncFunction. Perhabs you miss 'async' of function declaration?";
-              this.logger.error(error);
-              return res.status(500).json({
-                message:
-                  'Platform error. Please check later or contact support',
-              });
-            }
-            return routeObject.handler.call(this, req, res, next).catch((e) => {
-              this.logger.error(e);
-              return res.status(500).json({
-                message:
-                  'Platform error. Please check later or contact support',
-              });
-            });
-          },
-        );
-      }
-    }
-
-    /**
-     * Generate text info
-     */
-    const text = ['', `Controller '${this.getConstructorName()}' registered.`];
-
-    const reports = {
-      'Middlewares:': middlewaresInfo,
-      'Route middlewares:': routeMiddlewaresReg,
-      'Callbacks:': routesInfo,
-    };
-    for (const key in reports) {
-      text.push(`${key}`);
-      for (const item of reports[key]) {
-        text.push(
-          `Path:'${item.path}'. Full path: '${
-            item.fullPath
-          }'. Method: '${item.method.toUpperCase()}'. Function: '${item.name}'`,
-        );
-      }
-    }
-
-    text.push(`Time: ${Date.now() - time} ms`);
-
-    this.logger.verbose(text.join('\n'));
-    this.loadedTime = Date.now() - time;
-
-    /**
-     * Generate documentation
-     */
-    if (!this.app.httpServer) {
-      this.app.documentation.push(
-        new DocumentationGenerator(this.app).convertDataToDocumentationElement(
-          this.getConstructorName(),
-          routesInfo,
-          middlewaresInfo,
-          routeMiddlewaresReg,
-        ),
-      );
-    } else {
-      this.app.httpServer.express.use(httpPath, this.router);
-    }
-  }
-
-  /**
-   * Parse middlewares to be an object.
-   */
-  parseMiddlewares(middlewareMap, httpPath) {
-    const middlewaresInfo = [];
-    // eslint-disable-next-line prefer-const
-    for (let [path, middleware] of middlewareMap) {
-      if (!Array.isArray(middleware)) {
-        middleware = [middleware];
-      }
-      for (const M of middleware) {
-        let method = 'all';
-        let realPath = path;
-        if (typeof realPath !== 'string') {
-          this.logger.error(`Path not a string ${realPath}. Please check it`);
-          // eslint-disable-next-line no-continue
-          continue;
-        }
-        if (!realPath.startsWith('/')) {
-          method = realPath.split('/')[0]?.toLowerCase();
-          if (!method) {
-            this.logger.error(`Method not found for ${realPath}`);
-            // eslint-disable-next-line no-continue
-            continue;
-          }
-          realPath = realPath.substring(method.length);
-        }
-        if (typeof this.router[method] !== 'function') {
-          this.logger.error(
-            `Method ${method} not exist for middleware. Please check your codebase`,
-          );
-          // eslint-disable-next-line no-continue
-          continue;
-        }
-        const fullPath = `/${httpPath}/${realPath.toUpperCase()}`
-          .split('//')
-          .join('/')
-          .split('//')
-          .join('/');
-        let MiddlewareFunction = M;
-        let middlewareParams = {};
-        if (Array.isArray(M)) {
-          [MiddlewareFunction, middlewareParams] = M;
-        }
-
-        middlewaresInfo.push({
-          name: MiddlewareFunction.name,
-          method,
-          path: realPath,
-          fullPath,
-          params: middlewareParams,
-          relatedQueryParameters: new MiddlewareFunction(
-            this.app,
-            middlewareParams,
-          )?.relatedQueryParameters,
-          authParams: new MiddlewareFunction(this.app, middlewareParams)
-            ?.usedAuthParameters,
-          MiddlewareFunction,
-        });
-      }
-    }
-    return middlewaresInfo;
-  }
-
-  /**
-   * Object with routes. Routes relative to controller
-   * @example
-   * return {
-   *   post: {
-   *     "/someUrl": {
-   *       handler: this.postSomeUrl,
-   *       request: yup.object().shape({
-   *         count: yup.number().max(100)required(),
-   *       })
-   *     }
-   *   },
-   * };
-   */
-  get routes() {
-    this.logger.warn('Please implement "routes" method on controller.');
-    return {};
-  }
-
-  /**
-   * Array of middlewares to append for route
-   * You should provide path relative to controller and then array of middlewares to apply.
-   * Order is matter.
-   * Be default path apply to ANY' method, but you can preattach 'METHOD' into patch to scope patch to this METHOD
-   * @returns {Map<string, Array<typeof import('../services/http/middleware/AbstractMiddleware.js').default | [Function, ...any]>>}
-   * @example
-   * return new Map([
-   *    ['/{*splat}', [GetUserByToken]] // for any method for this controller
-   *    ['POST/', [Auth]] // for POST method
-   *    ['/superSecretMethod', [OnlySuperSecretUsers]] // route with ANY method
-   *    ['PUT/superSecretMathod', [OnlySuperSecretAdmin]] // route with PUT method
-   * ]);
-   */
-  static get middleware() {
-    return new Map([['/{*splat}', [GetUserByToken, Auth]]]);
-  }
-
-  /**
-   * Get constructor name that can include preix
-   */
-  getConstructorName() {
-    if (this.prefix) {
-      return `${this.prefix.charAt(0).toUpperCase()}${this.prefix.slice(1)}/${
-        this.constructor.name
-      }`;
-    }
-    return this.constructor.name;
-  }
-
-  /**
-   * Get http path with inheritance of path
-   */
-  getHttpPath() {
-    return `/${this.getConstructorName().toLowerCase()}`.replace('//', '/');
-  }
-
-  static get loggerGroup() {
-    return 'controller';
-  }
-}
-
-export default AbstractController;

package/modules/AbstractModel.d.ts

@@ -1,48 +0,0 @@
-import type Base from './Base.js';
-import { Model, Schema } from 'mongoose';
-import type Server from '../server.js';
-
-interface AbstractModel<T extends Document> extends Model, Base {
-  constructor(app: Server['app'], callback?: () => void);
-
-  /**
-   *  Return itself for internal methods.
-   */
-  getSuper(): this;
-
-  /**
-   *  Model schema in Js object (not a mongoose schema).
-   */
-  get modelSchema(): Object;
-
-  /**
-   * Mongoose schema.
-   */
-  mongooseSchema: Schema<T>;
-
-  /**
-   * Acces to mongoose model too
-   */
-  mongooseModel: Model<T>;
-
-  /**
-   * Init custom hooks before model
-   */
-  initHooks(): void;
-}
-
-abstract class AbstractModel<T extends Document>
-  extends Model
-  implements AbstractModel
-{
-  abstract get modelSchema(): Object;
-
-  /**
-   * Return itself for internal methods.
-   */
-  static abstract getSuper(): this;
-
-  mongooseSchema: Schema<T> = new Schema<T>(this.modelSchema);
-}
-
-export default AbstractModel;

package/modules/AbstractModel.js

@@ -1,92 +0,0 @@
-import mongoose from 'mongoose';
-import Base from './Base.js';
-
-class AbstractModel extends Base {
-  mongooseSchema = null;
-
-  mongooseModel = null;
-
-  /**
-   * @param {import('../server.js').default['app']} app  //TODO change to *.d.ts as this is a Server, not app
-   * @param function callback optional callback when connection ready
-   */
-  constructor(app, callback = () => {}) {
-    super(app);
-    this.mongooseSchema = new mongoose.Schema(
-      this.modelSchema,
-      this.modelSchemaOptions,
-    );
-    mongoose.set('strictQuery', true);
-    this.mongooseSchema.set('timestamps', true);
-    this.mongooseSchema.set('minimize', false);
-    this.mongooseSchema.loadClass(this.constructor);
-    this.mongooseSchema.statics.getSuper = () => this;
-    this.mongooseSchema.methods.getSuper = () => this;
-    this.initHooks();
-    this.mongooseModel = mongoose.model(
-      this.constructor.name,
-      this.mongooseSchema,
-    );
-    if (!mongoose.connection.readyState) {
-      this.app.events.on('shutdown', async () => {
-        this.logger.verbose(
-          'Shutdown was called. Closing all mongoose connections',
-        );
-        for (const c of mongoose.connections) {
-          c.close(true);
-        }
-        // await mongoose.disconnect(); // TODO it have problems with replica-set
-      });
-      const connectionParams = {};
-      if (process.env.MONGO_APP_NAME) {
-        connectionParams.appName = process.env.MONGO_APP_NAME;
-      }
-      // do not connect on test
-      mongoose
-        .connect(this.app.getConfig('mongo').connectionString, connectionParams)
-        .then(
-          () => {
-            this.logger.info(
-              `Mongo connection success ${connectionParams.appName}`,
-            );
-            mongoose.connection.on('error', (err) => {
-              this.logger.error('Mongo connection error', err);
-              console.error(err);
-            });
-
-            callback();
-          },
-          (error) => {
-            this.logger.error("Can't install mongodb connection", error);
-          },
-        );
-    } else {
-      callback();
-    }
-  }
-
-  /**
-   * Mongoose schema
-   */
-  get modelSchema() {
-    this.logger.warn('You should provide modelSchema');
-    return {};
-  }
-
-  /**
-   * Mongoose schema options
-   */
-  // eslint-disable-next-line class-methods-use-this
-  get modelSchemaOptions() {
-    return {};
-  }
-
-  static get loggerGroup() {
-    return 'model';
-  }
-
-  initHooks() {
-    this.logger.verbose('Model have no hooks');
-  }
-}
-export default AbstractModel;

package/modules/Base.d.ts

@@ -1,37 +0,0 @@
-import type winston from 'winston';
-import type Server from '../server.js';
-import type { Dirent } from 'node.fs';
-
-declare class Base {
-  app: Server['app'];
-  #realLogger: null;
-
-  constructor(app: Server['app']);
-
-  /**
-   * In case of logging sometimes we might need to replace name
-   */
-  getConstructorName(): string;
-
-  /**
-   * Optimzation to lazy load logger. It will be inited only on request
-   */
-  get logger(): winston.Logger;
-
-  /**
-   * Get winston loger for given label
-   * @param label name of logger
-   */
-  getLogger(label: string): winston.Logger;
-
-  getFilesPathWithInheritance(
-    internalFolder: string,
-    externalFolder: string,
-  ): Promise<{ path: string; file: string }[]>;
-
-  /**
-   * Return logger group. Just to have all logs groupped logically
-   */
-  static get loggerGroup(): string;
-}
-export default Base;

package/modules/Base.js

@@ -1,63 +0,0 @@
-import { getFilesPathWithInheritance } from '../helpers/files.js';
-
-class Base {
-  #realLogger = null;
-
-  constructor(app) {
-    this.app = app;
-  }
-
-  /**
-   * In case of logging sometimes we might need to replace name
-   */
-  getConstructorName() {
-    return this.constructor.name;
-  }
-
-  /**
-   * Optimzation to lazy load logger. It will be inited only on request
-   */
-  get logger() {
-    let l;
-    try {
-      l = this.#realLogger;
-    } catch (e) {
-      console.warn(
-        `You try to accees logger not from class. that can be ok in case of models.`,
-      );
-      return null;
-    }
-
-    if (!l) {
-      this.#realLogger = this.getLogger(
-        this.constructor.loggerGroup + this.getConstructorName(),
-      );
-    }
-    return this.#realLogger;
-  }
-
-  /**
-   * Get winston loger for given label
-   * @param {string} label name of logger
-   */
-  getLogger(label) {
-    return this.app.logger.child({ label });
-  }
-
-  async getFilesPathWithInheritance(internalFolder, externalFolder) {
-    return getFilesPathWithInheritance({
-      internalFolder,
-      externalFolder,
-      logger: (text) => this.logger.verbose(text),
-    });
-  }
-
-  /**
-   * Return logger group. Just to have all logs groupped logically
-   */
-  static get loggerGroup() {
-    return 'Base_please_overwrite_';
-  }
-}
-
-export default Base;