@merkaly/api 0.2.5-6 → 0.2.5-7

package/.prettierrc

@@ -1,5 +0,0 @@
-{
-  "printWidth": 120,
-  "singleQuote": true,
-  "trailingComma": "all"
-}

package/app.ts

@@ -1,11 +0,0 @@
-import { INestApplication, ValidationPipe } from '@nestjs/common';
-import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
-
-export function createNestApp(app: INestApplication) {
-  const config = new DocumentBuilder().build();
-
-  const document = SwaggerModule.createDocument(app, config);
-  SwaggerModule.setup('/', app, document);
-
-  return app.useGlobalPipes(new ValidationPipe({ whitelist: true, transform: true }));
-}

package/authCertificate.pem

@@ -1,19 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDAzCCAeugAwIBAgIJHHJE5ykX1iXdMA0GCSqGSIb3DQEBCwUAMB8xHTAbBgNV
-BAMTFG1lcmthbHkudXMuYXV0aDAuY29tMB4XDTIwMTEwNTIwMzY1MVoXDTM0MDcx
-NTIwMzY1MVowHzEdMBsGA1UEAxMUbWVya2FseS51cy5hdXRoMC5jb20wggEiMA0G
-CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCcZcJZ3OxWI+Gxp9a5GGY9035+FulG
-8+EWuIvRMCL1cUT5RMfib5/I66T3wipHw8t/yKO/Rjdx8uRUTZE94OuCbSI/qK7R
-bQHdpvUw9B9W3lwwyJ+AjklDOYS91apJcn4g/poMQ5G9vdQsP6u1P176Bjkx0pxH
-qx3XBbPf61IIb7Jv1yiyc6sQDHyR3ZUQPrDgjNgu30pTOxjQIOnnzSoCn/n0QjWA
-O9JcMyO2kI6+dNJnWBfs7BhCz4fPJA6IfU57vaq50sSH99/DEbc7SDJh+Ty1z4iW
-dX/4h+6GNtIUqBh35+fz606tN1x+RSET+/oDAHI78+KB8AkC4rTmdIBRAgMBAAGj
-QjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFJ8n4kEQjFyA504p+iJj2zr7
-vpiPMA4GA1UdDwEB/wQEAwIChDANBgkqhkiG9w0BAQsFAAOCAQEAGHMjDFX1myDL
-eHqlwxQTYJk1+sc68rfUxB70a/MU5OMZ8z53YTDbkeOhlsmrIuDMhIt3ZVHizWka
-nITpKzU7cuRLJEyozps2bZyX/8QaoKwTkqV5IUV4W9FoL8K8A/zTOKp2H/T8WiSu
-5b29cltqXYrsWj2La3Fm0uaqupfweZgwLN/z/wRg+k7ZzAaHdAehZ9DW2mUkgqHg
-5z6f4SOvTvyTAcphG4tqeFk4YjV4OQcBSuDsnLxs1mQpQ12eA2gmoRQ3W70zRtdI
-1UzqunyLrz5Pt59fitaSeXfthfFNKW67zSfGfJhoqngIuxG/+UaAaDRx/LBJjO0O
-4/ztS0AZ/A==
------END CERTIFICATE-----

package/nest-cli.json

@@ -1,8 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/nest-cli",
-  "collection": "@nestjs/schematics",
-  "sourceRoot": "src",
-  "compilerOptions": {
-    "deleteOutDir": true
-  }
-}

package/src/abstracts/abstarct.repository.ts

