@merkaly/api 0.2.5-4 → 0.2.5-6

package/src/modules/sale/orders/validators/payment.validator.ts

@@ -0,0 +1,44 @@
+import { Type } from 'class-transformer';
+import {
+  IsNotEmpty,
+  IsNumberString,
+  IsOptional,
+  IsPositive,
+  IsString,
+  Length,
+  Max,
+  Min,
+  ValidateNested,
+} from 'class-validator';
+
+export class PaymentCardValidator {
+  @IsString()
+  @IsNotEmpty()
+  public number = String();
+
+  @IsString()
+  @IsNotEmpty()
+  public name = String();
+
+  @IsPositive()
+  @Min(1)
+  @Max(12)
+  public expMonth: number;
+
+  @IsPositive()
+  @Min(new Date().getFullYear())
+  @IsNotEmpty()
+  public expYear: number;
+
+  @IsNumberString()
+  @Length(3, 4)
+  @IsNotEmpty()
+  public cvv = String();
+}
+
+export class PaymentValidator {
+  @ValidateNested()
+  @Type(() => PaymentCardValidator)
+  @IsOptional()
+  public card = new PaymentCardValidator();
+}

package/src/modules/sale/orders/validators/shipping.validator.ts

@@ -0,0 +1,14 @@
+import { ShippingType } from '../../payments/enums/shipping.type';
+import { AddressValidator } from './address.validator';
+
+export class ShippingValidator {
+  public address = new AddressValidator();
+
+  public type: ShippingType;
+
+  public name = String();
+
+  public phone = String();
+
+  public email = String();
+}

package/src/modules/sale/payments/entities/status.entity.ts

@@ -0,0 +1,17 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+import type { MaybeEntity } from '../../../../abstracts/abstract.entity';
+import { UserEntity } from '../../../auth/users/user.entity';
+import { UserSchema } from '../../../auth/users/user.schema';
+import { PaymentStatus } from '../enums/payment.status';
+
+export class StatusEntity {
+  @Prop({ enum: PaymentStatus, required: true, type: Schema.Types.String })
+  public name: PaymentStatus;
+
+  @Prop({ ref: UserSchema.name, required: true, type: Schema.Types.ObjectId })
+  public user: MaybeEntity<UserEntity>;
+
+  @Prop({ default: () => new Date(), type: Schema.Types.Date })
+  public date: Date;
+}

package/src/modules/sale/payments/enums/billing.type.ts

@@ -0,0 +1,6 @@
+export enum BillingType {
+  PIX = 'PIX',
+  BOLETO = 'BOLETO',
+  CARD = 'CARD',
+  TRANSFER = 'TRANSFER',
+}

package/src/modules/sale/payments/enums/payment.status.ts

@@ -0,0 +1,7 @@
+export enum PaymentStatus {
+  UNPAID = 'UNPAID',
+  WAITING = 'WAITING',
+  PAID = 'PAID',
+  REFUNDED = 'REFUNDED',
+  CANCELLED = 'CANCELLED',
+}

package/src/modules/sale/payments/enums/shipping.type.ts

@@ -0,0 +1,4 @@
+export enum ShippingType {
+  RETIRE = 'RETIRE',
+  DELIVERY = 'DELIVERY',
+}

package/src/modules/sale/payments/payment.controller.ts

