@merkaly/api 0.2.5-4 → 0.2.5-6

package/src/modules/auth/auth.controller.ts

@@ -0,0 +1,57 @@
+import { Controller, Get, Inject, NotAcceptableException, NotFoundException, Put, Req } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import type { Request } from 'express';
+import { Public } from '../../decorators/public.decorator';
+import { DecodedUser, GetUser } from '../../decorators/user.decorator';
+import { OrganizationRepository } from './organizations/organization.repository';
+import { UserRepository } from './users/user.repository';
+
+@Controller('/')
+@ApiTags('auth')
+export class AuthController {
+  @Inject()
+  protected readonly $user: UserRepository;
+
+  @Inject()
+  protected readonly $organization: OrganizationRepository;
+
+  @Put('/token')
+  public token(@GetUser() user: DecodedUser) {
+    return this.$user.upsert(user);
+  }
+
+  @Get('/resolve')
+  @Public()
+  public async resolve(@Req() req: Request) {
+    const list = await this.$organization.find();
+    const { origin, identity } = req.headers;
+
+    if (identity) {
+      return this.$organization.read(String(identity));
+    }
+
+    if (!origin) {
+      throw new NotAcceptableException();
+    }
+
+    const { hostname } = new URL(origin);
+
+    const result = list.find((item) => {
+      const domain = item.metadata?.domain;
+
+      if (!domain) {
+        return false;
+      }
+
+      const { name } = domain;
+
+      return String(name).includes(hostname);
+    });
+
+    if (!result) {
+      throw new NotFoundException('Store Not Found');
+    }
+
+    return result;
+  }
+}

package/src/modules/auth/auth.module.ts

