@adaptivestone/framework 5.0.0-beta.11 → 5.0.0-beta.13

package/services/cache/Cache.d.ts

@@ -1,35 +0,0 @@
-import Base from '../../modules/Base.d.ts';
-import Server from '../../server.js';
-
-declare class Cache extends Base {
-  app: Server['app'];
-
-  constructor(app: Server['app']);
-
-  /**
-   * As framework support namespaces all key for cache go through this function
-   * Function return new key with added namespace
-   * @param key key to add namespace
-   */
-  getKeyWithNameSpace(key: string): string;
-
-  /**
-   * Get value from cache. Set and get if not eists
-   * @param key key to check
-   * @param onNotFound callback that will be executed if value not found on cahce
-   * @param storeTime how long we should store value on cache
-   */
-  getSetValue(
-    key: string,
-    onNotFound: () => Promise<any>,
-    storeTime: number,
-  ): Promise<any>;
-
-  /**
-   * Remove key from cache
-   * @param key key to remove
-   */
-  removeKey(key: string): Promise<number>;
-}
-
-export default Cache;

package/services/cache/Cache.js

@@ -1,124 +0,0 @@
-import Base from '../../modules/Base.js';
-
-class Cache extends Base {
-  constructor(app) {
-    super(app);
-    this.whenReady = this.#init();
-  }
-
-  async #init() {
-    // todo for now only redis. refactor for drives support in future
-    // at least memory and redis drivers should be presented
-    // memory drives should works on master process level
-    // we should support multiple cashe same time
-    const { createClient } = await import('@redis/client');
-    const conf = this.app.getConfig('redis');
-    this.redisClient = createClient({
-      url: conf.url,
-    });
-
-    this.redisNamespace = conf.namespace;
-
-    this.redisClient.on('error', (error, b, c) => {
-      this.logger.error(error, b, c);
-    });
-    this.redisClient.on('connect', () => {
-      this.logger.info('Redis connection success');
-    });
-    this.app.events.on('shutdown', () => {
-      this.redisClient.quit();
-    });
-
-    this.promiseMapping = new Map();
-  }
-
-  getKeyWithNameSpace(key) {
-    return `${this.redisNamespace}-${key}`;
-  }
-
-  async getSetValue(keyValue, onNotFound, storeTime = 60 * 5) {
-    await this.whenReady;
-    if (!this.redisClient.isOpen) {
-      await this.redisClient.connect();
-    }
-    const key = this.getKeyWithNameSpace(keyValue);
-    // 5 mins default
-    // eslint-disable-next-line no-unused-vars
-    let resolve = (value) => {};
-    // eslint-disable-next-line no-unused-vars
-    let reject = (value) => {};
-    if (this.promiseMapping.has(key)) {
-      return this.promiseMapping.get(key);
-    }
-
-    this.promiseMapping.set(
-      key,
-      new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-      }),
-    );
-
-    let result = await this.redisClient.get(key);
-    if (!result) {
-      this.logger.verbose(`getSetValueFromCache not found for key ${key}`);
-      try {
-        result = await onNotFound();
-      } catch (e) {
-        this.logger.error(`Cache onNotFound for key '${key}' error: ${e}`);
-        this.promiseMapping.delete(key);
-        reject(e);
-        return Promise.reject(e);
-      }
-
-      this.redisClient.set(
-        key,
-        JSON.stringify(result, (_jsonkey, value) =>
-          typeof value === 'bigint' ? `${value}n` : value,
-        ),
-        {
-          EX: storeTime,
-        },
-      );
-    } else {
-      this.logger.verbose(
-        `getSetValueFromCache FROM CACHE key ${key}, value ${result.substring(
-          0,
-          100,
-        )}`,
-      );
-      try {
-        result = JSON.parse(result, (_jsonkey, value) => {
-          if (typeof value === 'string' && /^\d+n$/.test(value)) {
-            return BigInt(value.slice(0, value.length - 1));
-          }
-          return value;
-        });
-      } catch {
-        this.logger.warn(
-          'Not able to parse json from redis cache. That can be a normal in case you store string here',
-        );
-      }
-    }
-
-    resolve(result);
-    this.promiseMapping.delete(key);
-    return result;
-  }
-
-  async removeKey(keyValue) {
-    await this.whenReady;
-
-    if (!this.redisClient.isOpen) {
-      await this.redisClient.connect();
-    }
-    const key = this.getKeyWithNameSpace(keyValue);
-    return this.redisClient.del(key);
-  }
-
-  static get loggerGroup() {
-    return 'Cache_';
-  }
-}
-
-export default Cache;

