@merkaly/api 0.2.4-5 → 0.2.4-7

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));
+})();

package/src/middlewares/logger.middleware.ts

@@ -0,0 +1,15 @@
+import { Inject, Injectable, NestMiddleware } from '@nestjs/common';
+import { NextFunction, Request, Response } from 'express';
+import { LoggerService } from '../services/logger.service';
+
+@Injectable()
+export class LoggerMiddleware implements NestMiddleware {
+  @Inject()
+  protected readonly $logger: LoggerService;
+
+  public use(req: Request, res: Response, next: NextFunction) {
+    this.$logger.debug(req.originalUrl, req.method);
+
+    return next();
+  }
+}

package/src/middlewares/organization.middleware.ts

@@ -0,0 +1,76 @@
+import { Inject, Injectable, NestMiddleware, OnModuleInit } from '@nestjs/common';
+import { Organization } from 'auth0';
+import { NextFunction, Request } from 'express';
+import { MissingIdentityException } from '../exceptions/missing-identity.exception';
+import { StoreNotImplementedException } from '../exceptions/store-not-implemented.exception';
+import { Auth0Service } from '../services/auth0.service';
+import { OrganizationListener } from "../modules/setting/organization/organization.listener";
+
+declare module 'http' {
+  interface IncomingHttpHeaders {
+    identity?: string;
+  }
+}
+
+declare module 'express-session' {
+  interface SessionData {
+    organization?: Organization;
+  }
+}
+
+@Injectable()
+export class OrganizationMiddleware implements NestMiddleware, OnModuleInit {
+  public readonly organizations = [];
+  @Inject()
+  protected readonly $auth0: Auth0Service;
+  protected readonly $event = new OrganizationListener();
+  protected readonly allowedDomains = ['.store.merkaly.local', '.store.merkaly.io'];
+
+  public async onModuleInit() {
+    const organizations = await this.$auth0.organizations.getAll()
+
+    for await (const organization of organizations) {
+      this.organizations.push(this.$event.parseMetadata(organization))
+    }
+
+    return this.organizations
+  }
+
+  public async use(req: Request, res: Response, next: NextFunction) {
+    const identity = String(req.headers.identity || req.query.identity);
+
+    !identity && MissingIdentityException.throw();
+
+    let org: Organization | undefined
+
+    if (this.allowedDomains.some(dns => identity.endsWith(dns))) {
+      const [name] = identity.split('.');
+
+      org = this.organizations.find(org => org.name === name)
+    }
+
+    if (!org) {
+      org = this.organizations.find((org) => {
+        if (org.id === identity) {
+          return org
+        }
+
+        if (org.name === identity) {
+          return org
+        }
+
+        if (org.metadata?.domains?.includes(identity)) {
+          return org
+        }
+      })
+    }
+
+    if (org) {
+      req.session.organization = org
+
+      return next()
+    }
+
+    return StoreNotImplementedException.throw(identity)
+  }
+}

package/src/migrations/1667226478717-product_price_enhance.ts

@@ -0,0 +1,29 @@
+import { UpdateQuery } from "mongoose";
+import { connect } from '../abstract/abstract.migration';
+import { ProductEntity } from "../modules/inventory/products/product.entity";
+
+/**
+ * Make any changes you need to make to the database here
+ */
+export const up = () => connect(async (connection) => {
+  const productRepository = await connection.collection('inventory_products');
+
+  const updateSentence: UpdateQuery<ProductEntity>[] = [
+    { $set: { price: { sale: '$price', purchase: '$price' } } },
+  ];
+
+  return productRepository.updateMany({}, updateSentence);
+});
+
+/**
+ * Make any changes that UNDO the up function side effects here (if possible)
+ */
+export const down = () => connect(async (connection) => {
+  const productRepository = await connection.collection('inventory_products');
+
+  const updateSentence: UpdateQuery<ProductEntity>[] = [
+    { $set: { price: '$price.sale' } },
+  ];
+
+  return productRepository.updateMany({}, updateSentence);
+});

package/src/migrations/1667329249561-product_add_seo_code_dimension.ts

@@ -0,0 +1,37 @@
+import { connect } from '../abstract/abstract.migration';
+import { UpdateQuery } from "mongoose";
+import { ProductEntity } from "../modules/inventory/products/product.entity";
+
+/**
+ * Make any changes you need to make to the database here
+ */
+export const up = () => connect(async (connection) => {
+  const productRepository = await connection.collection('inventory_products');
+
+  const updateSentence: UpdateQuery<ProductEntity>[] = [{
+    $set: {
+      seo: { slug: null, title: '$name', description: '$description' },
+      code: { sku: undefined, gtin: undefined, mpn: undefined },
+      dimension: { weight: undefined, height: undefined, width: undefined, depth: undefined },
+    },
+  }];
+
+  return productRepository.updateMany({}, updateSentence);
+});
+
+/**
+ * Make any changes that UNDO the up function side effects here (if possible)
+ */
+export const down = () => connect(async (connection) => {
+  const productRepository = await connection.collection('inventory_products');
+
+  const updateSentence: UpdateQuery<ProductEntity>[] = [{
+    $unset: {
+      seo: undefined,
+      code: undefined,
+      dimension: undefined,
+    },
+  }];
+
+  return productRepository.updateMany({}, updateSentence);
+});