@@ -0,0 +1,20 @@
+import { Module, type ModuleMetadata } from '@nestjs/common';
+import { AuthController } from './auth.controller';
+import { OrganizationModule } from './organizations/organization.module';
+import { UserModule } from './users/user.module';
+
+const metadata: ModuleMetadata = {
+  controllers: [AuthController],
+  exports: [UserModule],
+  imports: [UserModule, OrganizationModule],
+  providers: [],
+};
+
+@Module(metadata)
+export class AuthModule {
+  public static readonly path = '/auth';
+
+  public static readonly module = AuthModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/auth/organizations/organization.controller.ts

@@ -0,0 +1,20 @@
+import { Controller, Get, Inject, Param } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { OrganizationRepository } from './organization.repository';
+
+@Controller('/')
+@ApiTags('auth')
+export class OrganizationController {
+  @Inject()
+  protected readonly $repository: OrganizationRepository;
+
+  @Get('/')
+  public find() {
+    return this.$repository.find();
+  }
+
+  @Get('/:id')
+  public read(@Param('id') id: string) {
+    return this.$repository.read(id);
+  }
+}

package/src/modules/auth/organizations/organization.entity.ts

@@ -0,0 +1,22 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+import { $collection, AbstractEntity } from '../../../abstracts/abstract.entity';
+
+@Collection($collection)
+export class OrganizationEntity extends AbstractEntity {
+  @Prop({ required: true, type: Schema.Types.String, unique: true })
+  public auth0: string;
+
+  @Prop({ required: true, type: Schema.Types.String, unique: true })
+  public name: string;
+
+  @Prop({ required: true, type: Schema.Types.String })
+  public displayName: string;
+
+  @Prop({ required: true, type: Schema.Types.Mixed })
+  public metadata: Record<string, any>;
+
+  @Prop({ required: true, type: Schema.Types.String })
+  public logoUrl: string;
+}

package/src/modules/auth/organizations/organization.module.ts

@@ -0,0 +1,21 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../../abstracts/abstract.router';
+import { Auth0Service } from '../../../services/auth0.service';
+import { OrganizationController } from './organization.controller';
+import { OrganizationRepository } from './organization.repository';
+
+export const metadata: ModuleMetadata = {
+  controllers: [OrganizationController],
+  exports: [OrganizationRepository],
+  imports: [],
+  providers: [OrganizationRepository, Auth0Service],
+};
+
+@Module(metadata)
+export class OrganizationModule extends AbstractRouter {
+  public static readonly module = OrganizationModule;
+
+  public static readonly path = '/organization';
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/auth/organizations/organization.repository.ts

@@ -0,0 +1,16 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Auth0Service } from '../../../services/auth0.service';
+
+@Injectable()
+export class OrganizationRepository {
+  @Inject()
+  public readonly $auth0: Auth0Service;
+
+  public find() {
+    return this.$auth0.organizations.find();
+  }
+
+  public read(id: string) {
+    return this.$auth0.organizations.read(id);
+  }
+}

package/src/modules/auth/organizations/organization.schema.ts

@@ -0,0 +1,8 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { OrganizationEntity } from './organization.entity';
+
+export namespace OrganizationSchema {
+  export const name = 'auth_organization';
+
+  export const schema = SchemaFactory.createForClass(OrganizationEntity);
+}

package/src/modules/auth/users/user.controller.ts

@@ -0,0 +1,23 @@
+import { Controller, Get, Inject, Param, Query } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { AbstractController } from '../../../abstracts/abstract.controller';
+import { FindValidator, IdMongoValidator, ReadValidator } from '../../../abstracts/abstract.validator';
+import { UserEntity } from './user.entity';
+import { UserRepository } from './user.repository';
+
+@Controller('/')
+@ApiTags('auth')
+export class UserController extends AbstractController {
+  @Inject()
+  protected readonly $repository: UserRepository;
+
+  @Get('/')
+  public find(@Query() validator: FindValidator<UserEntity>) {
+    return this.$repository.find(validator);
+  }
+
+  @Get('/:id')
+  public read(@Param() { id }: IdMongoValidator, @Query() validator?: ReadValidator) {
+    return this.$repository.read(id, validator);
+  }
+}

package/src/modules/auth/users/user.entity.ts

@@ -0,0 +1,25 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+import { $collection, AbstractEntity } from '../../../abstracts/abstract.entity';
+
+@Collection($collection)
+export class UserEntity extends AbstractEntity {
+  @Prop({ required: true, type: Schema.Types.String, unique: true })
+  public auth0: string;
+
+  @Prop({ required: true, type: Schema.Types.String, unique: true })
+  public email: string;
+
+  @Prop({ required: true, type: Schema.Types.String })
+  public name: string;
+
+  @Prop({ required: true, type: Schema.Types.String })
+  public picture: string;
+
+  @Prop({ required: true, type: Schema.Types.String })
+  public locale: string;
+
+  @Prop({ default: () => new Date(), type: Schema.Types.Date })
+  public lastSeen: Date;
+}

package/src/modules/auth/users/user.module.ts

@@ -0,0 +1,20 @@
+import { Module, type ModuleMetadata } from '@nestjs/common';
+import { Auth0Service } from '../../../services/auth0.service';
+import { UserController } from './user.controller';
+import { UserRepository } from './user.repository';
+
+const metadata: ModuleMetadata = {
+  controllers: [UserController],
+  exports: [UserRepository],
+  imports: [],
+  providers: [UserRepository, Auth0Service],
+};
+
+@Module(metadata)
+export class UserModule {
+  public static readonly path = '/users';
+
+  public static readonly module = UserModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/auth/users/user.repository.ts

@@ -0,0 +1,79 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { AbstractRepository } from '../../../abstracts/abstarct.repository';
+import { DecodedUser } from '../../../decorators/user.decorator';
+import { UserEntity } from './user.entity';
+import { UserSchema } from './user.schema';
+import { CreateUserValidator, UpdatedUserValidator } from './user.validator';
+
+@Injectable()
+export class UserRepository extends AbstractRepository<UserEntity> {
+  @InjectModel(UserSchema.name)
+  protected readonly $model: Model<UserEntity>;
+
+  public async create(validator: CreateUserValidator) {
+    const user = new this.$model();
+
+    user.auth0 = validator.auth0;
+    user.name = validator.name;
+    user.email = validator.email.toLowerCase();
+    user.picture = validator.picture;
+    user.locale = validator.locale;
+
+    await user.save();
+
+    return user;
+  }
+
+  public async update(id: string, validator: UpdatedUserValidator) {
+    const user = await this.read(id);
+
+    user.name = validator.name || user.name;
+    user.picture = validator.picture || user.picture;
+    user.locale = validator.locale || user.locale;
+    user.lastSeen = new Date();
+
+    await user.save();
+
+    return user;
+  }
+
+  public async upsert(decodedUser: DecodedUser) {
+    let foundedUser: UserEntity;
+
+    try {
+      foundedUser = await this.readByAuth0(decodedUser.sub);
+    } catch (e: unknown) {}
+
+    if (!foundedUser) {
+      const validator: CreateUserValidator = {
+        auth0: decodedUser.sub,
+        email: decodedUser.email,
+        locale: decodedUser.locale,
+        name: decodedUser.name,
+        picture: decodedUser.picture,
+      };
+
+      return this.create(validator);
+    }
+
+    const validator: UpdatedUserValidator = {
+      locale: decodedUser.locale,
+      name: decodedUser.name,
+      picture: decodedUser.picture,
+    };
+
+    return this.update(foundedUser._id, validator);
+  }
+
+  public async readByAuth0(auth0: string): Promise<UserEntity> {
+    const user = await this.$model.findOne({ auth0 });
+
+    if (!user) {
+      throw new NotFoundException();
+    }
+
+    return user;
+  }
+}

package/src/modules/auth/users/user.schema.ts

@@ -0,0 +1,8 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { UserEntity } from './user.entity';
+
+export namespace UserSchema {
+  export const name = 'auth_users';
+
+  export const schema = SchemaFactory.createForClass(UserEntity);
+}

package/src/modules/auth/users/user.validator.ts

@@ -0,0 +1,32 @@
+import { IsEmail, IsLocale, IsOptional, IsString } from 'class-validator';
+
+export class CreateUserValidator {
+  @IsString()
+  public auth0: string;
+
+  @IsString()
+  public name: string;
+
+  @IsEmail()
+  public email: string;
+
+  @IsString()
+  public picture: string;
+
+  @IsLocale()
+  public locale: string;
+}
+
+export class UpdatedUserValidator {
+  @IsString()
+  @IsOptional()
+  public name?: string;
+
+  @IsString()
+  @IsOptional()
+  public picture?: string;
+
+  @IsLocale()
+  @IsOptional()
+  public locale?: string;
+}

package/src/modules/command.module.ts

@@ -0,0 +1,15 @@
+import { DynamicModule } from '@nestjs/common';
+import { ConsoleModule } from 'nestjs-console';
+import { router } from '../app.module';
+import { SeedCommand } from '../commands/seed.command';
+
+export class CommandsModule {
+  public static register(): DynamicModule {
+    return {
+      global: true,
+      imports: [ConsoleModule, ...router],
+      module: CommandsModule,
+      providers: [SeedCommand],
+    };
+  }
+}

package/src/modules/global.module.ts

@@ -0,0 +1,46 @@
+import { DynamicModule } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { Auth0Service } from '../services/auth0.service';
+import { MongoService } from '../services/mongo.service';
+import { FileSchema } from './asset/files/file.schema';
+import { OrganizationSchema } from './auth/organizations/organization.schema';
+import { UserSchema } from './auth/users/user.schema';
+import { BrandSchema } from './inventory/brands/brand.schema';
+import { CategorySchema } from './inventory/categories/category.schema';
+import { ComplementSchema } from './inventory/complements/complement.schema';
+import { ProductSchema } from './inventory/products/product.schema';
+import { CustomerSchema } from './sale/customers/customer.schema';
+import { OrderSchema } from './sale/orders/order.schema';
+import { PaymentSchema } from './sale/payments/payment.schema';
+
+const mongooseEntities = MongooseModule.forFeature([
+  // Assets
+  FileSchema,
+
+  // Auth
+  UserSchema,
+  OrganizationSchema,
+
+  // Sale
+  OrderSchema,
+  PaymentSchema,
+  CustomerSchema,
+
+  // Inventory
+  BrandSchema,
+  ProductSchema,
+  CategorySchema,
+  ComplementSchema,
+]);
+
+export class GlobalModule {
+  public static register(): DynamicModule {
+    return {
+      exports: [mongooseEntities, Auth0Service],
+      global: true,
+      imports: [MongooseModule.forRootAsync({ useClass: MongoService }), mongooseEntities],
+      module: GlobalModule,
+      providers: [Auth0Service],
+    };
+  }
+}

package/src/modules/inventory/brands/brand.controller.ts

@@ -0,0 +1,44 @@
+import { Body, Controller, Delete, Get, HttpCode, HttpStatus, Inject, Param, Patch, Post, Query } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { AbstractController } from '../../../abstracts/abstract.controller';
+import { FindValidator, IdMongoValidator, ReadValidator } from '../../../abstracts/abstract.validator';
+import { Public } from '../../../decorators/public.decorator';
+import { BrandEntity } from './brand.entity';
+import { BrandRepository } from './brand.repository';
+import { CreateBrandValidator, UpdateBrandValidator } from './brand.validator';
+
+@Controller()
+@ApiTags('inventory')
+export class BrandController extends AbstractController {
+  @Inject()
+  protected readonly $repository: BrandRepository;
+
+  @Get('/')
+  @Public()
+  public async find(@Query() validator: FindValidator<BrandEntity>) {
+    return super.find(validator);
+  }
+
+  @Get('/:id')
+  @Public()
+  public async read(@Param() { id }: IdMongoValidator, @Query() validator?: ReadValidator) {
+    return this.$repository.read(id, validator);
+  }
+
+  @Post('/')
+  @HttpCode(HttpStatus.CREATED)
+  public async create(@Body() validator: CreateBrandValidator) {
+    return this.$repository.create(validator);
+  }
+
+  @Patch('/:id')
+  public async update(@Param('id') id: string, @Body() validator: UpdateBrandValidator) {
+    return this.$repository.update(id, validator);
+  }
+
+  @Delete('/:id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  public delete(@Param() { id }: IdMongoValidator) {
+    return this.$repository.delete(id);
+  }
+}

package/src/modules/inventory/brands/brand.entity.ts

@@ -0,0 +1,20 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema as MongoSchema } from 'mongoose';
+import { $collection, AbstractEntity } from '../../../abstracts/abstract.entity';
+
+@Collection($collection)
+export class BrandEntity extends AbstractEntity {
+  @Prop({
+    type: MongoSchema.Types.String,
+    required: true,
+    unique: true,
+    length: 32,
+  })
+  public name: string;
+
+  @Prop({ type: MongoSchema.Types.String })
+  public description: string;
+
+  public readonly picture: string;
+}

package/src/modules/inventory/brands/brand.module.ts

@@ -0,0 +1,20 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../../abstracts/abstract.router';
+import { BrandController } from './brand.controller';
+import { BrandRepository } from './brand.repository';
+
+export const metadata: ModuleMetadata = {
+  controllers: [BrandController],
+  exports: [BrandRepository],
+  imports: [],
+  providers: [BrandRepository],
+};
+
+@Module(metadata)
+export class BrandModule extends AbstractRouter {
+  public static readonly path = '/brands';
+
+  public static readonly module = BrandModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/inventory/brands/brand.repository.ts

@@ -0,0 +1,40 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { AbstractRepository } from '../../../abstracts/abstarct.repository';
+import { BrandEntity } from './brand.entity';
+import { BrandSchema } from './brand.schema';
+import { CreateBrandValidator, UpdateBrandValidator } from './brand.validator';
+
+@Injectable()
+export class BrandRepository extends AbstractRepository<BrandEntity> {
+  @InjectModel(BrandSchema.name)
+  protected readonly $model: Model<BrandEntity>;
+
+  public async create(validator: CreateBrandValidator) {
+    const brand = new this.$model();
+
+    brand.name = validator.name;
+    brand.description = validator.description;
+
+    await brand.save();
+
+    return brand;
+  }
+
+  public async update(id: string, validator: UpdateBrandValidator) {
+    const brand = await this.read(id);
+
+    if (validator.name) {
+      brand.name = validator.name;
+    }
+
+    if (validator.description) {
+      brand.description = validator.description;
+    }
+
+    await brand.save();
+
+    return brand;
+  }
+}

package/src/modules/inventory/brands/brand.schema.ts

@@ -0,0 +1,8 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { BrandEntity } from './brand.entity';
+
+export namespace BrandSchema {
+  export const name = 'inventory_brands';
+
+  export const schema = SchemaFactory.createForClass(BrandEntity);
+}

package/src/modules/inventory/brands/brand.validator.ts

@@ -0,0 +1,31 @@
+import { IsMongoId, IsOptional, IsString, Length } from 'class-validator';
+import { AbstractValidator } from '../../../abstracts/abstract.validator';
+
+export class CreateBrandValidator extends AbstractValidator {
+  @IsString()
+  @Length(2, 32)
+  public name: string;
+
+  @IsString()
+  @IsOptional()
+  public description?: string;
+
+  @IsMongoId()
+  @IsOptional()
+  public image: string;
+}
+
+export class UpdateBrandValidator extends AbstractValidator {
+  @IsString()
+  @Length(2, 32)
+  @IsOptional()
+  public name?: string;
+
+  @IsString()
+  @IsOptional()
+  public description?: string;
+
+  @IsMongoId()
+  @IsOptional()
+  public image: string;
+}

package/src/modules/inventory/categories/category.controller.ts

@@ -0,0 +1,42 @@
+import { Body, Controller, Delete, Get, Inject, Param, Patch, Post, Query } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { AbstractController } from '../../../abstracts/abstract.controller';
+import { FindValidator, IdMongoValidator, ReadValidator } from '../../../abstracts/abstract.validator';
+import { Public } from '../../../decorators/public.decorator';
+import { CategoryEntity } from './category.entity';
+import { CategoryRepository } from './category.repository';
+import { CreateCategoryValidator, UpdateCategoryValidator } from './category.validator';
+
+@Controller('')
+@ApiTags('inventory')
+export class CategoryController extends AbstractController {
+  @Inject()
+  protected readonly $repository: CategoryRepository;
+
+  @Public()
+  @Get('/')
+  public find(@Query() validator: FindValidator<CategoryEntity>) {
+    return this.$repository.find(validator);
+  }
+
+  @Public()
+  @Get('/:id')
+  public read(@Param() { id }: IdMongoValidator, @Query() validator?: ReadValidator) {
+    return this.$repository.read(id, validator);
+  }
+
+  @Post('/')
+  public create(@Body() validator: CreateCategoryValidator) {
+    return this.$repository.create(validator);
+  }
+
+  @Patch('/:id')
+  public update(@Param('id') id: string, @Body() validator: UpdateCategoryValidator) {
+    return this.$repository.update(id, validator);
+  }
+
+  @Delete('/:id')
+  public remove(@Param('id') id: string) {
+    return this.$repository.delete(id);
+  }
+}

package/src/modules/inventory/categories/category.entity.ts

@@ -0,0 +1,15 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+import { $collection, AbstractEntity } from '../../../abstracts/abstract.entity';
+
+@Collection($collection)
+export class CategoryEntity extends AbstractEntity {
+  @Prop({ required: true, type: Schema.Types.String, unique: true })
+  public name: string;
+
+  @Prop({ type: Schema.Types.String })
+  public description: string;
+
+  @Prop({ type: Schema.Types.String })
+  public picture: string;
+}