@merkaly/api 0.2.4-5 → 0.2.4-7

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

@@ -0,0 +1,21 @@
+import { Prop, Schema } from '@nestjs/mongoose';
+import { Schema as MongoSchema, Types } from 'mongoose';
+import { AbstractEntity } from '../../../abstract/abstract.entity';
+import { PropertyEntity } from '../properties/property.entity';
+
+@Schema({ timestamps: true })
+export class CategoryEntity extends AbstractEntity {
+  public static readonly $index = 'inventory_categories';
+
+  @Prop({ type: MongoSchema.Types.String, length: 32, unique: true, required: true })
+  public name: string;
+
+  @Prop({ type: MongoSchema.Types.String })
+  public description: string;
+
+  @Prop({ type: MongoSchema.Types.String, length: 32, default: 'tag' })
+  public icon: string;
+
+  @Prop({ type: [{ type: Types.ObjectId, ref: PropertyEntity.$index }] })
+  public properties: PropertyEntity[] = [];
+}

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

@@ -0,0 +1,9 @@
+import { Catch, HttpException } from '@nestjs/common';
+import { AbstractException } from '../../../abstract/abstract.exception';
+
+@Catch()
+export class CategoryException extends AbstractException {
+  public handleError(exception: HttpException) {
+    return exception;
+  }
+}

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

@@ -0,0 +1,18 @@
+import { AbstractFixture } from '../../../abstract/abstract.fixture';
+import { CategoryEntity } from "./category.entity";
+
+export class CategoryFixture extends AbstractFixture {
+
+  public normal() {
+    const category = new CategoryEntity({
+      _id: this.$faker.datatype.uuid(),
+      createdAt: this.$faker.date.past(1),
+      updatedAt: this.$faker.date.past(1),
+    });
+
+    category.name = this.$faker.vehicle.manufacturer();
+    category.description = this.$faker.lorem.sentence();
+
+    return category;
+  }
+}

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

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { AbsctractListener } from '../../../abstract/absctract.listener';
+
+export enum CategoryEvent {
+  PRE_CREATE = 'database.inventory.category.create.pre',
+  POST_CREATE = 'database.inventory.category.create.post',
+
+  PRE_UPDATE = 'database.inventory.category.update.pre',
+  POST_UPDATE = 'database.inventory.category.update.post',
+
+  PRE_DELETE = 'database.inventory.category.delete.pre',
+  POST_DELETE = 'database.inventory.category.delete.post',
+}
+
+@Injectable()
+export class CategoryListener extends AbsctractListener {
+}

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

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

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

@@ -0,0 +1,40 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model, UpdateQuery } from 'mongoose';
+import { AbstractRepository } from '../../../abstract/abstract.repository';
+import { CategoryEntity } from './category.entity';
+import { CreateCategoryValidator, UpdateCategoryValidator } from './category.validator';
+
+@Injectable()
+export class CategoryRepository extends AbstractRepository<CategoryEntity> {
+  @InjectModel(CategoryEntity.$index)
+  public readonly $model: Model<CategoryEntity>;
+
+  public async create(validator: CreateCategoryValidator) {
+    const category = new this.$model();
+
+    category.name = validator.name;
+    category.description = validator.description;
+    category.icon = validator.icon;
+
+    return super.$create(category);
+  }
+
+  public async update(id: string, validator: UpdateCategoryValidator) {
+    const category = await this.$model.findById(id);
+
+    const query: UpdateQuery<CategoryEntity> = {
+      $set: {
+        name: validator.name || category.name,
+        icon: validator.icon,
+        description: validator.description || category.description,
+      },
+    };
+
+    return super.$update(id, query);
+  }
+
+  public async delete(id: string): Promise<void> {
+    return super.$delete(id);
+  }
+}

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

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

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