package/services/documentation/DocumentationGenerator.js

@@ -1,169 +0,0 @@
-import Base from '../../modules/Base.js';
-import ValidateService from '../validate/ValidateService.js';
-
-class DocumentationGenerator extends Base {
-  // eslint-disable-next-line class-methods-use-this
-  processingFields(fieldsByRoute) {
-    const fields = [];
-    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.required = 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,
-          });
-        });
-      }
-      fields.push(field);
-    });
-    return fields;
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  selectUniqueFields(fields) {
-    return Array.from(
-      new Map(fields.map((item) => [item.name, item])).values(),
-    ).reduce((uniqueArray, item) => {
-      const existingItem = uniqueArray.find(
-        (uniqueItem) => uniqueItem.name === item.name,
-      );
-      if (!existingItem) {
-        uniqueArray.push(item);
-      } else if (item.required) {
-        existingItem.required = true;
-      }
-      return uniqueArray;
-    }, []);
-  }
-
-  groupFieldsFromSchemas(schemas) {
-    const result = [];
-    schemas.forEach((schema) => {
-      const convertedSchema = new ValidateService(this.app, schema).validator;
-
-      for (const [key, value] of Object.entries(
-        convertedSchema?.fieldsInJsonFormat,
-      )) {
-        result.push({
-          name: key,
-          type: value.type,
-          required: value.required,
-        });
-      }
-    });
-
-    return result;
-  }
-
-  convertDataToDocumentationElement(
-    controllerName,
-    routesInfo,
-    middlewaresInfo,
-    routeMiddlewaresReg,
-  ) {
-    return {
-      contollerName: controllerName,
-      routesInfo: routesInfo.map((route) => {
-        const middlewareQueryParams = new ValidateService(
-          this.app,
-        ).getMiddlewareParams(middlewaresInfo, routeMiddlewaresReg, {
-          method: route.method.toLowerCase(),
-          path: route.fullPath,
-        }).query;
-
-        const middlewareRequestParams = new ValidateService(
-          this.app,
-        ).getMiddlewareParams(middlewaresInfo, routeMiddlewaresReg, {
-          method: route.method.toLowerCase(),
-          path: route.fullPath,
-        }).request;
-
-        const queryParams = this.groupFieldsFromSchemas(middlewareQueryParams);
-
-        const requestParams = this.groupFieldsFromSchemas(
-          middlewareRequestParams,
-        );
-
-        return {
-          [route.fullPath]: {
-            method: route.method,
-            name: route.name,
-            description: route?.description,
-            fields: this.selectUniqueFields([
-              ...this.processingFields(route.fields),
-              ...requestParams,
-            ]),
-            queryFields: this.selectUniqueFields([
-              ...this.processingFields(route.queryFields),
-              ...queryParams,
-            ]),
-            routeMiddlewares: routeMiddlewaresReg
-              .map((middleware) => {
-                const routeFullPath = route.fullPath.toUpperCase();
-                const middlewareFullPath = middleware.fullPath.toUpperCase();
-                if (
-                  route.method.toLowerCase() ===
-                    middleware.method.toLowerCase() &&
-                  (middlewareFullPath === routeFullPath ||
-                    middlewareFullPath === `${routeFullPath}*`)
-                ) {
-                  return {
-                    name: middleware.name,
-                    params: middleware.params,
-                    authParams: middleware.authParams,
-                  };
-                }
-                return null;
-              })
-              .filter(Boolean),
-            controllerMiddlewares: [
-              ...new Set(
-                middlewaresInfo
-                  .filter((middleware) => {
-                    const routeFullPath = route.fullPath.toUpperCase();
-                    const middlewareFullPath =
-                      middleware.fullPath.toUpperCase();
-                    const middlewareFullPathWithSliced = middleware.fullPath
-                      .toUpperCase()
-                      .slice(0, -1);
-
-                    return (
-                      middlewareFullPath === routeFullPath ||
-                      middlewareFullPath === `${routeFullPath}*` ||
-                      routeFullPath?.indexOf(middlewareFullPathWithSliced) !==
-                        -1
-                    );
-                  })
-                  .map(({ name, params, authParams }) => ({
-                    name,
-                    params,
-                    authParams,
-                  })),
-              ),
-            ],
-          },
-        };
-      }),
-    };
-  }
-}
-
-export default DocumentationGenerator;

