@merkaly/api 0.2.4-6 → 0.2.4-7

package/src/app.module.ts

@@ -0,0 +1,92 @@
+import {
+  CacheModule,
+  Inject,
+  Logger,
+  MiddlewareConsumer,
+  Module,
+  ModuleMetadata,
+  NestModule,
+  RequestMethod,
+  Scope,
+} from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { APP_INTERCEPTOR, RouterModule } from '@nestjs/core';
+import { Routes } from '@nestjs/core/router/interfaces';
+import { EventEmitter2, EventEmitterModule } from '@nestjs/event-emitter';
+import { AppController } from './app.controller';
+import { AppStrategy } from './app.strategy';
+import { MongoInterceptor } from './interceptors/mongo.interceptor';
+import { LoggerMiddleware } from './middlewares/logger.middleware';
+import { OrganizationMiddleware } from './middlewares/organization.middleware';
+import { AssetModule } from './modules/assets/asset.module';
+import { CommandsModule } from './modules/command.module';
+import { ContentModule } from './modules/content/content.module';
+import { GlobalModule } from './modules/global.module';
+import { InsightModule } from './modules/insight/insight.module';
+import { InventoryModule } from './modules/inventory/inventory.module';
+import { SettingModule } from './modules/setting/setting.module';
+import { SalesModule } from './modules/sales/sales.module';
+import { UserModule } from './modules/users/user.module';
+import { LoggerService } from './services/logger.service';
+import { AuthModule } from "./modules/auth/auth.module";
+
+export const router = [
+  AssetModule,
+  AuthModule,
+  ContentModule,
+  InventoryModule,
+  InsightModule,
+  SettingModule,
+  SalesModule,
+  UserModule,
+];
+
+const modules = [
+  ...router,
+  GlobalModule.register(),
+  CommandsModule.register(),
+  RouterModule.register(router as Routes),
+  CacheModule.register({ isGlobal: true }),
+  ConfigModule.forRoot({ isGlobal: true }),
+  EventEmitterModule.forRoot({ wildcard: true }),
+];
+
+export const metadata: ModuleMetadata = {
+  controllers: [AppController],
+  imports: modules,
+  providers: [
+    AppStrategy,
+    {
+      provide: APP_INTERCEPTOR,
+      scope: Scope.REQUEST,
+      useClass: MongoInterceptor,
+    },
+  ],
+};
+
+@Module(metadata)
+export class AppModule implements NestModule {
+  @Inject()
+  protected readonly $event: EventEmitter2;
+
+  @Inject()
+  protected readonly $logger: LoggerService;
+
+  public configure(consumer: MiddlewareConsumer): MiddlewareConsumer {
+    this.$event.onAny((event) => Logger.verbose(`Event emitted: ${event}`));
+
+    consumer
+      .apply(OrganizationMiddleware)
+      .exclude(
+        { path: '/health', method: RequestMethod.GET },
+        { path: '/organizations', method: RequestMethod.GET }
+      )
+      .forRoutes({ path: '/*', method: RequestMethod.ALL });
+
+    consumer
+      .apply(LoggerMiddleware)
+      .forRoutes({ path: '/*', method: RequestMethod.ALL });
+
+    return consumer;
+  }
+}

package/src/app.strategy.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { readFileSync } from 'fs';
+import { ExtractJwt, Strategy, StrategyOptions } from 'passport-jwt';
+import { join } from 'path';
+import { AppConfig } from './app.config';
+import { DecodedUser } from './decorators/user.decorator';
+
+@Injectable()
+export class AppStrategy extends PassportStrategy(Strategy) {
+  public constructor() {
+    const strategy: StrategyOptions = {
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      audience: AppConfig.auth0.audience,
+      ignoreExpiration: true,
+      secretOrKey: process.env.AUTH_CERTIFICATE || readFileSync(join(process.cwd(), '/authCertificate.pem')),
+    };
+
+    super(strategy);
+  }
+
+  public validate(user: DecodedUser) {
+    return user;
+  }
+}

