@merkaly/api 0.2.5-4 → 0.2.5-6

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

@@ -0,0 +1,19 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { CategoryController } from './category.controller';
+import { CategoryRepository } from './category.repository';
+
+export const metadata: ModuleMetadata = {
+  controllers: [CategoryController],
+  exports: [CategoryRepository],
+  imports: [],
+  providers: [CategoryRepository],
+};
+
+@Module(metadata)
+export class CategoryModule {
+  public static readonly path = '/categories';
+
+  public static readonly module = CategoryModule;
+
+  public static readonly children = metadata.imports;
+}

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

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { AbstractRepository } from '../../../abstracts/abstarct.repository';
+import { CategoryEntity } from './category.entity';
+import { CategorySchema } from './category.schema';
+import { CreateCategoryValidator, UpdateCategoryValidator } from './category.validator';
+
+@Injectable()
+export class CategoryRepository extends AbstractRepository<CategoryEntity> {
+  @InjectModel(CategorySchema.name)
+  protected readonly $model: Model<CategoryEntity>;
+
+  public async create(validator: CreateCategoryValidator) {
+    const category = new this.$model();
+
+    category.name = validator.name;
+    category.description = validator.description;
+
+    await category.save();
+
+    return category;
+  }
+
+  public async update(id: string, validator: UpdateCategoryValidator) {
+    const category = await this.read(id);
+
+    category.name = validator.name || category.name;
+    category.description = validator.description || category.description;
+
+    await category.save();
+    return category;
+  }
+}

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

@@ -0,0 +1,8 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { CategoryEntity } from './category.entity';
+
+export namespace CategorySchema {
+  export const name = 'inventory_categories';
+
+  export const schema = SchemaFactory.createForClass(CategoryEntity);
+}

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

@@ -0,0 +1,20 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class CreateCategoryValidator {
+  @IsString()
+  public name: string;
+
+  @IsString()
+  @IsOptional()
+  public description?: string;
+}
+
+export class UpdateCategoryValidator {
+  @IsString()
+  @IsOptional()
+  public name: string;
+
+  @IsString()
+  @IsOptional()
+  public description?: string;
+}

package/src/modules/inventory/complements/complement.controller.ts

@@ -0,0 +1,41 @@
+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 { IdMongoValidator, ReadValidator } from '../../../abstracts/abstract.validator';
+import { Public } from '../../../decorators/public.decorator';
+import { ComplementRepository } from './complement.repository';
+import { CreateComplementValidator, UpdateComplementValidator } from './complement.validator';
+
+@Controller('/')
+@ApiTags('inventory')
+export class ComplementController extends AbstractController {
+  @Inject()
+  protected readonly $repository: ComplementRepository;
+
+  @Public()
+  @Get('/')
+  public find() {
+    return this.$repository.find();
+  }
+
+  @Public()
+  @Get('/:id')
+  public read(@Param() { id }: IdMongoValidator, @Query() validator?: ReadValidator) {
+    return this.$repository.read(id, validator);
+  }
+
+  @Post('/')
+  public create(@Body() validator: CreateComplementValidator) {
+    return this.$repository.create(validator);
+  }
+
+  @Patch('/:id')
+  public update(@Param() { id }: IdMongoValidator, @Body() validator: UpdateComplementValidator) {
+    return this.$repository.update(id, validator);
+  }
+
+  @Delete('/:id')
+  public delete(@Param() { id }: IdMongoValidator) {
+    return this.$repository.delete(id);
+  }
+}

package/src/modules/inventory/complements/complement.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 ComplementEntity extends AbstractEntity {
+  @Prop({ required: true, type: Schema.Types.String, unique: true })
+  public name: string;
+
+  @Prop({ type: Schema.Types.String })
+  public description: string;
+
+  @Prop({ default: () => 0, type: Schema.Types.Number })
+  public price: number;
+}

package/src/modules/inventory/complements/complement.module.ts

