@merkaly/api 0.2.5-4 → 0.2.5-6

package/src/app.module.ts

@@ -0,0 +1,54 @@
+import { MiddlewareConsumer, Module, NestModule, RequestMethod, Scope } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { APP_GUARD, APP_INTERCEPTOR, RouterModule, Routes } from '@nestjs/core';
+import { JwtModule } from '@nestjs/jwt';
+import { PassportModule } from '@nestjs/passport';
+import { ConsoleModule } from 'nestjs-console';
+import { AuthGuard } from './app.guard';
+import { AppStrategy } from './app.strategy';
+import { MongoInterceptor } from './interceptors/mongoose.interceptor';
+import { RouterMiddleware } from './middlewares/router.middleware';
+import { AssetModule } from './modules/asset/asset.module';
+import { AuthModule } from './modules/auth/auth.module';
+import { CommandsModule } from './modules/command.module';
+import { GlobalModule } from './modules/global.module';
+import { InventoryModule } from './modules/inventory/inventory.module';
+import { SaleModule } from './modules/sale/sale.module';
+
+export const router = [AuthModule, AssetModule, ConfigModule, InventoryModule, SaleModule];
+
+@Module({
+  controllers: [],
+  imports: [
+    ...router,
+    GlobalModule.register(),
+    RouterModule.register(router as Routes),
+    JwtModule.register({ global: true, signOptions: { expiresIn: '60s' } }),
+    ConfigModule.forRoot({ isGlobal: true }),
+    PassportModule,
+    ConsoleModule,
+    CommandsModule.register(),
+  ],
+  providers: [
+    AppStrategy,
+    {
+      provide: APP_GUARD,
+      useClass: AuthGuard,
+    },
+    {
+      provide: APP_INTERCEPTOR,
+      scope: Scope.REQUEST,
+      useClass: MongoInterceptor,
+    },
+  ],
+})
+export class AppModule implements NestModule {
+  public configure(consumer: MiddlewareConsumer) {
+    consumer
+      .apply(RouterMiddleware)
+      .exclude({ path: '/auth/resolve', method: RequestMethod.GET })
+      .forRoutes({ path: '/*', method: RequestMethod.ALL });
+
+    return consumer;
+  }
+}

package/src/app.strategy.ts

@@ -0,0 +1,21 @@
+import { Injectable } from '@nestjs/common';
+import { PassportStrategy } from '@nestjs/passport';
+import { ExtractJwt, Strategy, StrategyOptions } from 'passport-jwt';
+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(),
+      secretOrKey: AppConfig.AUTH0.certificate,
+    };
+
+    super(strategy);
+  }
+
+  public validate(user: DecodedUser) {
+    return user;
+  }
+}

package/src/commands/seed.command.ts