package/src/commands/assets.command.ts

@@ -0,0 +1,38 @@
+import { Inject } from '@nestjs/common';
+import { Command, Console } from 'nestjs-console';
+import { AssetEntity } from '../modules/assets/asset.entity';
+import { AssetRepository } from '../modules/assets/asset.repository';
+import { ProductEntity } from '../modules/inventory/products/product.entity';
+import { ProductRepository } from '../modules/inventory/products/product.repository';
+import { StorageService } from '../services/storage.service';
+
+@Console({ command: 'assets', description: 'Prune, cleand and remove assets' })
+export class AssetsCommand {
+  @Inject()
+  protected readonly $storage: StorageService;
+
+  @Inject()
+  protected readonly $assetRepository: AssetRepository;
+
+  @Inject()
+  protected readonly $productRepository: ProductRepository;
+
+  @Command({ command: 'prune', description: 'Remove assest that hasnt relation with another entity' })
+  public async prune() {
+
+    const products: ProductEntity[] = await this.$productRepository.$model
+      .find({ files: { $exists: true, $not: { $size: 0 } } });
+
+    const files = products.map(({ files }) => files).flat();
+    const assets: AssetEntity[] = await this.$assetRepository.$model.find({ '_id': { $nin: files } });
+
+    // Remove automatically assets that not are stored in google storage
+    const externalAssets = assets.filter(asset => asset.url.startsWith('https://storage.googleapis.com') === false);
+    const internalAssets = assets.filter(asset => asset.url.startsWith('https://storage.googleapis.com'));
+
+    await this.$assetRepository.$model.find({ '_id': { $nin: files } });
+    await this.$assetRepository.$model.deleteMany({ _id: { $in: externalAssets.map(asset => asset._id) } });
+
+    return process.exit();
+  }
+}

package/src/commands/deploy.command.ts

@@ -0,0 +1,6 @@
+import { Console } from 'nestjs-console';
+
+@Console({ command: 'deploy', description: 'Deploy App' })
+export class DeployCommand {
+
+}

package/src/commands/fixture.command.ts

@@ -0,0 +1,11 @@
+import { Command, Console } from 'nestjs-console';
+
+@Console({ command: 'fixture', description: 'Fill db with default required data' })
+export class FixtureCommand {
+  @Command({ command: 'settings:payments', description: 'Add all default settings payments' })
+  public async settingsPayments() {
+    const types = [];
+
+    return Promise.all(types);
+  }
+}

package/src/commands/generate.command.ts