@@ -0,0 +1,30 @@
+import { IsOptional, IsString, Length } from 'class-validator';
+import { AbstractValidator } from "../../../abstract/abstract.validator";
+
+export class CreateCategoryValidator extends AbstractValidator {
+  @IsString()
+  @Length(5, 32)
+  public name: string;
+
+  @IsString()
+  @IsOptional()
+  public description?: string;
+
+  @IsString()
+  @IsOptional()
+  public icon = 'tag';
+}
+
+export class UpdateCategoryValidator extends AbstractValidator {
+  @IsString()
+  @IsOptional()
+  public name: string;
+
+  @IsString()
+  @IsOptional()
+  public description?: string;
+
+  @IsString()
+  @IsOptional()
+  public icon = 'tag';
+}

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

@@ -0,0 +1,22 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../abstract/abstract.router';
+import { BrandModule } from './brands/brand.module';
+import { CategoryModule } from './categories/category.module';
+import { ProductModule } from './products/product.module';
+import { PropertyModule } from './properties/property.module';
+
+export const metadata: ModuleMetadata = {
+  imports: [BrandModule, CategoryModule, ProductModule, PropertyModule],
+  controllers: [],
+  providers: [],
+  exports: [BrandModule, CategoryModule, ProductModule, PropertyModule],
+};
+
+@Module(metadata)
+export class InventoryModule extends AbstractRouter {
+  public static readonly path = '/inventory';
+
+  public static readonly module = InventoryModule;
+
+  public static readonly children = metadata.imports;
+}

package/src/modules/inventory/products/entities/code.entity.ts

@@ -0,0 +1,15 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+
+@Collection()
+export class CodeEntity extends Map {
+  @Prop({ type: Schema.Types.String })
+  public sku: string;
+
+  @Prop({ type: Schema.Types.String })
+  public gtin: string;
+
+  @Prop({ type: Schema.Types.String })
+  public mpn: string;
+}

package/src/modules/inventory/products/entities/dimension.entity.ts

