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

package/commands/CreateUser.js

@@ -1,106 +0,0 @@
-import AbstractCommand from '../modules/AbstractCommand.js';
-
-// Example: node src/cli createuser --email=somemail@gmail.com  --password=somePassword --roles=user,admin,someOtherRoles
-class CreateUser extends AbstractCommand {
-  static get description() {
-    return 'Create user in a database';
-  }
-
-  /**
-   * You able to add command arguments for parsing there.
-   * @returns {import("../types/ICommandArguments.js").ICommandArguments}
-   */
-  static get commandArguments() {
-    return {
-      id: {
-        type: 'string',
-        description: 'User id to find user',
-      },
-      email: {
-        type: 'string',
-        description: 'User id to find/create user',
-      },
-      password: {
-        type: 'string',
-        description: 'New password for user',
-      },
-      roles: {
-        type: 'string',
-        description:
-          'User roles comma separated string (--roles=user,admin,someOtherRoles)',
-      },
-      update: {
-        type: 'boolean',
-        default: false,
-        description: 'Update user if it exists',
-      },
-    };
-  }
-
-  async run() {
-    const User = this.app.getModel('User');
-    const { id, email, password, roles, update } = this.args;
-
-    if (!email && !id) {
-      this.logger.error('Input validation failded');
-      this.logger.error('Please add "email" or "id" variables');
-      return false;
-    }
-
-    let user;
-
-    if (id) {
-      user = await User.findOne({ _id: id });
-    } else if (email) {
-      user = await User.findOne({ email });
-    }
-
-    if (user && !update) {
-      this.logger.error(
-        'We are found a user in database. But "update" option is not providing. Exitin',
-      );
-      return false;
-    }
-
-    if (!user && !password) {
-      this.logger.error(
-        'For a new user we alway asking for a password. Please provide it and rerun command',
-      );
-      return false;
-    }
-
-    if (!user && !email) {
-      this.logger.error(
-        'For a new user we alway asking for a email. Please provide it and rerun command',
-      );
-      return false;
-    }
-
-    if (!user) {
-      user = new User();
-    }
-
-    if (password) {
-      user.password = password;
-    }
-    if (email) {
-      user.email = email;
-    }
-
-    if (roles) {
-      user.roles = roles.split(',');
-    }
-
-    await user.save();
-
-    await user.generateToken();
-
-    this.logger.info(
-      `User was created/updated ${JSON.stringify(user, null, 4)}`,
-    );
-
-    return user;
-  }
-}
-
-export default CreateUser;

package/commands/Documentation.js

@@ -1,17 +0,0 @@
-import AbstractCommand from '../modules/AbstractCommand.js';
-import ControllerManager from '../controllers/index.js';
-
-class Documentation extends AbstractCommand {
-  static get description() {
-    return 'Generate documentation (internal)';
-  }
-
-  async run() {
-    const CM = new ControllerManager(this.app);
-    this.app.documentation = [];
-    await CM.initControllers();
-    return this.app.documentation;
-  }
-}
-
-export default Documentation;

package/commands/DropIndex.js

@@ -1,38 +0,0 @@
-import AbstractCommand from '../modules/AbstractCommand.js';
-
-class DropIndex extends AbstractCommand {
-  static get description() {
-    return 'Drop indexes of model';
-  }
-
-  /**
-   * You able to add command arguments for parsing there.
-   * @returns {import("../types/ICommandArguments.js").ICommandArguments}
-   */
-  static get commandArguments() {
-    return {
-      model: {
-        type: 'string',
-        description: 'Model name',
-        required: true,
-      },
-    };
-  }
-
-  async run() {
-    const Model = this.app.getModel(this.args.model);
-
-    if (!Model) {
-      this.logger.error('Not able to find model');
-      return false;
-    }
-
-    await Model.collection.dropIndexes();
-
-    this.logger.info('Success');
-
-    return true;
-  }
-}
-
-export default DropIndex;

package/commands/GenerateRandomBytes.js