@@ -0,0 +1,286 @@
+import { faker } from '@faker-js/faker';
+import { Inject } from '@nestjs/common';
+import { Command, Console, createSpinner } from 'nestjs-console';
+import { AssetEntity } from '../modules/assets/asset.entity';
+import { AssetRepository } from '../modules/assets/asset.repository';
+import { PageFixture } from '../modules/content/pages/page.fixture';
+import { PageRepository } from '../modules/content/pages/page.repository';
+import { BrandRepository } from '../modules/inventory/brands/brand.repository';
+import { CreateBrandValidator } from '../modules/inventory/brands/brand.validator';
+import { CategoryRepository } from '../modules/inventory/categories/category.repository';
+import { CreateCategoryValidator } from '../modules/inventory/categories/category.validator';
+import { ProductRepository } from '../modules/inventory/products/product.repository';
+import { CreateProductValidator } from '../modules/inventory/products/product.validator';
+import { ClientRepository } from '../modules/sales/clients/client.repository';
+import { CreateClientValidator } from '../modules/sales/clients/client.validator';
+import { OrderRepository } from '../modules/sales/orders/order.repository';
+import { CreateOrderValidator } from '../modules/sales/orders/order.validator';
+import { StatusType } from '../modules/sales/orders/status/status.validator';
+import { CustomerValidator } from "../modules/sales/orders/customer/customer.validator";
+import { BillingMethod } from "../modules/sales/orders/billing/billing.types";
+import { ShippingMethod } from "../modules/sales/orders/shipping/shipping.types";
+import { MetaAddress } from "../types";
+
+@Console({ command: 'generate', description: 'Generate massive fake data' })
+export class GenerateCommand {
+  @Inject() protected readonly brandRepository: BrandRepository;
+  @Inject() protected readonly categoryRepository: CategoryRepository;
+  @Inject() protected readonly productRepository: ProductRepository;
+  @Inject() protected readonly clientRepository: ClientRepository;
+  @Inject() protected readonly assetRepository: AssetRepository;
+  @Inject() protected readonly orderRepository: OrderRepository;
+  @Inject() protected readonly pageRepository: PageRepository;
+
+  private static generate<T = unknown>(iterator: number, promiseCb: () => Promise<T>) {
+    const listOfPromises = [];
+
+    for (let i = 0; i < iterator; i++) {
+      listOfPromises.push(promiseCb());
+    }
+
+    return Promise.all(listOfPromises);
+  }
+
+  @Command({ command: 'brands <quantity>', description: 'Generate and persist fake brands' })
+  public async generateBrands(quantity = 5) {
+    const spinner = createSpinner();
+    spinner.start(`Creating ${quantity} new brands`);
+
+    const callback = () => {
+      const brand = new CreateBrandValidator();
+      brand.name = [faker.vehicle.manufacturer(), faker.vehicle.model(), faker.lorem.words(1)].join(' ');
+      brand.description = faker.lorem.sentence();
+
+      return this.brandRepository.create(brand);
+    };
+
+    return GenerateCommand.generate(quantity, callback)
+      .then(({ length }) => spinner.succeed(`Created ${length} of ${quantity} brands`));
+  }
+
+  @Command({ command: 'categories <quantity>', description: 'Generate and persist fake categories' })
+  public async generateCategories(quantity = 10) {
+    const spinner = createSpinner();
+    spinner.start(`Creating ${quantity} new categories`);
+
+    const callback = () => {
+      const category = new CreateCategoryValidator();
+      category.name = faker.lorem.words(3);
+      category.description = faker.lorem.sentence();
+
+      return this.categoryRepository.create(category);
+    };
+
+    return GenerateCommand.generate(quantity, callback)
+      .then(({ length }) => spinner.succeed(`Created ${length} of ${quantity} categories`));
+  }
+
+  @Command({ command: 'products <quantity>', description: 'Generate and persist fake products' })
+  public async generateProducts(quantity = 100) {
+    const spinner = createSpinner();
+    spinner.start(`Creating ${quantity} new products`);
+
+    const allBrands = await this.brandRepository.find();
+    const allCategories = await this.categoryRepository.find();
+
+    const callback = async () => {
+      const product = new CreateProductValidator();
+
+      product.name = `${faker.commerce.product()} ${faker.commerce.product()} ${faker.commerce.product()} `;
+      product.description = faker.commerce.productDescription();
+
+      product.price.sale = Number(faker.commerce.price(1000, 10000, 2));
+      product.price.purchase = product.price.sale - Number(faker.commerce.price(80, 100, 2));
+
+      product.brand = faker.helpers.arrayElement(allBrands.items)._id;
+      product.category = faker.helpers.arrayElement(allCategories.items)._id;
+
+      product.active = faker.datatype.boolean();
+
+      product.seo.slug = faker.lorem.slug();
+      product.seo.title = faker.commerce.productName();
+      product.seo.description = faker.commerce.productDescription();
+
+      product.dimension.depth = faker.datatype.number(100);
+      product.dimension.height = faker.datatype.number(100);
+      product.dimension.weight = faker.datatype.number(10);
+      product.dimension.width = faker.datatype.number(100);
+
+      product.code.sku = faker.lorem.slug();
+      product.code.gtin = faker.lorem.slug();
+      product.code.mpn = faker.lorem.slug();
+
+      product.hashtags = faker.lorem.words().split(' ');
+
+      const { _id: file1 } = await this.createAsset();
+      const { _id: file2 } = await this.createAsset();
+      const { _id: file3 } = await this.createAsset();
+      const { _id: file4 } = await this.createAsset();
+      const { _id: file5 } = await this.createAsset();
+
+      product.files.push(file1, file2, file3, file4, file5);
+
+      return this.productRepository.create(product);
+    };
+
+    return GenerateCommand.generate(quantity, callback)
+      .then(({ length }) => spinner.succeed(`Created ${length} of ${quantity} products`));
+  }
+
+  @Command({ command: 'clients <quantity>', description: 'Generate and persist fake clients' })
+  public async generateClients(quantity = 50) {
+    const spinner = createSpinner();
+    spinner.start(`Creating ${quantity} new clients`);
+
+    const callback = () => {
+      const client = new CreateClientValidator();
+
+      client.name = faker.company.name();
+      client.email = faker.internet.exampleEmail();
+      client.phone = faker.phone.number();
+      client.identificationNumber = faker.phone.imei();
+
+      return this.clientRepository.create(client);
+    };
+
+    return GenerateCommand.generate(quantity, callback)
+      .then(({ length }) => spinner.succeed(`Created ${length} of ${quantity} clients`));
+  }
+
+  @Command({ command: 'orders <quantity>', description: 'Generate and persist fake orders' })
+  public async generateOrders(quantity = 10) {
+    const spinner = createSpinner();
+    spinner.start(`Creating ${quantity} new orders`);
+
+    const allProducts = await this.productRepository.$model.find();
+    const allClients = await this.clientRepository.$model.find();
+
+    const callback = async () => {
+      const order = new CreateOrderValidator();
+
+      const generateAddress = (): MetaAddress => ({
+        street: faker.address.streetAddress(false),
+        number: faker.address.buildingNumber(),
+        complement: faker.address.secondaryAddress(),
+        city: faker.address.city(),
+        state: faker.address.stateAbbr(),
+        country: faker.address.countryCode('alpha-2'),
+        code: faker.address.zipCode(),
+      });
+
+      const generateCustomer = (): CustomerValidator => ({
+        email: faker.internet.email(),
+        name: faker.internet.userName(),
+        phone: faker.phone.number(),
+      });
+
+      order.billing = {
+        address: generateAddress(),
+        customer: generateCustomer(),
+        method: faker.helpers.arrayElement(Object.values(BillingMethod))
+      };
+
+      order.shipping = {
+        address: generateAddress(),
+        customer: generateCustomer(),
+        method: faker.helpers.arrayElement(Object.values(ShippingMethod)),
+        price: Number(faker.commerce.price(1000, 10000, 2))
+      };
+
+      order.customer = generateCustomer();
+
+      const items = Number(faker.random.numeric(1).toString());
+
+      order.items = [...Array(items)].map(() => ({
+        quantity: Number(faker.random.numeric(2)),
+        product: faker.helpers.arrayElement(allProducts)._id,
+      }));
+
+      order.client = faker.helpers.arrayElement(allClients)._id;
+
+      const createdOrder = await this.orderRepository.create(order);
+      await createdOrder.updateOne({
+        $set: {
+          createdAt: faker.date.recent(200)
+        }
+      })
+
+      const generateStatus = (status: StatusType, date: Date) => ({
+        name: status,
+        user: faker.internet.email(),
+        date: faker.date.recent(10, date),
+      });
+
+      faker.helpers.maybe(() => {
+        const status = generateStatus(StatusType.ACCEPTED, createdOrder.createdAt);
+        createdOrder.status.push(status);
+        return faker.helpers.maybe(() => {
+          const status1 = generateStatus(StatusType.IN_PREPARATION, status.date);
+          createdOrder.status.push();
+          return faker.helpers.maybe(() => {
+            const status2 = generateStatus(StatusType.SENDED, status1.date);
+            createdOrder.status.push(status2);
+            return faker.helpers.maybe(() => {
+              const status3 = generateStatus(StatusType.COMPLETED, status2.date);
+              createdOrder.status.push();
+              return faker.helpers.maybe(() => {
+                const status4 = generateStatus(StatusType.CANCELED, status3.date);
+                createdOrder.status.push(status4);
+              }, { probability: 0.1 });
+            }, { probability: 0.3 });
+          }, { probability: 0.5 });
+        }, { probability: 0.7 });
+      }, { probability: 0.9 });
+
+      return createdOrder.save();
+    };
+
+    for await(const iterator of Array(Number(quantity)).fill(null)) {
+      await callback()
+        .then(({ fullNumber }) => spinner.text = (`Created order [${fullNumber}]`))
+    }
+
+    return spinner.succeed(`Created ${quantity} orders`)
+  }
+
+  @Command({ command: 'pages <quantity>', description: 'Generate and persist fake content pages' })
+  public async generateContentPages(quantity = 10) {
+    const spinner = createSpinner();
+    spinner.start(`Creating ${quantity} new pages`);
+    const fixture = new PageFixture();
+
+    const callback = async () => {
+      const page = fixture.normal();
+
+      const createPage = await this.pageRepository.create(page);
+
+      return createPage.save();
+    };
+
+    return GenerateCommand.generate(quantity, callback)
+      .then(({ length }) => spinner.succeed(`Created ${length} of ${quantity} pages`));
+  }
+
+  @Command({ command: 'all', description: 'Execute all seeders' })
+  public async generateAll() {
+    await this.generateBrands(10);
+    await this.generateCategories(20);
+    await this.generateProducts(100);
+
+    await this.generateClients(10);
+    await this.generateOrders(100);
+  }
+
+  protected async createAsset() {
+    const asset: Partial<AssetEntity> = {};
+
+    asset.name = faker.lorem.words(3);
+    asset.description = faker.lorem.sentence();
+    asset.url = faker.image.food(635, 475, true);
+    asset.weak = false;
+    asset.type = faker.system.mimeType();
+    asset.size = Number(faker.random.numeric(5));
+
+    return this.assetRepository.create(asset);
+  }
+}