@@ -0,0 +1,45 @@
+import { Body, Controller, Delete, Get, Inject, Param, Patch, Query } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { AbstractController } from '../../../abstracts/abstract.controller';
+import { FindValidator, IdMongoValidator, ReadValidator } from '../../../abstracts/abstract.validator';
+import { GetUser } from '../../../decorators/user.decorator';
+import { UserRepository } from '../../auth/users/user.repository';
+import { PaymentEntity } from './payment.entity';
+import { PaymentRepository } from './payment.repository';
+import { UpdatePaymentStatusValidator, UpdatePaymentValidator } from './payment.validator';
+
+@Controller('/')
+@ApiTags('sales')
+export class PaymentController extends AbstractController {
+  @Inject()
+  protected readonly $repository: PaymentRepository;
+
+  @Inject()
+  protected readonly $userRepository: UserRepository;
+
+  @Get('/')
+  public find(@Query() validator: FindValidator<PaymentEntity>) {
+    return this.$repository.find(validator);
+  }
+
+  @Get('/:id')
+  public read(@Param() { id }: IdMongoValidator, @Query() validator?: ReadValidator) {
+    return this.$repository.read(id, validator);
+  }
+
+  @Delete('/:id')
+  public delete(@Param() { id }: IdMongoValidator) {
+    return this.$repository.delete(id);
+  }
+
+  @Patch('/:id/status/:type')
+  public async updateStatus(
+    @Param() { id, type }: UpdatePaymentStatusValidator,
+    @Body() validator: UpdatePaymentValidator,
+    @GetUser('sub') sub: string,
+  ) {
+    const user = await this.$userRepository.readByAuth0(sub);
+
+    return this.$repository.updateStatus(id, type, user);
+  }
+}

package/src/modules/sale/payments/payment.entity.ts

@@ -0,0 +1,25 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+import { $collection, AbstractEntity } from '../../../abstracts/abstract.entity';
+import { OrderEntity } from '../orders/order.entity';
+import { StatusEntity } from './entities/status.entity';
+import { BillingType } from './enums/billing.type';
+
+@Collection($collection)
+export class PaymentEntity extends AbstractEntity {
+  @Prop({ default: () => [], type: Schema.Types.Array })
+  public status: StatusEntity[] = [];
+
+  @Prop({ required: true, type: Schema.Types.Number })
+  public total: number;
+
+  @Prop({ default: () => 0, type: Schema.Types.Number })
+  public fee = 0;
+
+  @Prop({ enum: BillingType, required: true, type: Schema.Types.String })
+  public type: BillingType;
+
+  public readonly order: OrderEntity;
+
+  public readonly lastStatus: StatusEntity;
+}

package/src/modules/sale/payments/payment.module.ts