@@ -0,0 +1,263 @@
+import { faker } from '@faker-js/faker/locale/pt_BR';
+import { Inject } from '@nestjs/common';
+import { InjectConnection } from '@nestjs/mongoose';
+import { Connection } from 'mongoose';
+import { Command, Console } from 'nestjs-console';
+import process from 'process';
+import { FileRepository } from '../modules/asset/files/file.repository';
+import { FileSchema } from '../modules/asset/files/file.schema';
+import { UserRepository } from '../modules/auth/users/user.repository';
+import { UserSchema } from '../modules/auth/users/user.schema';
+import { CreateUserValidator } from '../modules/auth/users/user.validator';
+import { BrandSchema } from '../modules/inventory/brands/brand.schema';
+import { CategoryRepository } from '../modules/inventory/categories/category.repository';
+import { CategorySchema } from '../modules/inventory/categories/category.schema';
+import { CreateCategoryValidator } from '../modules/inventory/categories/category.validator';
+import { ProductRepository } from '../modules/inventory/products/product.repository';
+import { ProductSchema } from '../modules/inventory/products/product.schema';
+import { CreateProductValidator } from '../modules/inventory/products/product.validator';
+import { OrderStatus } from '../modules/sale/orders/enums/order.status';
+import { OrderRepository } from '../modules/sale/orders/order.repository';
+import { CreateOrderValidator } from '../modules/sale/orders/order.validator';
+import { BillingType } from '../modules/sale/payments/enums/billing.type';
+import { PaymentStatus } from '../modules/sale/payments/enums/payment.status';
+import { ShippingType } from '../modules/sale/payments/enums/shipping.type';
+
+@Console({ command: 'seed' })
+export class SeedCommand {
+  @Inject()
+  protected readonly $productRepository: ProductRepository;
+
+  @Inject()
+  protected readonly $categoryRepository: CategoryRepository;
+
+  @Inject()
+  protected readonly $userRepository: UserRepository;
+
+  @Inject()
+  protected readonly $orderRepository: OrderRepository;
+
+  @Inject()
+  protected readonly $usersRepository: UserRepository;
+
+  @Inject()
+  protected readonly $categoriesRepository: CategoryRepository;
+
+  @Inject()
+  protected readonly $filesRepository: FileRepository;
+
+  @InjectConnection()
+  private connection: Connection;
+
+  @Command({ command: 'app', description: 'Seed entire app with random data' })
+  public async seedEntireApp() {
+    const list = [];
+
+    list.push(
+      this.connection.collection(ProductSchema.name).deleteMany(),
+      this.connection.collection(CategorySchema.name).deleteMany(),
+      this.connection.collection(BrandSchema.name).deleteMany(),
+
+      this.connection.collection(FileSchema.name).deleteMany(),
+      this.connection.collection(UserSchema.name).deleteMany(),
+    );
+
+    await Promise.all(list);
+
+    await this.generateUser();
+    await this.generateCategories();
+    await this.generateProducts();
+    await this.generateOrders();
+
+    return process?.exit?.(1);
+  }
+
+  @Command({ command: 'categories <counter>', description: 'Generate random categories' })
+  public async generateCategories(counter = 10) {
+    return this.generate(() => {
+      const category = new CreateCategoryValidator();
+      category.name = faker.lorem.words(2).concat(faker.helpers.replaceSymbols('********'));
+      category.description = faker.lorem.sentence();
+
+      return this.$categoryRepository.create(category);
+    }, counter);
+  }
+
+  @Command({ command: 'products <counter>', description: 'Generate random products' })
+  public async generateProducts(counter = 50) {
+    const { items: categories } = await this.$categoriesRepository.find();
+
+    await this.generate(async () => {
+      const validator = new CreateProductValidator();
+
+      validator.active = faker.datatype.boolean({ probability: 0.9 });
+      validator.name = `${faker.commerce.productName()} ${faker.helpers.replaceSymbols('*****')}`;
+      validator.description = faker.lorem.lines({ max: 6, min: 3 });
+      validator.price = Math.round(Math.random() * 100_000);
+
+      validator.attributes.units = faker.helpers.arrayElement([1, 5, 10]);
+      validator.attributes.sku = faker.helpers.replaceSymbols('*******');
+      validator.attributes.stock = faker.number.int({ min: 0, max: 100 });
+
+      if (faker.datatype.boolean({ probability: 0.9 })) {
+        validator.category = faker.helpers.arrayElement(categories)._id;
+      }
+
+      if (faker.datatype.boolean({ probability: 0.8 })) {
+        const files = await this.generate(() => {
+          const url = `https://cartzilla.createx.studio/img/shop/catalog/${faker.number
+            .int({ max: 72, min: 1 })
+            .toString()
+            .padStart(2, '0')}.jpg`;
+
+          return this.$filesRepository.create({
+            description: faker.lorem.sentence(),
+            name: faker.helpers.replaceSymbols('********.jpg'),
+            size: faker.number.int(),
+            type: faker.system.mimeType(),
+            url: url,
+            weak: false,
+          });
+        }, faker.number.int({ max: 5, min: 0 }));
+
+        validator.pictures = files.map(({ _id }) => _id);
+      }
+
+      return this.$productRepository.create(validator);
+    }, counter);
+  }
+
+  @Command({ command: 'users <counter>', description: 'Generate random users' })
+  public async generateUser(counter = 50) {
+    return this.generate(() => {
+      const user = new CreateUserValidator();
+
+      user.auth0 = faker.database.mongodbObjectId();
+      user.name = faker.person.fullName();
+      user.email = faker.internet.email({ lastName: user.name });
+      user.picture = faker.internet.avatar();
+      user.locale = faker.helpers.arrayElement(['es', 'pt', 'en']);
+
+      return this.$userRepository.create(user);
+    }, counter);
+  }
+
+  @Command({ command: 'orders <counter>', description: 'Generate random users' })
+  public async generateOrders(counter = 300) {
+    const { items: users } = await this.$userRepository.find();
+    const { items: products } = await this.$productRepository.find();
+
+    return this.generate(async () => {
+      const order = new CreateOrderValidator();
+      order.description = faker.lorem.sentence();
+
+      order.billing.type = faker.helpers.enumValue(BillingType);
+      order.billing.address = {
+        city: faker.location.city(),
+        code: faker.location.zipCode(),
+        country: faker.location.countryCode('alpha-2'),
+        line1: `${faker.location.buildingNumber()} ${faker.location.street()}`,
+        line2: faker.location.secondaryAddress(),
+        state: faker.location.state(),
+      };
+
+      order.shipping.type = faker.helpers.enumValue(ShippingType);
+      order.shipping.email = faker.internet.email();
+      order.shipping.phone = faker.phone.number();
+      order.shipping.name = faker.person.fullName();
+      order.shipping.address = {
+        city: faker.location.city(),
+        code: faker.location.zipCode(),
+        country: faker.location.countryCode('alpha-2'),
+        line1: `${faker.location.buildingNumber()} ${faker.location.street()}`,
+        line2: faker.location.secondaryAddress(),
+        state: faker.location.state(),
+      };
+
+      const items = faker.number.int({ max: 10, min: 1 });
+
+      order.items = [...Array(items)].map(() => ({
+        product: faker.helpers.arrayElement(products)._id,
+        quantity: Number(faker.number.int({ max: 10, min: 1 })),
+      }));
+
+      const randomUser = faker.helpers.arrayElement(users);
+
+      const createdOrder = await this.$orderRepository.create(order, randomUser);
+
+      const generateStatus = (state: OrderStatus) => {
+        const lastDate = faker.date.past({
+          refDate: createdOrder.status[createdOrder.status.length - 1]?.date,
+          years: 1,
+        });
+
+        return createdOrder.status.push({
+          date: lastDate,
+          name: state,
+          user: randomUser._id as any,
+        });
+      };
+
+      const generatePayment = (state: PaymentStatus) => {
+        const lastDate = faker.date.past({
+          refDate: createdOrder.status[createdOrder.status.length - 1]?.date,
+          years: 1,
+        });
+
+        if (typeof createdOrder.payment === 'string') {
+          return createdOrder;
+        }
+
+        return createdOrder.payment.status.push({
+          date: lastDate,
+          name: state,
+          user: randomUser._id as any,
+        });
+      };
+
+      faker.helpers.maybe(() => generateStatus(OrderStatus.ACCEPTED), {
+        probability: 0.9,
+      });
+      faker.helpers.maybe(() => generateStatus(OrderStatus.COMPLETED), {
+        probability: 0.6,
+      });
+      faker.helpers.maybe(() => generateStatus(OrderStatus.CANCELED), {
+        probability: 0.3,
+      });
+
+      faker.helpers.maybe(() => generatePayment(PaymentStatus.WAITING), {
+        probability: 0.8,
+      });
+      faker.helpers.maybe(() => generatePayment(PaymentStatus.PAID), {
+        probability: 0.6,
+      });
+      faker.helpers.maybe(() => generatePayment(PaymentStatus.CANCELLED), {
+        probability: 0.4,
+      });
+      faker.helpers.maybe(() => generatePayment(PaymentStatus.REFUNDED), {
+        probability: 0.2,
+      });
+
+      await createdOrder.updateOne({
+        $set: { createdAt: faker.date.past({ years: 3 }) },
+      });
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      await createdOrder.payment.save();
+      await createdOrder.save();
+
+      return createdOrder;
+    }, counter);
+  }
+
+  private generate<T = unknown>(hook: (index: number) => Promise<T>, lenght: number) {
+    const listOfPromises: Promise<T>[] = [];
+
+    for (let iterator = 0; iterator < Number(lenght); iterator++) {
+      listOfPromises.push(hook(iterator));
+    }
+
+    return Promise.all(listOfPromises);
+  }
+}

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,30 @@
+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;
+  given_name: string;
+  family_name: string;
+  nickname?: string;
+  name: string;
+  picture: string;
+  locale: 'es';
+  updated_at: Date;
+  email: string;
+  email_verified: boolean;
+  sid: string;
+  nonce: 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/interceptors/mongoose.interceptor.ts