package/src/decorators/public.decorator.ts

@@ -0,0 +1,5 @@
+import { CustomDecorator, SetMetadata } from '@nestjs/common';
+
+export const IS_PUBLIC_KEY = 'isPublic';
+
+export const Public: () => CustomDecorator = () => SetMetadata(IS_PUBLIC_KEY, true);

package/src/decorators/user.decorator.ts

@@ -0,0 +1,21 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { Request } from 'express';
+
+export interface DecodedUser {
+  iss: string,
+  sub: string,
+  aud: string[],
+  iat: number,
+  exp: number,
+  azp: string,
+  scope: string,
+  org_id?: string
+}
+
+export const GetUser = createParamDecorator((key: keyof DecodedUser, ctx: ExecutionContext) => {
+  const { user } = ctx.switchToHttp().getRequest<Request>();
+
+  return key
+    ? user[key]
+    : user;
+});

package/src/exceptions/missing-identity.exception.ts

@@ -0,0 +1,11 @@
+import { PreconditionFailedException } from '@nestjs/common';
+
+export class MissingIdentityException extends PreconditionFailedException {
+  public constructor() {
+    super('Missing identity parameter on your request');
+  }
+
+  public static throw() {
+    throw new MissingIdentityException;
+  }
+}

package/src/exceptions/store-not-implemented.exception.ts