@@ -1,62 +0,0 @@
-import { GoneException, Logger, NotFoundException } from '@nestjs/common';
-import { FilterQuery, HydratedDocument, Model, PopulateOptions } from 'mongoose';
-import { AbstractEntity } from './abstract.entity';
-import { FindResult, FindValidator, ReadValidator } from './abstract.validator';
-
-export abstract class AbstractRepository<E extends AbstractEntity = AbstractEntity> {
-  protected abstract $model: Model<AbstractEntity>;
-
-  public find(validator: FindValidator<E> = {}, ...params: unknown[]): Promise<FindResult<E>> {
-    const filters: FilterQuery<E> = { deletedAt: null, ...validator.filters };
-
-    const query = this.$model.find<E>(filters);
-    const counter = this.$model.count(filters);
-
-    const skip = validator.page * validator.limit - validator.limit;
-
-    !validator.sort?.createdAt && (validator.sort = { ...validator.sort, createdAt: 'desc' });
-
-    validator.page && query.skip(skip);
-    validator.sort && query.sort(validator.sort);
-
-    validator.join && query.populate(validator.join as (PopulateOptions | string)[]);
-
-    validator.limit && query.limit(validator.limit);
-
-    return Promise.all([counter.count(), query.exec()]).then(([total, items]) => ({
-      items,
-      page: validator.page,
-      total,
-    }));
-  }
-
-  public async read(id: string, validator?: ReadValidator) {
-    const entity = await this.$model.findById<HydratedDocument<E>>(id);
-
-    if (!entity) {
-      throw new NotFoundException();
-    }
-
-    if (entity.deletedAt) {
-      throw new GoneException();
-    }
-
-    if (validator?.join) {
-      await entity
-        .populate(validator.join as [])
-        .catch(() => Logger.warn(`Issue populating fields with id: ${entity._id}`));
-    }
-
-    return entity;
-  }
-
-  public abstract create(validator: unknown, ...params: unknown[]): any;
-
-  public abstract update(id: string, validator: unknown): any;
-
-  public async delete(id: string) {
-    await this.read(id);
-
-    return this.$model.deleteOne({ _id: id });
-  }
-}

package/src/abstracts/abstract.controller.ts

@@ -1,18 +0,0 @@
-import { AbstractRepository } from './abstarct.repository';
-import { IdMongoValidator, ReadValidator } from './abstract.validator';
-
-export abstract class AbstractController {
-  protected abstract readonly $repository: AbstractRepository;
-
-  protected find?(...params: unknown[]) {
-    return this.$repository.find();
-  }
-
-  protected read?({ id }: IdMongoValidator, validator?: ReadValidator) {
-    return this.$repository.read(id, validator);
-  }
-
-  protected delete?({ id }: IdMongoValidator) {
-    return this.$repository.delete(id);
-  }
-}

package/src/abstracts/abstract.entity.ts

@@ -1,22 +0,0 @@
-import { Prop } from '@nestjs/mongoose';
-import { Schema as MongoSchema } from 'mongoose';
-
-export const $collection = {
-  timestamps: true,
-  toJSON: { versionKey: false, virtuals: true },
-};
-
-export type MaybeEntity<T extends AbstractEntity> = T;
-
-export abstract class AbstractEntity {
-  public readonly _id = String();
-
-  @Prop({ type: MongoSchema.Types.Date })
-  public readonly createdAt: Date;
-
-  @Prop({ type: MongoSchema.Types.Date })
-  public readonly updatedAt?: Date = null;
-
-  @Prop({ default: null, type: MongoSchema.Types.Date })
-  public readonly deletedAt?: Date = null;
-}

package/src/abstracts/abstract.router.ts

@@ -1,7 +0,0 @@
-export abstract class AbstractRouter {
-  public static readonly path: string;
-
-  public static readonly module: typeof AbstractRouter;
-
-  public static readonly children? = [];
-}

package/src/abstracts/abstract.validator.ts

@@ -1,61 +0,0 @@
-import { Transform } from 'class-transformer';
-import { IsInt, IsMongoId, isObject, IsOptional } from 'class-validator';
-import { FilterQuery, PopulateOptions, SortOrder } from 'mongoose';
-import { AbstractEntity } from './abstract.entity';
-
-export abstract class AbstractValidator {}
-
-export type FindResult<I> = { items: I[]; page: number; total: number };
-
-export type KeyOfType<T, V> = keyof {
-  [P in keyof T as T[P] extends V ? P : string]: any;
-};
-
-export class IdMongoValidator {
-  @IsMongoId()
-  public id: string;
-}
-
-export class ReadValidator<E = AbstractEntity> extends AbstractValidator {
-  @Transform(({ value }) => {
-    try {
-      return JSON.parse(value);
-    } catch (e: unknown) {
-      return value;
-    }
-  })
-  @IsOptional()
-  public join?: (PopulateOptions | KeyOfType<E, AbstractEntity | AbstractEntity[]>)[] = [];
-}
-
-export class FindValidator<E = AbstractEntity> extends ReadValidator<E> {
-  @Transform(({ value }) => (value ? Number(value) : 10))
-  @IsInt()
-  @IsOptional()
-  public limit? = 10;
-
-  @Transform(({ value }) => (value ? Number(value) : 1))
-  @IsInt()
-  @IsOptional()
-  public page? = 1;
-
-  @Transform(({ value }) => {
-    if (isObject(value)) {
-      return value;
-    }
-
-    return value && JSON.parse(value);
-  })
-  @IsOptional()
-  public sort?: Partial<Record<keyof E, SortOrder>> = {};
-
-  @Transform(({ value }) => {
-    if (isObject(value)) {
-      return value;
-    }
-
-    return value && JSON.parse(value);
-  })
-  @IsOptional()
-  public filters?: FilterQuery<E> = {};
-}