@@ -1,21 +0,0 @@
-import { randomBytes } from 'node:crypto';
-import AbstractCommand from '../modules/AbstractCommand.js';
-
-class GenerateRandomBytes extends AbstractCommand {
-  static get description() {
-    return 'Generate random bytes ising randomBytes from  node:crypto';
-  }
-
-  static isShouldInitModels = false;
-
-  async run() {
-    const sizes = [16, 32, 64, 128, 256];
-    for (const size of sizes) {
-      const bytes = randomBytes(size).toString('hex');
-      this.logger.info(`${size} bytes: ${bytes}`);
-    }
-    return true;
-  }
-}
-
-export default GenerateRandomBytes;

package/commands/GetOpenApiJson.js

@@ -1,336 +0,0 @@
-import { promises as fs } from 'node:fs';
-import AbstractCommand from '../modules/AbstractCommand.js';
-
-/**
- * Command for generate documentation json file openApi
- */
-class GetOpenApiJson extends AbstractCommand {
-  static get description() {
-    return 'Generate documentation (openApi) ';
-  }
-  /**
-   * You able to add command arguments for parsing there.
-   * @returns {import("../types/ICommandArguments.js").ICommandArguments}
-   */
-  static get commandArguments() {
-    return {
-      output: {
-        type: 'string',
-        description: 'Output file path',
-      },
-    };
-  }
-
-  async run() {
-    const { myDomain } = this.app.getConfig('http');
-    let jsonFile = process.env.npm_package_json;
-    if (!jsonFile) {
-      jsonFile = `${process.env.PWD}/package.json`;
-    }
-
-    try {
-      jsonFile = JSON.parse(await fs.readFile(jsonFile, 'utf8'));
-    } catch {
-      this.logger.error(
-        'No npm package detected. Please start this command via NPM as it depends on package.json',
-      );
-    }
-
-    if (!jsonFile) {
-      jsonFile = {
-        name: 'UNDETECTD PROJECT',
-        description: 'UNDETECTD PROJECT DECCRIPTION',
-        version: '0.0.0-undetrcted',
-        author: {
-          email: 'none@example.com',
-        },
-      };
-    }
-
-    if (!jsonFile.author) {
-      jsonFile.author = 'none@example.com';
-    }
-
-    const openApi = {
-      openapi: '3.0.0',
-      info: {
-        title: jsonFile.name,
-        description: jsonFile.description,
-        contact: {
-          email: jsonFile.author.email,
-        },
-        version: jsonFile.version,
-      },
-      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 = {};
-
-    const permissionWithRoutes = {};
-    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 = [];
-
-        permissionWithRoutes[Object.keys(route)?.[0]] = [];
-
-        if (middlewares?.length) {
-          for (const middleware of middlewares) {
-            if (middleware?.authParams?.length) {
-              for (const authParam of middleware.authParams) {
-                const { permissions, ...mainFields } = authParam;
-                const fullName = authParam.name;
-                if (permissions) {
-                  permissionWithRoutes[Object.keys(route)?.[0]].push(
-                    permissions,
-                  );
-                }
-
-                if (!openApi.components.securitySchemes[fullName]) {
-                  openApi.components.securitySchemes[fullName] = mainFields;
-                }
-
-                securitySchemaNames.push({
-                  [fullName]: [],
-                });
-              }
-            }
-          }
-        }
-
-        let routeName = Object.keys(route)[0];
-        if (routeName === '/') {
-          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 routeDescription =
-          route[Object.keys(route)[0]]?.description || 'empty description';
-        const permissions =
-          permissionWithRoutes[Object.keys(route)[0]][
-            permissionWithRoutes[Object.keys(route)[0]].length - 1
-          ];
-        const routeDescriptionWithPermissions = `${
-          permissions || ''
-        } ${routeDescription}`;
-        const methodName = route[Object.keys(route)[0]].method.toLowerCase();
-        const routeTitle = route[Object.keys(route)[0]].name;
-
-        const routeFields = route[Object.keys(route)[0]].fields;
-        const routeQueryFields = route[Object.keys(route)[0]].queryFields;
-
-        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 =
-          routeDescriptionWithPermissions;
-        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 queryField of routeQueryFields) {
-          openApi.paths[routeName][methodName].parameters.push({
-            name: queryField.name,
-            in: 'query',
-            required: queryField?.required,
-            schema: {
-              type: queryField.type,
-            },
-          });
-        }
-
-        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 = [];
-          let isMultipartFormaData = false;
-          for (const field of routeFields) {
-            if (field.required) {
-              requiredFields.push(field.name);
-            }
-
-            switch (field.type) {
-              case 'object':
-                groupBodyFields[field.name] = {
-                  properties: {},
-                };
-
-                for (const objField of field.fields) {
-                  groupBodyFields[field.name].properties[objField.name] = {
-                    // fields file has mixed type but openApi doesnt have this type
-                    type: objField.type === 'mixed' ? 'string' : objField.type,
-                  };
-                }
-
-                break;
-
-              case 'array':
-                groupBodyFields[field.name] = {
-                  items: {
-                    type: field.innerType,
-                  },
-                };
-                break;
-
-              case 'lazy':
-                groupBodyFields[field.name] = {
-                  oneOf: [
-                    {
-                      type: 'object',
-                    },
-                    {
-                      type: 'string',
-                    },
-                  ],
-                };
-                break;
-
-              case 'file':
-                groupBodyFields[field.name] = {
-                  type: 'string',
-                  format: 'binary',
-                };
-                isMultipartFormaData = true;
-                break;
-              default:
-                groupBodyFields[field.name] = {
-                  type: field.type,
-                };
-            }
-          }
-
-          const contentType = isMultipartFormaData
-            ? 'multipart/form-data'
-            : 'application/json';
-
-          openApi.paths[routeName][methodName].requestBody = {
-            content: {
-              [contentType]: {
-                schema: {
-                  type: 'object',
-                  properties: groupBodyFields,
-                },
-              },
-            },
-          };
-
-          if (requiredFields.length) {
-            openApi.paths[routeName][methodName].requestBody.content[
-              contentType
-            ].schema.required = requiredFields;
-          }
-        }
-      }
-    }
-
-    const result = JSON.stringify(openApi);
-
-    if (this.args.output) {
-      await fs.writeFile(this.args.output, result);
-      this.logger.info(`Output to: ${this.args.output}`);
-    }
-
-    return result;
-  }
-}
-
-export default GetOpenApiJson;