@@ -0,0 +1,13 @@
+import { Logger, NotFoundException } from '@nestjs/common';
+
+export class StoreNotImplementedException extends NotFoundException {
+  public constructor(identity: string) {
+    super(`No store found by that id or name: [${identity}]`);
+  }
+
+  public static throw(identity: string) {
+
+    Logger.warn('Store not found or implemented', identity)
+    throw new StoreNotImplementedException(identity);
+  }
+}

package/src/exceptions/store-not-recognized.exception.ts

@@ -0,0 +1,11 @@
+import { NotAcceptableException } from '@nestjs/common/exceptions/not-acceptable.exception';
+
+export class StoreNotRecognizedException extends NotAcceptableException {
+  public constructor() {
+    super(`The store could not be accepted`);
+  }
+
+  public static throw() {
+    throw new StoreNotRecognizedException();
+  }
+}

package/src/guards/auth.guard.ts

@@ -0,0 +1,43 @@
+import { ExecutionContext, Inject, Injectable, UnauthorizedException } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { AuthGuard as JwtGuard } from '@nestjs/passport';
+import { IS_PUBLIC_KEY } from '../decorators/public.decorator';
+import { DecodedUser } from '../decorators/user.decorator';
+
+declare module 'express' {
+  interface Request {
+    user?: DecodedUser;
+  }
+}
+
+@Injectable()
+export class AuthGuard extends JwtGuard('jwt') {
+
+  @Inject() private reflector: Reflector;
+
+  public async canActivate(context: ExecutionContext): Promise<any> {
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    if (isPublic) {
+      return true;
+    }
+
+    return super.canActivate(context);
+  }
+
+  public handleRequest(err: Record<string, unknown>, user: DecodedUser): any {
+    if (err) {
+      throw err;
+    }
+
+    if (!user) {
+      throw new UnauthorizedException();
+    }
+
+    return user;
+  }
+
+}