package/services/http/HttpServer.js

@@ -1,89 +0,0 @@
-import http from 'node:http';
-// import path from 'node:path';
-// import * as url from 'node:url';
-import express from 'express';
-import RequestLoggerMiddleware from './middleware/RequestLogger.js';
-import I18nMiddleware from './middleware/I18n.js';
-import PrepareAppInfoMiddleware from './middleware/PrepareAppInfo.js';
-import RequestParserMiddleware from './middleware/RequestParser.js';
-import IpDetector from './middleware/IpDetector.js';
-import Cors from './middleware/Cors.js';
-import Base from '../../modules/Base.js';
-
-/**
- * HTTP server based on Express
- */
-class HttpServer extends Base {
-  constructor(app) {
-    super(app);
-    this.express = express();
-    this.express.disable('x-powered-by');
-
-    this.express.use(new RequestLoggerMiddleware(this.app).getMiddleware());
-    this.express.use(new PrepareAppInfoMiddleware(this.app).getMiddleware());
-    this.express.use(new IpDetector(this.app).getMiddleware());
-    this.express.use(new I18nMiddleware(this.app).getMiddleware());
-
-    const httpConfig = this.app.getConfig('http');
-    this.express.use(
-      new Cors(this.app, {
-        origins: httpConfig.corsDomains,
-      }).getMiddleware(),
-    );
-
-    this.express.use(new RequestParserMiddleware(this.app).getMiddleware());
-
-    // As exprress will check numbersof arguments
-    // eslint-disable-next-line no-unused-vars
-    this.express.use((err, req, res, next) => {
-      // error handling
-      console.error(err.stack);
-      // TODO
-      res.status(500).json({ message: 'Something broke!' });
-    });
-
-    this.httpServer = http.createServer(this.express);
-
-    const listener = this.httpServer.listen(
-      httpConfig.port,
-      httpConfig.hostname,
-      () => {
-        const address = listener.address();
-        const port = typeof address === 'string' ? 0 : address.port;
-        this.logger.info(`App started and listening on port ${port}`);
-        if (+port !== +httpConfig.port) {
-          // in case we using port 0
-          this.app.updateConfig('http', { port });
-          this.logger.info(
-            `Updating http config to use new port ${
-              port
-            }. Old was ${httpConfig.port} `,
-          );
-        }
-      },
-    );
-  }
-
-  /**
-   * Add handle for 404 error
-   */
-  add404Page() {
-    this.express.use((req, res) => {
-      // error handling
-      res.status(404).json({ message: '404' });
-    });
-  }
-
-  static get loggerGroup() {
-    return 'service';
-  }
-
-  /**
-   * Stop http server (mostly for unit testing)
-   */
-  shutdown() {
-    this.httpServer.close();
-  }
-}
-
-export default HttpServer;

package/services/http/middleware/AbstractMiddleware.js