package/commands/SyncIndexes.js

@@ -1,40 +0,0 @@
-import path from 'node:path';
-import * as url from 'node:url';
-import AbstractCommand from '../modules/AbstractCommand.js';
-
-class SyncIndexes extends AbstractCommand {
-  async run() {
-    const dirname = url.fileURLToPath(new URL('.', import.meta.url));
-    const files = await this.getFilesPathWithInheritance(
-      path.join(dirname, '/../models'),
-      this.app.foldersConfig.models,
-    );
-    let models = [];
-
-    for (const file of files) {
-      models.push(path.basename(file.file, path.extname(file.file)));
-    }
-    models = models.sort();
-    this.logger.info(`Total found ${models.length} models`);
-
-    for (const modelName of models) {
-      const Model = this.app.getModel(modelName);
-      // eslint-disable-next-line no-await-in-loop
-      const removedIndexes = await Model.syncIndexes(); // await in loop not a bug. Lets do one by one
-      if (removedIndexes.length) {
-        this.logger.info(
-          `Model - ${modelName} removed indexes: ${removedIndexes}`,
-        );
-      } else {
-        this.logger.info(`Model - ${modelName} NO removed indexes`);
-      }
-    }
-    return true;
-  }
-
-  static get description() {
-    return 'Synchronize indexes defined in models with a real one indexed on the database.  Command will remove all indexes from the database that do not exist on model OR have different parameters. Then it will create a new indexes   ';
-  }
-}
-
-export default SyncIndexes;

package/commands/migration/Create.js

