@adaptivestone/framework 5.0.0-beta.2 → 5.0.0-beta.21

package/modules/BaseCli.js

@@ -1,97 +0,0 @@
-/* eslint-disable no-console */
-import path from 'node:path';
-import * as url from 'node:url';
-import Base from './Base.js';
-
-class Cli extends Base {
-  constructor(server) {
-    super(server.app);
-    this.server = server;
-    this.commands = {};
-  }
-
-  async loadCommands() {
-    if (Object.keys(this.commands).length) {
-      return true;
-    }
-    const dirname = url.fileURLToPath(new URL('.', import.meta.url));
-    const commandsToLoad = await this.getFilesPathWithInheritance(
-      path.join(dirname, '../commands'),
-      this.server.app.foldersConfig.commands,
-    );
-    for (const com of commandsToLoad) {
-      if (com.file.endsWith('.js')) {
-        const c = com.file.replace('.js', '');
-
-        this.commands[c.toLowerCase()] = com.path;
-      }
-    }
-    return true;
-  }
-
-  async printCommandTable() {
-    const commands = Object.keys(this.commands).sort();
-    const maxLength = commands.reduce((max, c) => Math.max(max, c.length), 0);
-    console.log('Available commands:');
-    let commandsClasses = [];
-    for (const c of commands) {
-      // eslint-disable-next-line no-await-in-loop
-      commandsClasses.push(import(this.commands[c]));
-      // console.log(
-      //   ` \x1b[36m${c.padEnd(maxLength)}\x1b[0m - ${f.default.description}`,
-      // );
-    }
-    commandsClasses = await Promise.all(commandsClasses);
-    for (const [key, c] of Object.entries(commands)) {
-      // eslint-disable-next-line no-await-in-loop
-      console.log(
-        ` \x1b[36m${c.padEnd(maxLength)}\x1b[0m - ${commandsClasses[key].default.description}`,
-      );
-    }
-  }
-
-  async run(command, args) {
-    await this.loadCommands();
-
-    if (!command) {
-      console.log('Please provide command name');
-      await this.printCommandTable();
-      return false;
-    }
-
-    if (!this.commands[command]) {
-      console.log(`Command ${command} not found `);
-      await this.printCommandTable();
-      return false;
-    }
-    const { default: Command } = await import(this.commands[command]);
-
-    if (Command.isShouldInitModels) {
-      this.logger.debug(
-        `Command ${command} isShouldInitModels called. If you want to skip loading and init models, please set isShouldInitModels to false in tyou command`,
-      );
-      process.env.MONGO_APP_NAME = Command.getMongoConnectionName(
-        command,
-        args,
-      );
-      await this.server.initAllModels();
-    } else {
-      this.logger.debug(`Command ${command} NOT need to isShouldInitModels`);
-    }
-
-    const c = new Command(this.app, this.commands, args);
-    let result = false;
-
-    result = await c.run().catch((e) => {
-      this.logger.error(e.stack);
-    });
-
-    return result;
-  }
-
-  static get loggerGroup() {
-    return 'CLI_';
-  }
-}
-
-export default Cli;

package/server.d.ts

@@ -1,98 +0,0 @@
-import TFolderConfig from './types/TFoldersConfig';
-import { ExpandDeep } from './types/Expand';
-
-import EventEmitter from 'events';
-
-import { Model as MongooseModel, Schema } from 'mongoose';
-
-import BaseCli from './modules/BaseCli';
-import Cache from './services/cache/Cache';
-import winston from 'winston';
-
-import HttpServer from './services/http/HttpServer.js';
-
-type ServerConfig = {
-  folders: ExpandDeep<TFolderConfig>;
-};
-
-declare class Server {
-  config: ServerConfig;
-  app: {
-    getConfig: Server['getConfig'];
-    getModel: Server['getModel'];
-    runCliCommand: Server['runCliCommand'];
-    updateConfig: Server['updateConfig'];
-    foldersConfig: Server['config']['folders'];
-    events: EventEmitter;
-    get cache(): Server['cacheService'];
-    get logger(): winston.Logger;
-    httpServer: HttpServer | null;
-    controllerManager: null;
-  };
-  cacheService: Cache;
-
-  cache: {
-    configs: Map<string, {}>;
-    models: Map<string, MongooseModel<any>>;
-  };
-  cli: null | BaseCli;
-
-  /**
-   *  Construct new server
-   */
-  constructor(config: ExpandDeep<ServerConfig>);
-
-  /**
-   * Start server (http  + init all http ralated functions)
-   */
-  startServer(callbackBefore404?: Promise<null>): Promise<null>;
-
-  /**
-   * Do an initialization (config reading,  etc)
-   * @returns {Promise}
-   */
-  init(
-    options: { isSkipModelInit: boolean } = { isSkipModelInit: false },
-  ): Promise<boolean>;
-
-  /**
-   * Load model and init them
-   * @returns {Promise}
-   */
-  initAllModels(): Promise<void>;
-
-  /**
-   * Return config from {configName} (file name) on config folder.
-   * Support cache and updating confing into cache
-   * Also will update config based on NODE_ENV. If config.js and config.production.js
-   * and NODE_ENV is production then we will load base config (config.js) and the load
-   * environment config (config.production.js) and overwrite base config options
-   * @see updateConfig
-   * @TODO generate that based on real data
-   */
-  getConfig(configName: string): { [key: string]: any };
-
-  /**
-   * Return or create new logger instance. This is a main logger instance
-   */
-  getLogger(): winston.Logger;
-
-  /**
-   * Primary designed for tests when we need to update some configs before start testing
-   * Should be called before any initialization was done
-   */
-  updateConfig(configName: string, config: {}): { [key: string]: any };
-
-  /**
-   * Return model from {modelName} (file name) on model folder.
-   * Support cache
-   */
-  getModel(modelName: string): MongooseModel<any>;
-
-  /**
-   * Run cli command into framework (http, ws, etc)
-   */
-  runCliCommand(commandName: string, args: {}): Promise<BaseCli['run']>;
-}
-
-export default Server;