@@ -0,0 +1,19 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { ComplementController } from './complement.controller';
+import { ComplementRepository } from './complement.repository';
+
+export const metadata: ModuleMetadata = {
+  controllers: [ComplementController],
+  exports: [ComplementRepository],
+  imports: [],
+  providers: [ComplementRepository],
+};
+
+@Module(metadata)
+export class ComplementModule {
+  public static readonly path = '/complements';
+
+  public static readonly module = ComplementModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/inventory/complements/complement.repository.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { AbstractRepository } from '../../../abstracts/abstarct.repository';
+import { ComplementEntity } from './complement.entity';
+import { ComplementSchema } from './complement.schema';
+import { CreateComplementValidator, UpdateComplementValidator } from './complement.validator';
+
+@Injectable()
+export class ComplementRepository extends AbstractRepository<ComplementEntity> {
+  @InjectModel(ComplementSchema.name)
+  protected readonly $model: Model<ComplementEntity>;
+
+  public async create(validator: CreateComplementValidator) {
+    const complement = new this.$model();
+
+    complement.name = validator.name;
+    complement.description = validator.description;
+    complement.price = validator.price;
+
+    await complement.save();
+
+    return complement;
+  }
+
+  public async update(id: string, validator: UpdateComplementValidator) {
+    const complement = await this.read(id);
+
+    complement.name = validator.name || complement.name;
+    complement.description = validator.description || complement.description;
+    complement.price = validator.price || complement.price;
+
+    complement.save();
+
+    return complement;
+  }
+}

package/src/modules/inventory/complements/complement.schema.ts

@@ -0,0 +1,8 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { ComplementEntity } from './complement.entity';
+
+export namespace ComplementSchema {
+  export const name = 'inventory_complements';
+
+  export const schema = SchemaFactory.createForClass(ComplementEntity);
+}

package/src/modules/inventory/complements/complement.validator.ts

@@ -0,0 +1,28 @@
+import { IsNumber, IsOptional, IsPositive, IsString } from 'class-validator';
+
+export class CreateComplementValidator {
+  @IsString()
+  public name: string;
+
+  @IsString()
+  public description: string;
+
+  @IsNumber()
+  @IsPositive()
+  public price: number;
+}
+
+export class UpdateComplementValidator {
+  @IsOptional()
+  @IsString()
+  public name: string;
+
+  @IsOptional()
+  @IsString()
+  public description: string;
+
+  @IsOptional()
+  @IsNumber()
+  @IsPositive()
+  public price: number;
+}

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

@@ -0,0 +1,23 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { BrandModule } from './brands/brand.module';
+import { CategoryModule } from './categories/category.module';
+import { ComplementModule } from './complements/complement.module';
+import { ProductModule } from './products/product.module';
+
+const modules = [ProductModule, CategoryModule, ComplementModule, BrandModule];
+
+export const metadata: ModuleMetadata = {
+  controllers: [],
+  exports: modules,
+  imports: modules,
+  providers: [],
+};
+
+@Module(metadata)
+export class InventoryModule {
+  public static readonly path = '/inventory';
+
+  public static readonly module = InventoryModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/inventory/products/documents/attribute.document.ts

@@ -0,0 +1,14 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+
+export class ProductAttributesDocument {
+  // Cantidad de unidades que se venden en ese producto
+  @Prop({ default: () => 1, type: Schema.Types.Number })
+  public units = 1;
+
+  @Prop({ default: () => null, type: Schema.Types.Number })
+  public stock: null | number = null;
+
+  @Prop({ default: () => undefined, required: true, type: Schema.Types.String, unique: true })
+  public sku: string;
+}

package/src/modules/inventory/products/documents/dimension.document.ts

@@ -0,0 +1,16 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+
+export class ProductDimensionDocument {
+  @Prop({ type: Schema.Types.Number })
+  public weight: number;
+
+  @Prop({ type: Schema.Types.Number })
+  public height: number;
+
+  @Prop({ type: Schema.Types.Number })
+  public width: number;
+
+  @Prop({ type: Schema.Types.Number })
+  public depth: number;
+}

package/src/modules/inventory/products/product.controller.ts

@@ -0,0 +1,62 @@
+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 { ProductEntity } from './product.entity';
+import { ProductRepository } from './product.repository';
+import { CreateProductValidator, UpdateProductValidator } from './product.validator';
+
+@Controller('/')
+@ApiTags('inventory')
+export class ProductController extends AbstractController {
+  @Inject()
+  protected readonly $repository: ProductRepository;
+
+  @Public()
+  @Get('/')
+  public find(@Query() validator: FindValidator<ProductEntity>) {
+    return this.$repository.find(validator);
+  }
+
+  @Public()
+  @Post('/')
+  public create(@Body() validator: CreateProductValidator) {
+    return this.$repository.create(validator);
+  }
+
+  @Public()
+  @Get('/:id')
+  public read(@Param() { id }: IdMongoValidator, @Query() validator?: ReadValidator) {
+    return this.$repository.read(id, validator);
+  }
+
+  @Patch('/:id')
+  public update(@Param() { id }: IdMongoValidator, @Body() validator: UpdateProductValidator) {
+    return this.$repository.update(id, validator);
+  }
+
+  @Delete('/:id')
+  public delete(@Param() { id }: IdMongoValidator) {
+    return this.$repository.delete(id);
+  }
+
+  @Public()
+  @Get('/:id/related')
+  public async findRelated(@Param() { id }: IdMongoValidator, @Query() validator: FindValidator<ProductEntity> = {}) {
+    const product = await this.read({ id }, {});
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    validator.filters._id = { $ne: id };
+    validator.filters.category = product.category;
+    validator.filters.$text = {
+      $caseSensitive: false,
+      $search: product.name,
+    };
+
+    const { items } = await this.$repository.find(validator);
+
+    return items;
+  }
+}

package/src/modules/inventory/products/product.entity.ts

@@ -0,0 +1,46 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+import { $collection, AbstractEntity, MaybeEntity } from '../../../abstracts/abstract.entity';
+import { FileEntity } from '../../asset/files/file.entity';
+import { FileSchema } from '../../asset/files/file.schema';
+import { BrandEntity } from '../brands/brand.entity';
+import { BrandSchema } from '../brands/brand.schema';
+import { CategoryEntity } from '../categories/category.entity';
+import { CategorySchema } from '../categories/category.schema';
+import { ProductAttributesDocument } from './documents/attribute.document';
+import { ProductDimensionDocument } from './documents/dimension.document';
+
+@Collection($collection)
+export class ProductEntity extends AbstractEntity {
+  @Prop({ required: true, type: Schema.Types.String, unique: true })
+  public name: string;
+
+  @Prop({ default: () => String(), type: Schema.Types.String })
+  public description: string;
+
+  @Prop({ default: true, type: Schema.Types.Boolean })
+  public active = true;
+
+  @Prop({ required: true, type: Schema.Types.Number })
+  public price: number;
+
+  @Prop({ default: [], type: Schema.Types.Array })
+  public hashtags: string[] = [];
+
+  @Prop({ ref: BrandSchema.name, type: Schema.Types.ObjectId })
+  public brand?: MaybeEntity<BrandEntity>;
+
+  @Prop({ ref: CategorySchema.name, type: Schema.Types.ObjectId })
+  public category?: MaybeEntity<CategoryEntity>;
+
+  @Prop({ default: [], ref: FileSchema.name, type: [{ type: Schema.Types.String }] })
+  public pictures: FileEntity[] = [];
+
+  @Prop({ default: () => new ProductAttributesDocument(), type: Schema.Types.Mixed })
+  public attributes = new ProductAttributesDocument();
+
+  @Prop({ default: () => new ProductDimensionDocument(), type: Schema.Types.Mixed })
+  public dimension = new ProductDimensionDocument();
+
+  public readonly image: string;
+}

package/src/modules/inventory/products/product.module.ts

@@ -0,0 +1,19 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { ProductController } from './product.controller';
+import { ProductRepository } from './product.repository';
+
+export const metadata: ModuleMetadata = {
+  controllers: [ProductController],
+  exports: [ProductRepository],
+  imports: [],
+  providers: [ProductRepository],
+};
+
+@Module(metadata)
+export class ProductModule {
+  public static readonly path = '/products';
+
+  public static readonly module = ProductModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/inventory/products/product.repository.ts

@@ -0,0 +1,64 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { AbstractRepository } from '../../../abstracts/abstarct.repository';
+import { ProductEntity } from './product.entity';
+import { ProductSchema } from './product.schema';
+import { CreateProductValidator, UpdateProductValidator } from './product.validator';
+
+@Injectable()
+export class ProductRepository extends AbstractRepository<ProductEntity> {
+  @InjectModel(ProductSchema.name)
+  protected readonly $model: Model<ProductEntity>;
+
+  public async create(validator: CreateProductValidator) {
+    const product = new this.$model();
+
+    product.active = validator.active;
+
+    product.name = validator.name;
+    product.description = validator.description;
+    product.price = validator.price;
+    product.hashtags = validator.hashtags;
+
+    product.pictures = validator.pictures as any;
+    product.category = validator.category as any;
+    product.brand = validator.brand as any;
+
+    product.dimension = {
+      depth: validator.dimension?.depth,
+      height: validator.dimension?.height,
+      weight: validator.dimension?.weight,
+      width: validator.dimension?.width,
+    };
+
+    product.attributes = {
+      stock: validator.attributes.stock,
+      sku: validator.attributes.sku,
+      units: validator.attributes.units,
+    };
+
+    await product.save();
+
+    return product;
+  }
+
+  public async update(id: string, validator: UpdateProductValidator) {
+    const product = await this.read(id);
+
+    validator.active && (product.active = validator.active);
+
+    validator.name && (product.name = validator.name);
+    validator.description && (product.description = validator.description);
+    validator.price && (product.price = validator.price);
+    validator.hashtags?.length && (product.hashtags = validator.hashtags);
+
+    validator.category && (product.category = validator.category as any);
+    validator.brand && (product.brand = validator.brand as any);
+    validator.pictures?.length && (product.pictures = validator.pictures as any);
+
+    await product.save();
+
+    return product;
+  }
+}

package/src/modules/inventory/products/product.schema.ts

@@ -0,0 +1,19 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { ProductEntity } from './product.entity';
+
+export namespace ProductSchema {
+  export const name = 'inventory_products';
+
+  export const schema = SchemaFactory.createForClass(ProductEntity);
+
+  schema.index({
+    description: 'text',
+    name: 'text',
+  });
+
+  schema.virtual('image').get(function () {
+    const [first] = this.pictures;
+
+    return first?.url;
+  });
+}

package/src/modules/inventory/products/product.validator.ts

@@ -0,0 +1,132 @@
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsBoolean,
+  IsMongoId,
+  IsNotEmpty,
+  IsNumber,
+  IsOptional,
+  IsPositive,
+  IsString,
+  ValidateNested,
+} from 'class-validator';
+import { AbstractValidator } from '../../../abstracts/abstract.validator';
+import { ProductEntity } from './product.entity';
+import { AttributesValidator } from './validators/attributes.validator';
+import { DimensionValidator } from './validators/dimension.validator';
+
+export class CreateProductValidator extends AbstractValidator {
+  @IsBoolean()
+  @IsOptional()
+  public active? = true;
+
+  @IsString({ each: true })
+  @IsNotEmpty({ each: true })
+  @IsOptional()
+  public hashtags?: string[] = [];
+
+  @IsString()
+  @IsNotEmpty()
+  public name: string;
+
+  @IsString()
+  @IsOptional()
+  public description: string;
+
+  @IsNumber()
+  @IsPositive()
+  public price: number;
+
+  @IsMongoId({ each: true })
+  @IsArray()
+  @IsOptional()
+  public pictures?: string[] = [];
+
+  @IsOptional()
+  @IsMongoId()
+  public category?: string;
+
+  @IsOptional()
+  @IsMongoId()
+  public brand?: string;
+
+  @Type(() => DimensionValidator)
+  @ValidateNested()
+  @IsOptional()
+  public dimension? = new DimensionValidator();
+
+  @Type(() => AttributesValidator)
+  @ValidateNested()
+  @IsOptional()
+  public attributes? = new AttributesValidator();
+}
+
+export class UpdateProductValidator {
+  @IsBoolean()
+  @IsOptional()
+  public active?: boolean;
+
+  @IsString({ each: true })
+  @IsNotEmpty({ each: true })
+  @IsOptional()
+  public hashtags?: string[] = [];
+
+  @IsOptional()
+  @IsString()
+  @IsNotEmpty()
+  public name?: string;
+
+  @IsOptional()
+  @IsString()
+  @IsOptional()
+  public description?: string;
+
+  @IsOptional()
+  @IsNumber()
+  public price?: number;
+
+  @IsOptional()
+  @IsMongoId()
+  public category?: string;
+
+  @IsOptional()
+  @IsMongoId()
+  public brand?: string;
+
+  @IsMongoId({ each: true })
+  @IsArray()
+  @IsOptional()
+  public pictures?: string[] = [];
+
+  @Type(() => DimensionValidator)
+  @ValidateNested()
+  @IsOptional()
+  public dimension?: DimensionValidator;
+
+  @Type(() => AttributesValidator)
+  @ValidateNested()
+  @IsOptional()
+  public attributes?: AttributesValidator = new AttributesValidator();
+
+  public constructor(entity: ProductEntity) {
+    this.active = entity.active;
+
+    this.name = entity.name;
+    this.description = entity.description;
+    this.price = entity.price;
+    this.hashtags = entity.hashtags;
+
+    this.category = entity.category?._id;
+    this.brand = entity.brand?._id;
+    this.pictures = entity.pictures.map((file) => file._id);
+
+    this.attributes.sku = entity.attributes.sku;
+    this.attributes.stock = entity.attributes.stock;
+    this.attributes.units = entity.attributes.units;
+
+    this.dimension.depth = entity.dimension.depth;
+    this.dimension.height = entity.dimension.height;
+    this.dimension.weight = entity.dimension.weight;
+    this.dimension.width = entity.dimension.width;
+  }
+}

package/src/modules/inventory/products/validators/attributes.validator.ts

@@ -0,0 +1,15 @@
+import { IsNumber, IsOptional, IsPositive, IsString } from 'class-validator';
+
+export class AttributesValidator {
+  @IsPositive()
+  public units = 1;
+
+  @IsNumber()
+  @IsOptional()
+  public stock: number | null = null;
+
+  @IsString()
+  @IsOptional()
+  @IsOptional()
+  public sku: string;
+}

package/src/modules/inventory/products/validators/dimension.validator.ts

@@ -0,0 +1,19 @@
+import { IsOptional, IsPositive } from 'class-validator';
+
+export class DimensionValidator {
+  @IsPositive()
+  @IsOptional()
+  public weight: number;
+
+  @IsPositive()
+  @IsOptional()
+  public height: number;
+
+  @IsPositive()
+  @IsOptional()
+  public width: number;
+
+  @IsPositive()
+  @IsOptional()
+  public depth: number;
+}