@@ -0,0 +1,63 @@
+import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
+import { InjectConnection, InjectModel } from '@nestjs/mongoose';
+import { Connection, Model } from 'mongoose';
+import { finalize } from 'rxjs/operators';
+import { FileEntity } from '../modules/asset/files/file.entity';
+import { FileSchema } from '../modules/asset/files/file.schema';
+import { OrganizationEntity } from '../modules/auth/organizations/organization.entity';
+import { OrganizationSchema } from '../modules/auth/organizations/organization.schema';
+import { UserEntity } from '../modules/auth/users/user.entity';
+import { BrandEntity } from '../modules/inventory/brands/brand.entity';
+import { BrandSchema } from '../modules/inventory/brands/brand.schema';
+import { CategoryEntity } from '../modules/inventory/categories/category.entity';
+import { CategorySchema } from '../modules/inventory/categories/category.schema';
+import { ComplementEntity } from '../modules/inventory/complements/complement.entity';
+import { ComplementSchema } from '../modules/inventory/complements/complement.schema';
+import { ProductEntity } from '../modules/inventory/products/product.entity';
+import { ProductSchema } from '../modules/inventory/products/product.schema';
+import { CustomerEntity } from '../modules/sale/customers/customer.entity';
+import { CustomerSchema } from '../modules/sale/customers/customer.schema';
+import { OrderEntity } from '../modules/sale/orders/order.entity';
+import { OrderSchema } from '../modules/sale/orders/order.schema';
+import { PaymentEntity } from '../modules/sale/payments/payment.entity';
+import { PaymentSchema } from '../modules/sale/payments/payment.schema';
+
+@Injectable()
+export class MongoInterceptor implements NestInterceptor {
+  @InjectConnection()
+  protected readonly $connection: Connection;
+
+  @InjectModel(OrganizationSchema.name)
+  protected readonly authOrganization: Model<OrganizationEntity>;
+
+  @InjectModel(OrganizationSchema.name)
+  protected readonly authUser: Model<UserEntity>;
+
+  @InjectModel(CategorySchema.name)
+  protected readonly inventoryCategory: Model<CategoryEntity>;
+
+  @InjectModel(FileSchema.name)
+  protected readonly assetFile: Model<FileEntity>;
+
+  @InjectModel(BrandSchema.name)
+  protected readonly inventoryBrand: Model<BrandEntity>;
+
+  @InjectModel(ProductSchema.name)
+  protected readonly inventoryProduct: Model<ProductEntity>;
+
+  @InjectModel(ComplementSchema.name)
+  protected readonly inventoryComplement: Model<ComplementEntity>;
+
+  @InjectModel(OrderSchema.name)
+  protected readonly saleOrder: Model<OrderEntity>;
+
+  @InjectModel(CustomerSchema.name)
+  protected readonly saleCustomer: Model<CustomerEntity>;
+
+  @InjectModel(PaymentSchema.name)
+  protected readonly salePayment: Model<PaymentEntity>;
+
+  public intercept(context: ExecutionContext, next: CallHandler) {
+    return next.handle().pipe(finalize(() => this.$connection.close()));
+  }
+}