@@ -1,51 +0,0 @@
-import { object } from 'yup';
-import Base from '../../../modules/Base.js';
-
-class AbstractMiddleware extends Base {
-  constructor(app, params) {
-    super(app);
-    this.params = params;
-  }
-
-  static get description() {
-    return 'Middleware description. Please provide own';
-  }
-
-  static get usedAuthParameters() {
-    return [];
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  get relatedQueryParameters() {
-    // For example  yup.object().shape({page: yup.number().required(),limit: yup.number()})
-    return object().shape({});
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  get relatedRequestParameters() {
-    // For example  yup.object().shape({page: yup.number().required(),limit: yup.number()})
-    return object().shape({});
-  }
-
-  get relatedReqParameters() {
-    return {
-      request: this.relatedRequestParameters,
-      query: this.relatedQueryParameters,
-    };
-  }
-
-  async middleware(req, res, next) {
-    this.logger.warn('Middleware is not implemented');
-    next();
-  }
-
-  getMiddleware() {
-    return this.middleware.bind(this);
-  }
-
-  static get loggerGroup() {
-    return 'middleware';
-  }
-}
-
-export default AbstractMiddleware;

package/services/http/middleware/Auth.js

@@ -1,20 +0,0 @@
-import AbstractMiddleware from './AbstractMiddleware.js';
-
-class AuthMiddleware extends AbstractMiddleware {
-  static get description() {
-    return 'Allow to pass only if the user provided. Please use any middleware that provide user instance before';
-  }
-
-  async middleware(req, res, next) {
-    if (!req.appInfo.user) {
-      this.logger.info('User try to access resource without credentials');
-      return res.status(401).json({
-        error: 'AUTH001',
-        message: 'Please login to application',
-      });
-    }
-    return next();
-  }
-}
-
-export default AuthMiddleware;

package/services/http/middleware/Cors.js

@@ -1,46 +0,0 @@
-import AbstractMiddleware from './AbstractMiddleware.js';
-
-class Cors extends AbstractMiddleware {
-  constructor(app, params) {
-    super(app);
-    this.params = params;
-    if (!Array.isArray(params?.origins) || !params.origins.length) {
-      throw new Error('Cors inited without origin config');
-    }
-  }
-
-  static get description() {
-    return 'Add CORS headers to request';
-  }
-
-  async middleware(req, res, next) {
-    for (const host of this.params.origins) {
-      if (
-        (typeof host === 'string' && req.headers.origin === host) ||
-        (host instanceof RegExp && host.test(req.headers.origin))
-      ) {
-        res.set('Access-Control-Allow-Origin', req.headers.origin);
-        res.set('Vary', 'Origin');
-
-        if (req.method === 'OPTIONS') {
-          res.set(
-            'Access-Control-Allow-Methods',
-            'GET,HEAD,PUT,PATCH,POST,DELETE',
-          );
-          res.set('Vary', 'Origin, Access-Control-Request-Headers');
-
-          const allowedHeaders = req.headers['access-control-request-headers'];
-          if (allowedHeaders) {
-            res.set('Access-Control-Allow-Headers', allowedHeaders);
-          }
-          res.set('Content-Length', '0');
-          res.status(204);
-          return res.end();
-        }
-      }
-    }
-    return next();
-  }
-}
-
-export default Cors;

package/services/http/middleware/GetUserByToken.js

@@ -1,47 +0,0 @@
-import AbstractMiddleware from './AbstractMiddleware.js';
-
-class GetUserByToken extends AbstractMiddleware {
-  static get description() {
-    return 'Grab a token and try to parse the user from it. It user exist will add req.appInfo.user variable';
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  get usedAuthParameters() {
-    return [
-      {
-        name: 'Authorization',
-        type: 'apiKey',
-        in: 'header',
-        description: GetUserByToken.description,
-      },
-    ];
-  }
-
-  async middleware(req, res, next) {
-    if (req.appInfo.user) {
-      this.logger.warn('You call GetUserByToken more then once');
-      return next();
-    }
-    let { token } = req.body || {};
-    this.logger.verbose(
-      `GetUserByToken token in BODY ${token}. Token in Authorization header ${req.get(
-        'Authorization',
-      )}`,
-    );
-    if (!token) {
-      token = req.get('Authorization');
-      if (!token || token === 'null') {
-        // is null express bug*
-        return next();
-      }
-    }
-    const User = this.app.getModel('User');
-    const user = await User.getUserByToken(token);
-    if (user) {
-      req.appInfo.user = user;
-    }
-    return next();
-  }
-}
-
-export default GetUserByToken;

package/services/http/middleware/I18n.js

@@ -1,117 +0,0 @@
-import i18next from 'i18next';
-import BackendFS from 'i18next-fs-backend';
-import AbstractMiddleware from './AbstractMiddleware.js';
-
-class I18n extends AbstractMiddleware {
-  cache = {};
-
-  enabled = true;
-
-  lookupQuerystring = '';
-
-  supportedLngs = [];
-
-  fallbackLng = 'en';
-
-  /** @type {i18next} */
-  i18n = {
-    // @ts-ignore
-    t: (text) => text,
-    language: 'en',
-  };
-
-  constructor(app, params) {
-    super(app, params);
-    const I18NConfig = this.app.getConfig('i18n');
-
-    if (I18NConfig.enabled) {
-      this.logger.info('Enabling i18n support');
-      this.i18n = i18next;
-      // eslint-disable-next-line import-x/no-named-as-default-member
-      i18next.use(BackendFS).init({
-        backend: {
-          loadPath: `${this.app.foldersConfig.locales}/{{lng}}/{{ns}}.json`,
-          addPath: `${this.app.foldersConfig.locales}/{{lng}}/{{ns}}.missing.json`,
-        },
-        fallbackLng: I18NConfig.fallbackLng,
-        preload: I18NConfig.preload,
-        saveMissing: I18NConfig.saveMissing,
-        debug: I18NConfig.debug,
-      });
-    }
-
-    this.enabled = I18NConfig.enabled;
-    this.lookupQuerystring = I18NConfig.lookupQuerystring;
-    this.supportedLngs = I18NConfig.supportedLngs;
-    this.fallbackLng = I18NConfig.fallbackLng;
-  }
-
-  static get description() {
-    return 'Provide language detection and translation';
-  }
-
-  async middleware(req, res, next) {
-    let i18n;
-
-    if (this.enabled) {
-      let lang = this.detectLang(req);
-      if (!lang || this.supportedLngs.indexOf(lang) === -1) {
-        this.logger.verbose(
-          `Language "${lang}" is not supported or not detected. Using fallback on ${this.fallbackLng}`,
-        );
-        lang = this.fallbackLng;
-      }
-
-      if (!this.cache[lang]) {
-        this.cache[lang] = i18next.cloneInstance({
-          initAsync: false,
-          lng: lang,
-        });
-      }
-      i18n = this.cache[lang];
-    }
-
-    if (!i18n) {
-      i18n = this.i18n;
-    }
-
-    req.appInfo.i18n = i18n;
-    req.i18n = new Proxy(req.appInfo.i18n, {
-      get: (target, prop) => {
-        this.logger.warn('Please not use "req.i18n" Use "req.appInfo.i18n"');
-        return target[prop];
-      },
-    });
-
-    return next();
-  }
-
-  detectors = {
-    XLang: (req) => req.get('X-Lang'), // grab from header
-    query: (req) => (req.query ? req.query[this.lookupQuerystring] : false), // grab from query
-    user: (req) => req.appInfo?.user?.locale, // what if we have a user and user have a defined locale?
-  };
-
-  detectorOrder = ['XLang', 'query', 'user'];
-
-  detectLang(req, isUseShortCode = true) {
-    let lang = '';
-    for (const detectorName of this.detectorOrder) {
-      const lng = this.detectors[detectorName](req);
-      if (!lng) {
-        continue;
-      }
-      if (i18next.services.languageUtils.isSupportedCode(lng)) {
-        if (isUseShortCode) {
-          lang = i18next.services.languageUtils.getLanguagePartFromCode(lng);
-        } else {
-          lang = lng;
-        }
-        break;
-      }
-    }
-    return lang;
-  }
-}
-
-export default I18n;