@@ -1,72 +0,0 @@
-import path from 'node:path';
-import { promises as fs } from 'node:fs';
-import AbstractCommand from '../../modules/AbstractCommand.js';
-
-class CreateMigration extends AbstractCommand {
-  static get description() {
-    return 'Create new migration';
-  }
-
-  /**
-   * You able to add command arguments for parsing there.
-   * @returns {import("../../types/ICommandArguments.js").ICommandArguments}
-   */
-  static get commandArguments() {
-    return {
-      name: {
-        type: 'string',
-        description: 'Migration name',
-        required: true,
-      },
-    };
-  }
-
-  async run() {
-    if (this.args.name.match(/^\d/)) {
-      this.logger.error('Command cant start from nubmer');
-      return false;
-    }
-    const fileName = `${Date.now()}_${CreateMigration.camelSentence(
-      this.args.name,
-    )}.js`;
-
-    const fileContent = CreateMigration.getTemplate(
-      CreateMigration.camelSentence(this.args.name),
-    );
-
-    await fs.writeFile(
-      path.join(this.app.foldersConfig.migrations, fileName),
-      fileContent,
-    );
-    this.logger.info(`Migration created ${fileName}`);
-    return true;
-  }
-
-  static camelSentence(str) {
-    return ` ${str}`
-      .toLowerCase()
-      .replace(/[^a-zA-Z0-9]+(.)/g, (match, chr) => chr.toUpperCase());
-  }
-
-  static getTemplate(name) {
-    return `/* eslint-disable class-methods-use-this */
-
-import Base from '@adaptivestone/framework/modules/Base.js';
-
-class ${name} extends Base {
-  async up() {
-    // put here your mirgation up logic
-    // const YourModel = this.app.getModel('ModelName');
-  }
-
-  async down() {
-    // put here your mirgation down logic
-  }
-}
-
-export default ${name};
-`;
-  }
-}
-
-export default CreateMigration;

package/commands/migration/Migrate.js

@@ -1,56 +0,0 @@
-import * as url from 'node:url';
-import path from 'node:path';
-import AbstractCommand from '../../modules/AbstractCommand.js';
-
-class Migrate extends AbstractCommand {
-  static get description() {
-    return 'Run all pending migrations';
-  }
-
-  async run() {
-    const dirname = url.fileURLToPath(new URL('.', import.meta.url));
-
-    const files = await this.getFilesPathWithInheritance(
-      path.join(dirname, '/../../migrations'),
-      this.app.foldersConfig.migrations,
-    );
-    files.sort(
-      (a, b) => Number(a.file.split('_')[0]) - Number(b.file.split('_')[0]),
-    );
-    const MigrationModel = this.app.getModel('Migration');
-    const lastMigration = await MigrationModel.findOne({})
-      .sort({ createdAt: -1 })
-      .exec();
-
-    let migrations = files;
-
-    if (lastMigration) {
-      const lastMigrationTime = Number(
-        lastMigration.migrationFile.split('_')[0],
-      );
-      migrations = files.filter(
-        (val) => Number(val.file.split('_')[0]) > lastMigrationTime,
-      );
-    }
-
-    for (const migration of migrations) {
-      this.logger.info(`=== Start migration ${migration.file} ===`);
-      // eslint-disable-next-line no-await-in-loop
-      const { default: MigrationCommand } = await import(migration.path);
-      const migrationCommand = new MigrationCommand(this.app);
-      // eslint-disable-next-line no-await-in-loop
-      await migrationCommand.up();
-      // eslint-disable-next-line no-await-in-loop
-      await MigrationModel.create({
-        migrationFile: migration.file,
-      });
-    }
-
-    this.logger.info(
-      `=== Migration Finished. Migrated ${migrations.length} files ===`,
-    );
-    return true;
-  }
-}
-
-export default Migrate;

package/config/auth.js

@@ -1,9 +0,0 @@
-export default {
-  hashRounds: 64,
-  saltSecret:
-    process.env.AUTH_SALT ||
-    console.error(
-      'AUTH_SALT is not defined. You can "npm run cli generateRandomBytes" and use it',
-    ),
-  isAuthWithVefificationFlow: true,
-};