package/src/guards/organization.guard.ts

@@ -0,0 +1,39 @@
+import { CanActivate, ExecutionContext, Inject, Injectable } from '@nestjs/common';
+import { Request } from 'express';
+import { AppController } from '../app.controller';
+import { IS_PUBLIC_KEY } from "../decorators/public.decorator";
+import { Reflector } from "@nestjs/core";
+
+@Injectable()
+export class OrganizationGuard implements CanActivate {
+  @Inject() private reflector: Reflector;
+
+  public async canActivate(context: ExecutionContext) {
+
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+
+    if (isPublic) {
+      return true;
+    }
+
+    if (context.getType() === 'http') {
+      const allowedHandlers: any[] = [AppController.prototype.userOrganizations];
+
+      if (allowedHandlers.includes(context.getHandler())) {
+        return true;
+      }
+
+      const request = context.switchToHttp().getRequest<Request>();
+
+      const { organization } = request.session;
+
+      return !!organization?.id;
+    }
+
+    return false;
+  }
+
+}

package/src/interceptors/mongo.interceptor.ts

@@ -0,0 +1,16 @@
+import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
+import { InjectConnection } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
+import { Observable } from 'rxjs';
+import { finalize } from 'rxjs/operators';
+
+@Injectable()
+export class MongoInterceptor implements NestInterceptor {
+  @InjectConnection()
+  protected readonly $connection: Connection;
+
+  public intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    return next.handle()
+      .pipe(finalize(() => this.$connection.close()));
+  }
+}

package/src/main.ts

@@ -0,0 +1,37 @@
+import { Logger, ValidationPipe } from '@nestjs/common';
+import { NestApplication, NestFactory } from '@nestjs/core';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import session from 'express-session';
+import { AppConfig } from './app.config';
+import { AppModule } from './app.module';
+import { AuthGuard } from './guards/auth.guard';
+import { OrganizationGuard } from './guards/organization.guard';
+
+(async () => {
+  const app = await NestFactory.create(AppModule, {
+    cors: true,
+  });
+
+  app.use(session({
+    secret: 'thisIsNotASecretAnyMore',
+    resave: false,
+    saveUninitialized: false,
+  }));
+
+  const builder = new DocumentBuilder()
+    .setTitle(AppConfig.server.name)
+    .setDescription(AppConfig.server.description)
+    .setVersion(AppConfig.server.version)
+    .addBearerAuth()
+    .build();
+
+  //Creating Swagger Doc for API
+  const document = SwaggerModule.createDocument(app, builder);
+  SwaggerModule.setup('/', app, document);
+
+  return app
+    .useGlobalGuards(app.get(AuthGuard), app.get(OrganizationGuard))
+    .useGlobalPipes(new ValidationPipe({ whitelist: true, transform: true }))
+    .listen(AppConfig.server.port)
+    .then(async () => Logger.verbose(`Running on: ${await app.getUrl()}`, NestApplication.name));
+})();