@@ -0,0 +1,18 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+
+@Collection()
+export class DimensionEntity extends Map {
+  @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/entities/price.entity.ts

@@ -0,0 +1,12 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+
+@Collection()
+export class PriceEntity extends Map {
+  @Prop({ type: Schema.Types.Number, required: true })
+  public sale: number;
+
+  @Prop({ type: Schema.Types.Number })
+  public purchase: number;
+}

package/src/modules/inventory/products/entities/seo.entity.ts

@@ -0,0 +1,15 @@
+import { Prop } from '@nestjs/mongoose';
+import { Schema as Collection } from '@nestjs/mongoose/dist/decorators/schema.decorator';
+import { Schema } from 'mongoose';
+
+@Collection()
+export class SeoEntity extends Map {
+  @Prop({ type: Schema.Types.String })
+  public title: string;
+
+  @Prop({ type: Schema.Types.String })
+  public slug: string;
+
+  @Prop({ type: Schema.Types.String })
+  public description: string;
+}

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

@@ -0,0 +1,59 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Param,
+  Patch,
+  Post,
+  Query,
+  UseFilters,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { AbstractController } from '../../../abstract/abstract.controller';
+import { FindValidator } from '../../../abstract/abstract.validator';
+import { ProductEntity } from './product.entity';
+import { ProductException } from './product.exception';
+import { ProductRepository } from './product.repository';
+import { CreateProductValidator, UpdateProductValidator } from './product.validator';
+import { Public } from "../../../decorators/public.decorator";
+
+@Controller()
+@UseFilters(ProductException)
+@ApiTags('inventory')
+export class ProductController extends AbstractController<ProductEntity> {
+  @Inject()
+  protected readonly $repository: ProductRepository;
+
+  @Get('/')
+  @Public()
+  public async find(@Query() validator: FindValidator<ProductEntity>) {
+    return super.find(validator);
+  }
+
+  @Post('/')
+  @HttpCode(HttpStatus.CREATED)
+  public async create(@Body() validator: CreateProductValidator) {
+    return this.$repository.create(validator);
+  }
+
+  @Get('/:id')
+  @Public()
+  public async read(@Param('id') id: string, @Query() validator: FindValidator<ProductEntity>) {
+    return this.$repository.read(id, validator);
+  }
+
+  @Patch('/:id')
+  public async update(@Param('id') id: string, @Body() validator: UpdateProductValidator) {
+    return this.$repository.update(id, validator);
+  }
+
+  @Delete('/:id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  public async delete(@Param('id') id: string) {
+    return this.$repository.delete(id);
+  }
+}

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

@@ -0,0 +1,53 @@
+import { Prop, Schema as Collection } from '@nestjs/mongoose';
+import { Schema } from 'mongoose';
+import { AbstractEntity } from '../../../abstract/abstract.entity';
+import { AssetEntity } from '../../assets/asset.entity';
+import { BrandEntity } from '../brands/brand.entity';
+import { CategoryEntity } from '../categories/category.entity';
+import { CodeEntity } from './entities/code.entity';
+import { DimensionEntity } from './entities/dimension.entity';
+import { PriceEntity } from './entities/price.entity';
+import { SeoEntity } from './entities/seo.entity';
+
+@Collection({ timestamps: true, toJSON: { virtuals: true } })
+export class ProductEntity extends AbstractEntity {
+  public static readonly $index = 'inventory_products';
+
+  @Prop({ type: Schema.Types.String, required: true, length: 64 })
+  public name: string;
+
+  @Prop({ type: Schema.Types.String, length: 256 })
+  public measurement: string;
+
+  @Prop({ type: Schema.Types.Boolean, default: true })
+  public active = true;
+
+  @Prop({ type: Schema.Types.String, nullable: true })
+  public description: string;
+
+  @Prop({ type: Schema.Types.Array, default: [] })
+  public hashtags: string[] = [];
+
+  @Prop({ type: Schema.Types.ObjectId, ref: CategoryEntity.$index })
+  public category?: CategoryEntity;
+
+  @Prop({ type: Schema.Types.ObjectId, ref: BrandEntity.$index })
+  public brand?: BrandEntity;
+
+  @Prop({ type: [{ type: Schema.Types.ObjectId, ref: AssetEntity.$index }] })
+  public files: AssetEntity[] = [];
+
+  @Prop({ type: Schema.Types.Map, ref: () => PriceEntity, default: new Map() })
+  public price: PriceEntity;
+
+  @Prop({ type: Schema.Types.Map, ref: () => CodeEntity, default: new Map() })
+  public code: CodeEntity;
+
+  @Prop({ type: Schema.Types.Map, ref: () => DimensionEntity, default: new Map() })
+  public dimension: DimensionEntity;
+
+  @Prop({ type: Schema.Types.Map, ref: () => SeoEntity, default: new Map() })
+  public seo: SeoEntity;
+
+  public readonly picture: string
+}

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

@@ -0,0 +1,9 @@
+import { Catch, HttpException } from '@nestjs/common';
+import { AbstractException } from '../../../abstract/abstract.exception';
+
+@Catch()
+export class ProductException extends AbstractException {
+  public handleError(exception: HttpException) {
+    return exception;
+  }
+}

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

@@ -0,0 +1,19 @@
+import { AbstractFixture } from '../../../abstract/abstract.fixture';
+import { ProductEntity } from "./product.entity";
+
+export class ProductFixture extends AbstractFixture {
+
+  public normal() {
+    const product = new ProductEntity({
+      _id: this.$faker.datatype.uuid(),
+      createdAt: this.$faker.date.past(1),
+      updatedAt: this.$faker.date.past(1),
+    });
+
+    product.name = this.$faker.vehicle.vehicle();
+    product.description = this.$faker.commerce.productDescription();
+    product.price.sale = Number(this.$faker.commerce.price(1000, 10000, 2));
+
+    return product;
+  }
+}

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

@@ -0,0 +1,27 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { AbsctractListener } from '../../../abstract/absctract.listener';
+import { AssetService } from '../../assets/asset.service';
+import { ProductEntity } from './product.entity';
+
+export enum ProductEvent {
+  LINK_FILES = 'database.inventory.product.link-files',
+}
+
+@Injectable()
+export class ProductListener extends AbsctractListener {
+
+  @Inject()
+  protected $assets: AssetService;
+
+  @OnEvent(ProductEvent.LINK_FILES)
+  protected async linkAssets(product: ProductEntity) {
+    await product.populate('files');
+
+    const { _id, db: { name } } = product;
+
+    await this.$assets.removeAssetsWeakness(product.files, `${name}/products/${_id}`);
+
+    return product;
+  }
+}

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

@@ -0,0 +1,20 @@
+import { Module, ModuleMetadata } from '@nestjs/common';
+import { AbstractRouter } from '../../../abstract/abstract.router';
+import { AssetService } from '../../assets/asset.service';
+import { ProductController } from './product.controller';
+import { ProductListener } from './product.listener';
+import { ProductRepository } from './product.repository';
+
+export const metadata: ModuleMetadata = {
+  imports: [],
+  controllers: [ProductController],
+  providers: [ProductRepository, ProductListener, AssetService],
+  exports: [ProductRepository],
+};
+
+@Module(metadata)
+export class ProductModule extends AbstractRouter {
+  public static readonly path = '/products';
+
+  public static readonly module = ProductModule;
+}

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

@@ -0,0 +1,108 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model, Types } from 'mongoose';
+import { AbstractRepository } from '../../../abstract/abstract.repository';
+import { AssetEntity } from '../../assets/asset.entity';
+import { BrandEntity } from '../brands/brand.entity';
+import { CategoryEntity } from '../categories/category.entity';
+import { ProductEntity } from './product.entity';
+import { ProductEvent } from './product.listener';
+import { CreateProductValidator, UpdateProductValidator } from './product.validator';
+import { FindValidator } from "../../../abstract/abstract.validator";
+
+@Injectable()
+export class ProductRepository extends AbstractRepository<ProductEntity> {
+  @InjectModel(ProductEntity.$index)
+  public readonly $model: Model<ProductEntity>;
+
+  @InjectModel(AssetEntity.$index)
+  public readonly $asset: Model<AssetEntity>;
+
+  @InjectModel(BrandEntity.$index)
+  public readonly $brand: Model<BrandEntity>;
+
+  @InjectModel(CategoryEntity.$index)
+  public readonly $category: Model<CategoryEntity>;
+
+  public async create(validator: CreateProductValidator) {
+    const product: ProductEntity = new this.$model();
+
+    product.name = validator.name;
+    product.measurement = validator.measurement;
+    product.description = validator.description;
+    product.hashtags = validator.hashtags;
+    product.active = validator.active;
+    product.files = validator.files.map<AssetEntity>(file => new Types.ObjectId(file) as any);
+
+    product.brand = (validator.brand ? new Types.ObjectId(validator.brand) : product.brand) as any;
+    product.category = (validator.category ? new Types.ObjectId(validator.category) : product.category) as any;
+
+    product.price.set('sale', validator.price.sale);
+    product.price.set('purchase', validator.price.purchase);
+
+    product.seo.set('slug', validator.seo.slug);
+    product.seo.set('title', validator.seo.title);
+    product.seo.set('description', validator.seo.description);
+
+    product.code.set('gtin', validator.code.gtin);
+    product.code.set('sku', validator.code.sku);
+    product.code.set('mpn', validator.code.mpn);
+
+    product.dimension.set('depth', validator.dimension.depth);
+    product.dimension.set('height', validator.dimension.height);
+    product.dimension.set('weight', validator.dimension.weight);
+    product.dimension.set('width', validator.dimension.width);
+
+    await this.$model.create(product);
+
+    await this.$event.emitAsync(ProductEvent.LINK_FILES, product);
+
+    return product;
+  }
+
+  public async read(id: string, params: FindValidator<ProductEntity>): Promise<ProductEntity> {
+    return this.$model
+      .findOne({ [Types.ObjectId.isValid(id) ? '_id' : 'seo.slug']: id })
+      .populate(params.join)
+  }
+
+  public async update(id: string, validator: UpdateProductValidator) {
+    const product: ProductEntity = await this.$model.findById(id);
+
+    product.name = validator.name || product.name;
+    product.measurement = validator.measurement || product.measurement;
+    product.description = validator.description || product.description;
+    product.hashtags = validator.hashtags ?? product.hashtags;
+    product.active = validator.active ?? product.active;
+    product.files = validator.files.map<AssetEntity>(file => new Types.ObjectId(file) as any);
+
+    product.brand = (validator.brand ? new Types.ObjectId(validator.brand) : product.brand) as any;
+    product.category = (validator.category ? new Types.ObjectId(validator.category) : product.category) as any;
+
+    product.price.set('sale', validator.price.sale || product.price.get('sale'));
+    product.price.set('purchase', validator.price.purchase || product.price.get('purchase'));
+
+    product.seo.set('slug', validator.seo.slug ?? product.seo.slug);
+    product.seo.set('title', validator.seo.title ?? product.seo.title);
+    product.seo.set('description', validator.seo.description ?? product.seo.description);
+
+    product.code.set('gtin', validator.code.gtin ?? product.code.gtin);
+    product.code.set('sku', validator.code.sku ?? product.code.sku);
+    product.code.set('mpn', validator.code.mpn ?? product.code.mpn);
+
+    product.dimension.set('depth', validator.dimension.depth ?? product.dimension.depth);
+    product.dimension.set('height', validator.dimension.height ?? product.dimension.height);
+    product.dimension.set('weight', validator.dimension.weight ?? product.dimension.weight);
+    product.dimension.set('width', validator.dimension.width ?? product.dimension.width);
+
+    await this.$event.emitAsync(ProductEvent.LINK_FILES, product);
+
+    await product.save();
+
+    return product;
+  }
+
+  public async delete(id: string) {
+    return this.$delete(id);
+  }
+}

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