package/src/main.ts

@@ -0,0 +1,27 @@
+import { Logger } from '@nestjs/common';
+import { HttpsOptions } from '@nestjs/common/interfaces/external/https-options.interface';
+import { NestApplication, NestFactory } from '@nestjs/core';
+// import { readFileSync } from 'fs';
+import { createNestApp } from '../app';
+import { AppConfig } from './app.config';
+import { AppModule } from './app.module';
+
+(async () => {
+  const httpsOptions: HttpsOptions = undefined;
+
+  // if (AppConfig.SERVER.isDEV) {
+  //   httpsOptions = {
+  //     key: readFileSync('./.cert/key.pem'),
+  //     cert: readFileSync('./.cert/cert.pem'),
+  //   };
+  // }
+
+  const app = await NestFactory.create(AppModule, {
+    cors: true,
+    httpsOptions,
+  });
+
+  return createNestApp(app)
+    .listen(AppConfig.SERVER.port)
+    .then(async () => Logger.verbose(`Running on: ${await app.getUrl()}`, NestApplication.name));
+})();

package/src/middlewares/router.middleware.ts

@@ -0,0 +1,14 @@
+import { Injectable, Logger, NestMiddleware } from '@nestjs/common';
+import { NextFunction, Request, Response } from 'express';
+import { MongoService } from '../services/mongo.service';
+
+@Injectable()
+export class RouterMiddleware implements NestMiddleware {
+  public use(req: Request, res: Response, next: NextFunction) {
+    const identity = MongoService.extractIdentityFromRequest(req);
+
+    Logger.debug(`[${req.method}]: ${req.originalUrl}`, identity);
+
+    return next();
+  }
+}

package/src/modules/asset/asset.module.ts