package/src/app.config.ts

@@ -1,59 +0,0 @@
-import { config } from 'dotenv';
-import { readFileSync } from 'fs';
-import { join } from 'path';
-import * as process from 'process';
-
-config();
-
-export abstract class AppConfig {
-  public static get SENTRY() {
-    return {
-      dsn: process.env.SENTRY_DSN,
-      debug: process.env.NODE_ENV !== 'production',
-      environment: process.env.NODE_ENV,
-    };
-  }
-
-  public static get SERVER() {
-    return {
-      description: String(process.env.npm_package_description),
-      isDEV: process.env.NODE_ENV !== 'production',
-      name: String(process.env.npm_package_name),
-      port: Number(process.env.PORT || 6500),
-      version: String(process.env.npm_package_version),
-    };
-  }
-
-  public static get MONGO() {
-    const { MONGO_PASSWORD, MONGO_USER, MONGO_HOST } = process.env;
-
-    return {
-      host: MONGO_HOST,
-      user: MONGO_USER,
-      pass: MONGO_PASSWORD,
-      retryWrites: true,
-      w: 'majority',
-    };
-  }
-
-  public static get STORAGE() {
-    const serviceAccount = readFileSync(join(process.cwd(), '/serviceAccount.json'));
-    const credentials = JSON.parse(serviceAccount.toString());
-
-    return {
-      projectId: 'api-merkaly-io',
-      bucketName: process.env.GCP_BUCKET_NAME,
-      serviceAccount: credentials,
-    };
-  }
-
-  public static get AUTH0() {
-    const domain = 'merkaly.us.auth0.com';
-    const audience = `https://${domain}/api/v2/`;
-    const client = 'eApUjfHoWlMPcTUuU1lqvE517q0KzTh9';
-    const secret = String(process.env.AUTH0_CLIENT_SECRET);
-    const certificate = process.env.AUTH_CERTIFICATE || readFileSync(join(process.cwd(), '/authCertificate.pem'));
-
-    return { domain, audience, client, secret, certificate };
-  }
-}

package/src/app.console.ts

@@ -1,24 +0,0 @@
-import { BootstrapConsole } from 'nestjs-console';
-import process from 'process';
-import { AppModule } from './app.module';
-
-const bootstrap = new BootstrapConsole({
-  module: AppModule,
-  useDecorators: true,
-});
-
-bootstrap.init().then(async (app) => {
-  try {
-    await app.init();
-
-    await bootstrap.boot();
-
-    await app.close();
-  } catch (e) {
-    console.error(e);
-
-    await app.close();
-
-    process.exit(1);
-  }
-});

package/src/app.guard.ts

@@ -1,39 +0,0 @@
-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') {
-  public isPublic = false;
-  @Inject()
-  private reflector: Reflector;
-
-  public async canActivate(context: ExecutionContext): Promise<any> {
-    this.isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
-      context.getHandler(),
-      context.getClass(),
-    ]);
-
-    return super.canActivate(context);
-  }
-
-  public handleRequest(err: Record<string, unknown>, user: DecodedUser): any {
-    if (err) {
-      throw err;
-    }
-
-    if (!user && !this.isPublic) {
-      throw new UnauthorizedException();
-    }
-
-    return user || undefined;
-  }
-}

package/src/app.module.ts

@@ -1,54 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,263 +0,0 @@
-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);
-  }
-}