@@ -0,0 +1,15 @@
+import { SchemaFactory } from '@nestjs/mongoose';
+import { ProductEntity } from './product.entity';
+
+export const ProductSchema = SchemaFactory.createForClass(ProductEntity);
+
+ProductSchema.virtual('picture').get<ProductEntity>(function () {
+  const [first] = this.files
+
+  return first?.url;
+});
+
+ProductSchema.index({
+  name: 'text',
+  description: 'text',
+})

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

@@ -0,0 +1,71 @@
+import { Type } from 'class-transformer';
+import {
+  IsBoolean,
+  IsMongoId,
+  IsNotEmpty,
+  IsNotEmptyObject,
+  IsOptional,
+  IsString,
+  ValidateNested
+} from 'class-validator';
+import 'reflect-metadata';
+import { ProductCodeValidator } from './validators/code.validator';
+import { ProductDimensionValidator } from './validators/dimension.validator';
+import { ProductPriceValidator } from './validators/price.validator';
+import { ProductSeoValidator } from './validators/seo.validator';
+import { AbstractValidator } from "../../../abstract/abstract.validator";
+
+export class CreateProductValidator extends AbstractValidator {
+  @IsString()
+  @IsNotEmpty()
+  public name = String();
+
+  @IsString()
+  @IsOptional()
+  public description = String();
+
+  @IsString()
+  public measurement = String();
+
+  @IsBoolean()
+  @IsOptional()
+  public active = Boolean(1);
+
+  @IsOptional()
+  @IsMongoId()
+  public category?: string = null;
+
+  @IsOptional()
+  @IsMongoId()
+  public brand?: string = null;
+
+  @IsMongoId({ each: true })
+  @IsOptional()
+  public files: string[] = [];
+
+  @IsString({ each: true })
+  public hashtags: string[] = [];
+
+  @ValidateNested()
+  @IsNotEmptyObject()
+  @Type(() => ProductPriceValidator)
+  public price = new ProductPriceValidator();
+
+  @ValidateNested()
+  @Type(() => ProductSeoValidator)
+  public seo = new ProductSeoValidator();
+
+  @ValidateNested()
+  @Type(() => ProductDimensionValidator)
+  public dimension = new ProductDimensionValidator();
+
+  @ValidateNested()
+  @Type(() => ProductCodeValidator)
+  public code = new ProductCodeValidator();
+}
+
+export class UpdateProductValidator extends CreateProductValidator {
+  @IsString()
+  @IsOptional()
+  public name: string;
+}

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

@@ -0,0 +1,15 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class ProductCodeValidator {
+  @IsString()
+  @IsOptional()
+  public sku? = String();
+
+  @IsString()
+  @IsOptional()
+  public gtin? = String();
+
+  @IsString()
+  @IsOptional()
+  public mpn? = String();
+}