package/server.js

@@ -1,429 +0,0 @@
-/* eslint-disable no-console */
-import EventEmitter from 'node:events';
-import { hrtime, loadEnvFile } from 'node:process';
-import * as url from 'node:url';
-import path from 'node:path';
-
-import merge from 'deepmerge';
-import winston from 'winston';
-import { getFilesPathWithInheritance } from './helpers/files.js';
-import { consoleLogger } from './helpers/logger.js';
-import Cache from './services/cache/Cache.js';
-
-try {
-  loadEnvFile();
-} catch (e) {
-  console.warn('No env file found. This is ok. But please check youself.');
-}
-
-/**
- * Main framework class.
- */
-class Server {
-  #realLogger = null;
-
-  #isInited = false;
-
-  #isModelsInited = false;
-
-  #isModelsLoaded = false;
-
-  cli = null;
-
-  /**
-   *  Construct new server
-   * @param {Object} config main config object
-   * @param {Object} config.folders folders config
-   * @param {String} config.folders.config path to folder with config files
-   * @param {String} config.folders.models path to folder with moidels files
-   * @param {String} config.folders.controllers path to folder with controllers files
-   * @param {String} config.folders.views path to folder with view files
-   * @param {String} config.folders.locales path to folder with locales files
-   * @param {String} config.folders.emails path to folder with emails files
-   */
-  constructor(config) {
-    this.config = config;
-    const that = this;
-    this.app = {
-      getConfig: this.getConfig.bind(this),
-      getModel: this.getModel.bind(this),
-      runCliCommand: this.runCliCommand.bind(this),
-      updateConfig: this.updateConfig.bind(this),
-      foldersConfig: this.config.folders,
-      events: new EventEmitter(),
-      get cache() {
-        return that.getCache();
-      },
-      get logger() {
-        return that.getLogger();
-      },
-      httpServer: null,
-      controllerManager: null,
-    };
-
-    this.cache = {
-      configs: new Map(),
-      models: new Map(),
-      modelConstructors: new Map(),
-    };
-  }
-
-  /**
-   * Start server (http  + init all http ralated functions)
-   * @param {Function} callbackBefore404 code that should be executed before adding page 404
-   * @returns {Promise}
-   */
-  async startServer(callbackBefore404 = async () => Promise.resolve()) {
-    const [{ default: HttpServer }, { default: ControllerManager }] =
-      await Promise.all([
-        import('./services/http/HttpServer.js'), // Speed optimisation
-        import('./controllers/index.js'), // Speed optimisation
-        this.init(),
-      ]);
-
-    this.addErrorHandling();
-
-    // TODO config
-    this.app.httpServer = new HttpServer(this.app);
-
-    this.app.controllerManager = new ControllerManager(this.app);
-
-    await this.app.controllerManager.initControllers();
-    await callbackBefore404();
-    this.app.httpServer.add404Page();
-  }
-
-  /**
-   * Do an initialization (config reading,  etc)
-   * @returns {Promise}
-   */
-  async init({ isSkipModelInit = false, isSkipModelLoading = false } = {}) {
-    if (this.#isInited) {
-      return true;
-    }
-
-    console.time('Server init. Done');
-    console.time('Loading config and model files. Time');
-    const prom = [this.#initConfigFiles()];
-    if (!isSkipModelLoading) {
-      prom.push(this.#loadModelFiles());
-    }
-    await Promise.all(prom);
-    console.timeEnd('Loading config and model files. Time');
-
-    if (!isSkipModelInit) {
-      await this.initAllModels();
-    }
-
-    this.#isInited = true;
-
-    console.timeEnd('Server init. Done');
-
-    return true;
-  }
-
-  /**
-   * Load model and init them
-   * @returns {Promise}
-   */
-  async initAllModels() {
-    if (this.#isModelsInited) {
-      // already inited
-      return;
-    }
-    const now = performance.now();
-
-    if (!this.#isModelsLoaded) {
-      await this.#loadModelFiles();
-    }
-
-    if (this.app.getConfig('mongo').connectionString) {
-      for (const [modelName, ModelConstructor] of this.cache
-        .modelConstructors) {
-        try {
-          const model = new ModelConstructor(this.app);
-          this.cache.models.set(modelName, model.mongooseModel);
-        } catch (e) {
-          this.app.logger.error(
-            `Problem with model ${modelName}, ${e.message}`,
-          );
-          this.app.logger.error(e);
-        }
-      }
-    } else {
-      this.app.logger.info(
-        'Skipping inited models as we have no mongo connection string',
-      );
-    }
-
-    this.app.logger.debug(
-      `Inited models in ${(performance.now() - now).toFixed(2)}ms`,
-    );
-    this.#isModelsInited = true;
-  }
-
-  async #initConfigFiles() {
-    const dirname = url.fileURLToPath(new URL('.', import.meta.url));
-    const files = await getFilesPathWithInheritance({
-      internalFolder: path.join(dirname, '/config'),
-      externalFolder: this.app.foldersConfig.config,
-      loggerFileType: 'CONFIG',
-      logger: (m) => consoleLogger('info', m),
-      filter: {
-        startWithCapital: false,
-      },
-    });
-
-    const configFiles = {};
-
-    for (const file of files) {
-      const config = file.file.split('.');
-      if (!configFiles[config[0]]) {
-        configFiles[config[0]] = {};
-      }
-      if (config.length === 2) {
-        configFiles[config[0]].default = file.path;
-      } else {
-        configFiles[config[0]][config[1]] = file.path;
-      }
-    }
-
-    const loadConfig = async (configName, values) => {
-      const promises = [import(values.default)];
-      if (process.env.NODE_ENV && values[process.env.NODE_ENV]) {
-        promises.push(import(values[process.env.NODE_ENV]));
-      }
-      const result = await Promise.all(promises);
-      return {
-        name: configName,
-        finalValue: merge(result[0].default, result[1]?.default || {}, {
-          arrayMerge: (destinationArray, sourceArray) => sourceArray,
-        }),
-      };
-    };
-
-    const loadingPromises = [];
-
-    for (const [configFile, value] of Object.entries(configFiles)) {
-      loadingPromises.push(loadConfig(configFile, value));
-    }
-
-    const configs = await Promise.all(loadingPromises);
-
-    for (const config of configs) {
-      this.cache.configs.set(config.name, config.finalValue);
-    }
-    return true;
-  }
-
-  async #loadModelFiles() {
-    if (this.#isModelsLoaded) {
-      // already inited
-      return true;
-    }
-    const dirname = url.fileURLToPath(new URL('.', import.meta.url));
-    const files = await getFilesPathWithInheritance({
-      internalFolder: path.join(dirname, '/models'),
-      externalFolder: this.app.foldersConfig.models,
-      loggerFileType: 'MODEL',
-      logger: (m) => consoleLogger('info', m),
-    });
-
-    const promises = [];
-    for (const file of files) {
-      const t = hrtime.bigint();
-      promises.push(
-        import(file.path).then((f) => ({
-          name: file.file.split('.')[0],
-          file: f,
-          took: hrtime.bigint() - t,
-        })),
-      );
-    }
-
-    const loadedModels = await Promise.all(promises);
-
-    for (const model of loadedModels) {
-      this.cache.modelConstructors.set(model.name, model.file.default);
-    }
-    this.#isModelsLoaded = true;
-    return true;
-  }
-
-  /**
-   * Add error logging on promise reject
-   */
-  addErrorHandling() {
-    process.on('uncaughtException', (e) =>
-      this.app.logger.error('uncaughtException', e),
-    );
-    process.on('unhandledRejection', (e) => {
-      this.app.logger.error('unhandledRejection', e);
-    });
-  }
-
-  /**
-   * Return config from {configName} (file name) on config folder.
-   * Support cache and updating confing into cache
-   * Also will update config based on NODE_ENV. If config.js and config.production.js
-   * and NODE_ENV is production then we will load base config (config.js) and the load
-   * environment config (config.production.js) and overwrite base config options
-   * @see updateConfig
-   * @param {String} configName name on config file to load
-   * @returns {Object} config object. Structure depends of config file
-   */
-  getConfig(configName) {
-    if (!this.cache.configs.has(configName)) {
-      if (!this.#isInited) {
-        throw new Error('You should call Server.init() before using getConfig');
-      }
-      this.app.logger.warn(
-        `You asked for config ${configName} that not exists. Please check you codebase `,
-      );
-      return {};
-    }
-    return this.cache.configs.get(configName);
-  }
-
-  /**
-   * Return or create new logger instance. This is a main logger instance
-   */
-  getLogger() {
-    if (!this.#realLogger) {
-      this.#realLogger = this.#createLogger();
-    }
-    return this.#realLogger;
-  }
-
-  #createLogger() {
-    const alignColorsAndTime = winston.format.combine(
-      winston.format.colorize({
-        all: true,
-      }),
-      winston.format.timestamp(),
-      winston.format.printf(
-        (info) =>
-          `(${process.pid}) \x1B[32m[${info.label ?? 'SERVER'}]\x1B[39m ${
-            info.timestamp
-          }  ${info.level} : ${info.message} ${info?.stack ?? ''} ${
-            info.durationMs ? `Duration: ${info.durationMs}ms` : ''
-          }`,
-      ),
-    );
-    const logConfig = this.app.getConfig('log').transports;
-    function IsConstructor(f) {
-      try {
-        Reflect.construct(String, [], f);
-      } catch (e) {
-        return false;
-      }
-      return true;
-    }
-
-    const logger = winston.createLogger({
-      format: winston.format.errors({ stack: true }),
-      level: 'silly',
-    });
-
-    for (const log of logConfig) {
-      if (log.enable) {
-        if (log.transport === 'console') {
-          logger.add(
-            new winston.transports.Console({
-              level: log.transportOptions.level,
-              format: winston.format.combine(
-                winston.format.colorize(),
-                alignColorsAndTime,
-              ),
-            }),
-          );
-        } else {
-          import(log.transport).then((Tr) => {
-            let Transport = Tr.default;
-            if (!IsConstructor(Transport) && Transport.default) {
-              Transport = Transport.default;
-            } else {
-              console.error(
-                `${log.transport} not a constructor. Please check it`,
-              );
-              return;
-            }
-            logger.profile(`Adding new logger ${log.transport}`);
-            logger.add(new Transport(log.transportOptions));
-            logger.profile(`Adding new logger ${log.transport}`);
-          });
-        }
-      }
-    }
-
-    return logger;
-  }
-
-  /**
-   * Primary designed for tests when we need to update some configs before start testing
-   * Should be called before any initialization was done
-   * @TODO send event to all inited components to update config
-   * @param {String} configName
-   * @param {Object} config
-   */
-  updateConfig(configName, config) {
-    // const confName = configName.charAt(0).toUpperCase() + configName.slice(1);
-    const conf = this.getConfig(configName);
-    const newConf = Object.assign(conf, config); // TODO deep clone
-    this.cache.configs.set(configName, newConf);
-    return newConf;
-  }
-
-  /**
-   * Return model from {modelName} (file name) on model folder.
-   * Support cache
-   * @param {String} modelName name on config file to load
-   * @returns {import('mongoose').Model | false| {}}
-   */
-  getModel(modelName) {
-    if (modelName.endsWith('s')) {
-      this.app.logger.warn(
-        `Probably your model name '${modelName}' in plural from. Try to avoid plural form`,
-      );
-    }
-    if (!this.#isInited) {
-      this.app.logger.error(
-        new Error('You should call Server.init() before using getModel'),
-      );
-      return false;
-    }
-    if (!this.cache.models.has(modelName)) {
-      this.app.logger.warn(
-        `You asked for model ${modelName} that not exists. Please check you codebase `,
-      );
-      return {};
-    }
-    return this.cache.models.get(modelName);
-  }
-
-  /**
-   * Run cli command into framework (http, ws, etc)
-   * @param {String} commandName name of command to load
-   * @param {Object} args list of arguments to pass into command
-   */
-  async runCliCommand(commandName, args) {
-    if (!this.cli) {
-      const { default: BaseCli } = await import('./modules/BaseCli.js'); // Speed optimisation
-      this.cli = new BaseCli(this);
-    }
-    return this.cli.run(commandName, args);
-  }
-
-  /**
-   * Get internal cache service
-   * @returns
-   */
-  getCache() {
-    if (!this.cacheService) {
-      this.cacheService = new Cache(this.app);
-    }
-    return this.cacheService;
-  }
-}
-
-export default Server;

package/services/cache/Cache.d.ts

@@ -1,35 +0,0 @@
-import Base from '../../modules/Base';
-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;