@@ -0,0 +1,19 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../abstracts/abstract.router';
+import { FileModule } from './files/file.module';
+
+export const metadata: ModuleMetadata = {
+  controllers: [],
+  exports: [FileModule],
+  imports: [FileModule],
+  providers: [],
+};
+
+@Module(metadata)
+export class AssetModule extends AbstractRouter {
+  public static readonly path = '/asset';
+
+  public static readonly module = AssetModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/asset/files/file.controller.ts

@@ -0,0 +1,22 @@
+import { Controller, Delete, Inject, Param, Post, UploadedFiles, UseInterceptors } from '@nestjs/common';
+import { AnyFilesInterceptor } from '@nestjs/platform-express';
+import { ApiTags } from '@nestjs/swagger';
+import { FileRepository } from './file.repository';
+
+@Controller()
+@ApiTags('asset')
+export class FileController {
+  @Inject()
+  protected readonly $repository: FileRepository;
+
+  @Post('/')
+  @UseInterceptors(AnyFilesInterceptor())
+  public async files(@UploadedFiles() images: Express.Multer.File[] = []) {
+    return this.$repository.upload(images);
+  }
+
+  @Delete('/:id')
+  public delete(@Param('id') id: string) {
+    return this.$repository.delete(id);
+  }
+}

package/src/modules/asset/files/file.entity.ts

@@ -0,0 +1,24 @@
+import { Prop, Schema } from '@nestjs/mongoose';
+import { Schema as MongoSchema } from 'mongoose';
+import { AbstractEntity } from '../../../abstracts/abstract.entity';
+
+@Schema({ timestamps: true })
+export class FileEntity extends AbstractEntity {
+  @Prop({ type: MongoSchema.Types.String, required: true, unique: true })
+  public name: string;
+
+  @Prop({ type: MongoSchema.Types.String, required: true })
+  public url: string;
+
+  @Prop({ type: MongoSchema.Types.Boolean, default: true })
+  public weak = true;
+
+  @Prop({ type: MongoSchema.Types.String, nullable: true })
+  public description: string;
+
+  @Prop({ type: MongoSchema.Types.String })
+  public type: string;
+
+  @Prop({ type: MongoSchema.Types.Number, required: true, default: 0 })
+  public size = 0;
+}

package/src/modules/asset/files/file.module.ts

@@ -0,0 +1,21 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../../abstracts/abstract.router';
+import { FileController } from './file.controller';
+import { FileRepository } from './file.repository';
+import { FileService } from './file.service';
+
+export const metadata: ModuleMetadata = {
+  imports: [],
+  controllers: [FileController],
+  providers: [FileRepository, FileService],
+  exports: [FileRepository],
+};
+
+@Module(metadata)
+export class FileModule extends AbstractRouter {
+  public static readonly path = '/files';
+
+  public static readonly module = FileModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/asset/files/file.repository.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { writeFileSync } from 'fs';
+import { Model } from 'mongoose';
+import { AbstractRepository } from '../../../abstracts/abstarct.repository';
+import { FileEntity } from './file.entity';
+import { FileSchema } from './file.schema';
+
+@Injectable()
+export class FileRepository extends AbstractRepository<FileEntity> {
+  @InjectModel(FileSchema.name)
+  public readonly $model: Model<FileEntity>;
+
+  public async upload(files: Express.Multer.File[] = []) {
+    const assets: FileEntity[] = [];
+
+    for (const file of files) {
+      const asset: FileEntity = new this.$model();
+
+      const ext = file.originalname.split('.').pop();
+      const name = `${asset._id}.${ext}`;
+      const filePath = `uploads/${name}`;
+
+      asset.url = filePath;
+      asset.name = name;
+      asset.size = file.size;
+      asset.type = file.mimetype;
+
+      assets.push(await this.$model.create(asset));
+
+      writeFileSync(filePath, file.buffer);
+    }
+
+    return Promise.all(assets);
+  }
+
+  public create(partial: Partial<FileEntity>): Promise<FileEntity> {
+    return this.$model.create(partial);
+  }
+
+  public update(id: string, params: unknown): Promise<FileEntity> {
+    return Promise.resolve(undefined);
+  }
+}

package/src/modules/asset/files/file.schema.ts

@@ -0,0 +1,8 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { FileEntity } from './file.entity';
+
+export namespace FileSchema {
+  export const name = 'asset_files';
+
+  export const schema = SchemaFactory.createForClass(FileEntity);
+}

package/src/modules/asset/files/file.service.ts

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class FileService {}