@@ -0,0 +1,20 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { UserRepository } from '../../auth/users/user.repository';
+import { PaymentController } from './payment.controller';
+import { PaymentRepository } from './payment.repository';
+
+export const metadata: ModuleMetadata = {
+  controllers: [PaymentController],
+  exports: [PaymentRepository],
+  imports: [],
+  providers: [PaymentRepository, UserRepository],
+};
+
+@Module(metadata)
+export class PaymentModule {
+  public static readonly path = '/payments';
+
+  public static readonly module = PaymentModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/sale/payments/payment.repository.ts

@@ -0,0 +1,57 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { AbstractRepository } from '../../../abstracts/abstarct.repository';
+import { UserEntity } from '../../auth/users/user.entity';
+import { OrderEntity } from '../orders/order.entity';
+import { StatusEntity } from './entities/status.entity';
+import { PaymentStatus } from './enums/payment.status';
+import { PaymentEntity } from './payment.entity';
+import { PaymentSchema } from './payment.schema';
+import { CreatePaymentValidator, UpdatePaymentValidator } from './payment.validator';
+
+@Injectable()
+export class PaymentRepository extends AbstractRepository<PaymentEntity> {
+  @InjectModel(PaymentSchema.name)
+  protected readonly $model: Model<PaymentEntity>;
+
+  public async create(validator: CreatePaymentValidator, order: OrderEntity) {
+    const payment = new this.$model();
+
+    const status = new StatusEntity();
+    status.date = new Date();
+    status.name = PaymentStatus.UNPAID;
+    status.user = validator.user as any;
+    payment.status.push(status);
+
+    payment.type = validator.type;
+    payment.total = order.total;
+
+    await payment.save();
+
+    return payment;
+  }
+
+  public async update(id: string, validator: UpdatePaymentValidator) {
+    const payment = await this.read(id);
+
+    await payment.save();
+
+    return payment;
+  }
+
+  public async updateStatus(id: string, type: PaymentStatus, user: UserEntity) {
+    const payment = await this.read(id);
+
+    const status = new StatusEntity();
+    status.date = new Date();
+    status.name = type;
+    status.user = user;
+
+    payment.status.push(status);
+
+    await payment.save();
+
+    return payment;
+  }
+}

package/src/modules/sale/payments/payment.schema.ts

@@ -0,0 +1,14 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { PaymentEntity } from './payment.entity';
+
+export namespace PaymentSchema {
+  export const name = 'sales_payments';
+
+  export const schema = SchemaFactory.createForClass(PaymentEntity);
+
+  schema.virtual('lastStatus').get(function () {
+    const [first] = this.status.reverse();
+
+    return first;
+  });
+}

package/src/modules/sale/payments/payment.validator.ts

@@ -0,0 +1,32 @@
+import { Type } from 'class-transformer';
+import { IsEnum, IsMongoId, IsNotEmptyObject, IsPositive, ValidateNested } from 'class-validator';
+import { IdMongoValidator } from '../../../abstracts/abstract.validator';
+import { PaymentValidator } from '../orders/validators/payment.validator';
+import { BillingType } from './enums/billing.type';
+import { PaymentStatus } from './enums/payment.status';
+
+export class CreatePaymentValidator {
+  @IsEnum(BillingType)
+  public type: BillingType;
+
+  @IsPositive()
+  public total: number;
+
+  @IsMongoId()
+  public order: string;
+
+  @IsMongoId()
+  public user: string;
+
+  @ValidateNested()
+  @Type(() => PaymentValidator)
+  @IsNotEmptyObject()
+  public payload: PaymentValidator;
+}
+
+export class UpdatePaymentValidator {}
+
+export class UpdatePaymentStatusValidator extends IdMongoValidator {
+  @IsEnum(PaymentStatus)
+  public type: PaymentStatus;
+}

package/src/modules/sale/sale.module.ts

@@ -0,0 +1,20 @@
+import { Module, type ModuleMetadata } from '@nestjs/common';
+import { CustomerModule } from './customers/customer.module';
+import { OrderModule } from './orders/order.module';
+import { PaymentModule } from './payments/payment.module';
+
+export const metadata: ModuleMetadata = {
+  controllers: [],
+  exports: [OrderModule, PaymentModule, CustomerModule],
+  imports: [OrderModule, PaymentModule, CustomerModule],
+  providers: [],
+};
+
+@Module(metadata)
+export class SaleModule {
+  public static readonly path = '/sale';
+
+  public static readonly module = SaleModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/services/auth0.service.ts

@@ -0,0 +1,49 @@
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import type { GetOrganizations200ResponseOneOfInner, ManagementClientOptionsWithClientCredentials } from 'auth0';
+import { ManagementClient } from 'auth0';
+import { AppConfig } from '../app.config';
+
+@Injectable()
+export class Auth0Service implements OnModuleInit {
+  protected $auth0: ManagementClient;
+
+  public get organizations() {
+    const parseOrg = (org: GetOrganizations200ResponseOneOfInner) => {
+      if (!org.metadata) {
+        org.metadata = {};
+      }
+
+      for (const key in org.metadata) {
+        try {
+          org.metadata[key] = JSON.parse(org.metadata[key]);
+        } catch (e: unknown) {}
+      }
+
+      return org;
+    };
+
+    return {
+      find: async () => {
+        const { data } = await this.$auth0.organizations.getAll();
+
+        return data.map(parseOrg);
+      },
+      read: async (id: string) => {
+        const { data } = await this.$auth0.organizations.get({ id });
+
+        return parseOrg(data);
+      },
+    };
+  }
+
+  public async onModuleInit() {
+    const options: ManagementClientOptionsWithClientCredentials = {
+      audience: AppConfig.AUTH0.audience,
+      clientId: AppConfig.AUTH0.client,
+      clientSecret: AppConfig.AUTH0.secret,
+      domain: AppConfig.AUTH0.domain,
+    };
+
+    this.$auth0 = new ManagementClient(options);
+  }
+}

package/src/services/mongo.service.ts

@@ -0,0 +1,52 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+import { MongooseModuleOptions, MongooseOptionsFactory } from '@nestjs/mongoose';
+import { Request } from 'express';
+import { AppConfig } from '../app.config';
+import { MissingIdentityException } from '../exceptions/missing-identity.exception';
+import { Auth0Service } from './auth0.service';
+
+@Injectable()
+export class MongoService implements MongooseOptionsFactory {
+  @Inject(REQUEST)
+  protected readonly $request: Request;
+
+  @Inject()
+  protected readonly $auth0: Auth0Service;
+
+  public static extractIdentityFromRequest(request: Request) {
+    const identity = request.header?.('identity') || request.query['identity'];
+
+    if (!identity && request.path !== '/auth/resolve') {
+      throw new MissingIdentityException();
+    }
+
+    return identity;
+  }
+
+  public async createMongooseOptions(): Promise<MongooseModuleOptions> {
+    const { host, pass, user, retryWrites, w } = AppConfig.MONGO;
+    const uri = `mongodb+srv://${user}:${pass}@${host}`;
+    const [, entrypoint] = process.argv;
+
+    let DSN: URL;
+
+    // if is command running
+    if (entrypoint.endsWith('console.ts')) {
+      const { ORG_ID = 'not_defined_organization' } = process.env;
+
+      DSN = new URL(`${uri}/${ORG_ID}`);
+
+      return { uri: DSN.toString() };
+    }
+
+    const identity = MongoService.extractIdentityFromRequest(this.$request);
+
+    DSN = new URL(`${uri}/${identity}`);
+
+    DSN.searchParams.set('retryWrites', String(retryWrites));
+    DSN.searchParams.set('w', String(w));
+
+    return { uri: DSN.toString() };
+  }
+}

package/test/auth/auth.spec.ts

@@ -0,0 +1,20 @@
+import { INestApplication } from '@nestjs/common';
+import { setupApp } from '../main';
+
+describe('When payment is requested', () => {
+  let app: INestApplication;
+
+  beforeAll(async () => {
+    app = await setupApp();
+
+    await app.init();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  it('If is a lost card', () => {
+    console.log('WORK');
+  });
+});

package/test/main.ts

@@ -0,0 +1,12 @@
+import { Test } from '@nestjs/testing';
+import { type INestApplication } from '@nestjs/common';
+import { type ModuleMetadata } from '@nestjs/common/interfaces/modules/module-metadata.interface';
+import { AppModule } from '../src/app.module';
+import { createNestApp } from '../app';
+
+export async function setupApp(): Promise<INestApplication> {
+  const metadata: ModuleMetadata = { imports: [AppModule] };
+  const module = await Test.createTestingModule(metadata).compile();
+
+  return createNestApp(module.createNestApplication());
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es2017",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false
+  }
+}

package/tsconfig.package.json

@@ -0,0 +1,22 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "target": "es5",
+    "declarationMap": false,
+    "sourceMap": false,
+    "emitDeclarationOnly": false,
+    "declarationDir": null,
+    "noEmitHelpers": false,
+    "outDir": "./.output",
+    "emitDecoratorMetadata": true
+  },
+  "include": [
+    "./src/types.ts",
+    "./src/**/*.entity.ts",
+    "./src/**/*.document.ts",
+    "./src/**/*.fixture.ts",
+    "./src/**/*.exception.ts",
+    "./src/**/*.types.ts",
+    "./src/**/*.validator.ts"
+  ]
+}

package/.output/abstract/abstract.entity.d.ts

@@ -1,9 +0,0 @@
-
-export declare abstract class AbstractEntity {
-    static $index: string;
-    readonly _id: string;
-    id: string;
-    readonly createdAt: Date;
-    readonly updatedAt?: Date;
-    readonly deletedAt?: Date;
-}

package/.output/abstract/abstract.exception.d.ts

@@ -1,11 +0,0 @@
-import { ArgumentsHost, ExceptionFilter, HttpException } from '@nestjs/common';
-import { Request, Response } from 'express';
-import { LoggerService } from '../services/logger.service';
-export declare abstract class AbstractException implements ExceptionFilter {
-    protected readonly $logger: LoggerService;
-    protected request: Request;
-    protected response: Response;
-    protected host: ArgumentsHost;
-    catch(exception: HttpException, host: ArgumentsHost): Response<any, Record<string, any>>;
-    protected abstract handleError(exception: HttpException): HttpException;
-}

package/.output/abstract/abstract.exception.js

@@ -1,53 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractException = void 0;
-var common_1 = require("@nestjs/common");
-var logger_service_1 = require("../services/logger.service");
-var AbstractException = (function () {
-    function AbstractException() {
-    }
-    AbstractException.prototype.catch = function (exception, host) {
-        this.host = host;
-        var ctx = this.host.switchToHttp();
-        this.response = ctx.getResponse();
-        this.request = ctx.getRequest();
-        this.$logger.error(exception);
-        var handledError = this.handleError(exception);
-        if (handledError instanceof common_1.HttpException) {
-            var trace = exception.getResponse().message;
-            this.response.statusMessage = handledError.name
-                .slice(0, -9)
-                .replace(/([A-Z])/g, ' $1')
-                .trim();
-            return this.response
-                .status(handledError.getStatus())
-                .json({
-                statusCode: handledError.getStatus(),
-                message: handledError.message,
-                error: this.response.statusMessage,
-                trace: trace,
-            });
-        }
-        return this.response
-            .status(500)
-            .json(new common_1.InternalServerErrorException(handledError));
-    };
-    __decorate([
-        (0, common_1.Inject)(),
-        __metadata("design:type", logger_service_1.LoggerService)
-    ], AbstractException.prototype, "$logger", void 0);
-    AbstractException = __decorate([
-        (0, common_1.Injectable)()
-    ], AbstractException);
-    return AbstractException;
-}());
-exports.AbstractException = AbstractException;

package/.output/abstract/abstract.fixture.d.ts

@@ -1,4 +0,0 @@
-export declare abstract class AbstractFixture {
-    protected $faker: import("@faker-js/faker").Faker;
-    abstract normal(): any;
-}

package/.output/abstract/abstract.fixture.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractFixture = void 0;
-var faker_1 = require("@faker-js/faker");
-var AbstractFixture = (function () {
-    function AbstractFixture() {
-        this.$faker = faker_1.faker;
-    }
-    return AbstractFixture;
-}());
-exports.AbstractFixture = AbstractFixture;

package/.output/abstract/abstract.validator.d.ts

@@ -1,20 +0,0 @@
-import { FilterQuery, PopulateOptions, SortOrder } from 'mongoose';
-import { AbstractEntity } from './abstract.entity';
-import 'reflect-metadata';
-export interface SearchResults<I> {
-    page: number;
-    total: number;
-    items: I[];
-}
-export declare abstract class AbstractValidator {
-}
-export declare type KeyOfType<T, V> = keyof {
-    [P in keyof T as T[P] extends V ? P : string]: any;
-};
-export declare class FindValidator<E extends AbstractEntity> extends AbstractValidator {
-    limit?: number;
-    page?: number;
-    sort?: Partial<Record<keyof E, SortOrder>>;
-    filters?: FilterQuery<E>;
-    join?: (PopulateOptions | KeyOfType<E, AbstractEntity | AbstractEntity[]>)[];
-}