@merkaly/api 0.1.7 → 0.1.9-1

package/src/app.d.ts

@@ -0,0 +1 @@
+export {};

package/src/app.emitter.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { event, eventNS } from 'eventemitter2';
+export declare enum AbstractEvent {
+    ENTITY_LISTED = "entity.*.listed",
+    ENTITY_READED = "entity.*.readed",
+    ENTITY_CREATED = "entity.*.created",
+    ENTITY_UPDATED = "entity.*.updated",
+    ENTITY_DELETED = "entity.*.deleted",
+    ENTITY_NOT_FOUND = "entity.*.not_found",
+    ENTITY_SYNCED = "entity.*.synced"
+}
+export default class AppEmitter {
+    protected readonly emitter: EventEmitter2;
+    emit(event: event | eventNS, ...values: any[]): boolean;
+    private handleAllEvents;
+}

package/src/app.emitter.ts

@@ -0,0 +1,27 @@
+import { Inject, Injectable, Logger } from '@nestjs/common'
+import { EventEmitter2, OnEvent } from '@nestjs/event-emitter'
+import { event, eventNS } from 'eventemitter2'
+
+export enum AbstractEvent {
+  ENTITY_LISTED = 'entity.*.listed',
+  ENTITY_READED = 'entity.*.readed',
+  ENTITY_CREATED = 'entity.*.created',
+  ENTITY_UPDATED = 'entity.*.updated',
+  ENTITY_DELETED = 'entity.*.deleted',
+  ENTITY_NOT_FOUND = 'entity.*.not_found',
+  ENTITY_SYNCED = 'entity.*.synced',
+}
+
+@Injectable()
+export default class AppEmitter {
+  @Inject() protected readonly emitter: EventEmitter2
+
+  public emit (event: event | eventNS, ...values: any[]) {
+    return this.emitter.emit(event, values)
+  }
+
+  @OnEvent('*.*.*')
+  private handleAllEvents (payload: any, name: string) {
+    return Logger.debug(`Event '${name}' has emitted an ${typeof payload}`, AppEmitter.name)
+  }
+}

package/src/app.entity.d.ts

@@ -0,0 +1,7 @@
+import { TransformFnParams } from 'class-transformer';
+import { IEntity } from 'fireorm';
+export default abstract class AppEntity implements IEntity {
+    static readonly $path: string;
+    id: string;
+    static transformSubCollection({ value }: TransformFnParams): string;
+}

package/src/app.module.d.ts

@@ -0,0 +1,9 @@
+import { MiddlewareConsumer, ModuleMetadata, NestMiddleware, NestModule } from '@nestjs/common';
+import { NextFunction, Request, Response } from 'express';
+export declare const metadata: ModuleMetadata;
+export default class AppModule implements NestModule {
+    configure(consumer: MiddlewareConsumer): MiddlewareConsumer;
+}
+export declare class LoggerMiddleware implements NestMiddleware {
+    use(request: Request, response: Response, next: NextFunction): Promise<void>;
+}

package/src/app.module.ts

@@ -0,0 +1,45 @@
+import { Logger, MiddlewareConsumer, Module, ModuleMetadata, NestMiddleware, NestModule } from '@nestjs/common'
+import { ConfigModule } from '@nestjs/config'
+import { RouterModule } from '@nestjs/core'
+import { EventEmitterModule } from '@nestjs/event-emitter'
+import { NextFunction, Request, Response } from 'express'
+import AccountModule from './account/account.module'
+import AuthModule from './account/auth/auth.module'
+// import AppConfig from './app.config'
+import AppEmitter from './app.emitter'
+import AppRoutes from './app.routes'
+// import InventoryModule from './inventory/inventory.module'
+// import StoreModule from './store/store.module'
+
+const modules = [
+  ConfigModule.forRoot({ isGlobal: true }),
+  EventEmitterModule.forRoot({ wildcard: true }),
+  RouterModule.register(AppRoutes),
+  AuthModule,
+  // InventoryModule,
+  // StoreModule,
+  AccountModule
+]
+
+export const metadata: ModuleMetadata = {
+  imports: modules,
+  providers: [AppEmitter]
+}
+
+@Module(metadata)
+export default class AppModule implements NestModule {
+  configure (consumer: MiddlewareConsumer): MiddlewareConsumer {
+
+    return consumer
+      .apply(LoggerMiddleware).forRoutes('/')
+  }
+}
+
+export class LoggerMiddleware implements NestMiddleware {
+  async use (request: Request, response: Response, next: NextFunction): Promise<void> {
+    await next()
+    const referer = new URL(request.header('referer') || 'http://localhost').host
+
+    return Logger.log(`[${referer}] ${response.statusCode} ${request.method} ${request.url}`, LoggerMiddleware.name)
+  }
+}

package/src/app.repository.d.ts

@@ -0,0 +1,5 @@
+import { BaseFirestoreRepository, IEntity } from 'fireorm';
+export default abstract class AppRepository {
+    protected abstract readonly repositories: Record<string, BaseFirestoreRepository<IEntity>>;
+    static setReference($path: string, value: string): Promise<any>;
+}

package/src/app.repository.ts

@@ -0,0 +1,12 @@
+import { BaseFirestoreRepository, IEntity } from 'fireorm'
+import { firestore } from 'firebase-admin'
+
+export default abstract class AppRepository {
+  protected abstract readonly repositories: Record<string, BaseFirestoreRepository<IEntity>>
+
+  public static async setReference ($path: string, value: string): Promise<any> {
+    const { ref } = await firestore().collection($path).doc(value).get()
+
+    return ref
+  }
+}

package/src/app.routes.d.ts

@@ -0,0 +1,3 @@
+import { RouteTree } from '@nestjs/core/router/interfaces/routes.interface';
+declare const routes: RouteTree[];
+export default routes;

package/src/app.routes.ts

@@ -0,0 +1,61 @@
+import { RouteTree } from '@nestjs/core/router/interfaces/routes.interface'
+import { $AccountPath, OrganizationEntity, RoleEntity, UserEntity } from './account'
+import AccountModule from './account/account.module'
+import { $AuthPath as AccountAuthPath } from './account/auth'
+import AuthModule from './account/auth/auth.module'
+import MemberModule from './account/organizations/members/member.module'
+import OrganizationModule from './account/organizations/organization.module'
+import RoleModule from './account/roles/role.module'
+import RoleUserModule from './account/roles/users/user.module'
+import UserRoleModule from './account/users/roles/role.module'
+import UserModule from './account/users/user.module'
+import { $InventoryPath, ProductEntity } from './inventory'
+import BrandModule from './inventory/brands/brand.module'
+import CategoryModule from './inventory/categories/category.module'
+import InventoryModule from './inventory/inventory.module'
+import MediaModule from './inventory/products/media/media.module'
+import ProductModule from './inventory/products/product.module'
+import VariantModule from './inventory/products/variants/variant.module'
+import PropertyModule from './inventory/properties/property.module'
+import { $StorePath, OrderEntity } from './store'
+import CartModule from './store/carts/cart.module'
+import ItemModule from './store/orders/items/item.module'
+import OrderModule from './store/orders/order.module'
+import StoreModule from './store/store.module'
+
+const addModule = (module, children = [], path = '/'): RouteTree => ({ path, module, children })
+
+const routes = [
+  addModule(AuthModule, [], AccountAuthPath),
+
+  addModule(AccountModule, [
+    addModule(UserModule, [
+      addModule(UserRoleModule, [], UserEntity.$path)
+    ]),
+    addModule(OrganizationModule, [
+      addModule(MemberModule, [], OrganizationEntity.$path)
+    ]),
+    addModule(RoleModule, [
+      addModule(RoleUserModule, [], RoleEntity.$path)
+    ])
+  ], $AccountPath),
+
+  addModule(InventoryModule, [
+    addModule(BrandModule),
+    addModule(CategoryModule),
+    addModule(PropertyModule),
+    addModule(ProductModule, [
+      addModule(VariantModule, [], ProductEntity.$path),
+      addModule(MediaModule, [], ProductEntity.$path)
+    ])
+  ], $InventoryPath),
+
+  addModule(StoreModule, [
+    addModule(CartModule),
+    addModule(OrderModule, [
+      addModule(ItemModule, [], OrderEntity.$path)
+    ])
+  ], $StorePath)
+]
+
+export default routes

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

@@ -0,0 +1,11 @@
+import { BrandEntity } from './brand.entity';
+import BrandRepository from './brand.repository';
+import { CreateBrandValidator, UpdateBrandValidator } from './brand.validator';
+export default class BrandController {
+    protected readonly repository: BrandRepository;
+    find(): Promise<BrandEntity[]>;
+    read(id: string): Promise<BrandEntity>;
+    create(validator: CreateBrandValidator): Promise<BrandEntity>;
+    update(id: string, validator: UpdateBrandValidator): Promise<BrandEntity>;
+    delete(id: string): Promise<void>;
+}

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

@@ -0,0 +1,41 @@
+import { Body, Controller, Delete, Get, HttpCode, Inject, Param, Post, Put } from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+import { BrandEntity } from './brand.entity'
+import BrandRepository from './brand.repository'
+import { CreateBrandValidator, UpdateBrandValidator } from './brand.validator'
+
+@Controller(BrandEntity.$path)
+@ApiTags(BrandController.name)
+export default class BrandController {
+  @Inject() protected readonly repository: BrandRepository
+
+  @Get('/')
+  async find (): Promise<BrandEntity[]> {
+
+    return this.repository.find()
+  }
+
+  @Get('/:id')
+  async read (@Param('id') id: string): Promise<BrandEntity> {
+    return this.repository.read(id)
+  }
+
+  @Post('/')
+  @HttpCode(201)
+  async create (@Body() validator: CreateBrandValidator): Promise<BrandEntity> {
+
+    return this.repository.create(validator)
+  }
+
+  @Put('/:id')
+  async update (@Param('id') id: string, @Body() validator: UpdateBrandValidator): Promise<BrandEntity> {
+
+    return this.repository.update(id, validator)
+  }
+
+  @Delete('/:id')
+  @HttpCode(204)
+  async delete (@Param('id') id: string): Promise<void> {
+    return this.repository.delete(id)
+  }
+}

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

@@ -0,0 +1,4 @@
+import { ModuleMetadata } from '@nestjs/common';
+export declare const metadata: ModuleMetadata;
+export default class BrandModule {
+}

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

@@ -0,0 +1,14 @@
+import { Module, ModuleMetadata } from '@nestjs/common'
+import BrandController from './brand.controller'
+import BrandRepository from './brand.repository'
+
+export const metadata: ModuleMetadata = {
+  imports: [],
+  controllers: [BrandController],
+  providers: [BrandRepository],
+  exports: []
+}
+
+@Module(metadata)
+export default class BrandModule {
+}

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

@@ -0,0 +1,13 @@
+import AppRepository from '../../app.repository';
+import { BrandEntity } from './brand.entity';
+import { CreateBrandValidator, UpdateBrandValidator } from './brand.validator';
+export default class BrandRepository extends AppRepository {
+    protected readonly repositories: {
+        brand: import("fireorm").BaseFirestoreRepository<BrandEntity>;
+    };
+    find(): Promise<BrandEntity[]>;
+    read(id: string): Promise<BrandEntity>;
+    create(validator: CreateBrandValidator): Promise<BrandEntity>;
+    update(id: any, validator: UpdateBrandValidator): Promise<BrandEntity>;
+    delete(id: string): Promise<void>;
+}

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

@@ -0,0 +1,36 @@
+import { getRepository } from 'fireorm'
+import AppRepository from '../../app.repository'
+import { BrandEntity } from './brand.entity'
+import { CreateBrandValidator, UpdateBrandValidator } from './brand.validator'
+
+export default class BrandRepository extends AppRepository {
+  protected readonly repositories = {
+    brand: getRepository(BrandEntity)
+  }
+
+  public find () {
+    return this.repositories.brand.find()
+  }
+
+  public read (id: string) {
+    return this.repositories.brand.findById(id)
+  }
+
+  public create (validator: CreateBrandValidator) {
+    const brand = new BrandEntity()
+    brand.name = validator.name
+
+    return this.repositories.brand.create(brand)
+  }
+
+  public update (id, validator: UpdateBrandValidator) {
+    const brand = <BrandEntity>{}
+    brand.name = validator.name
+
+    return this.repositories.brand.update(brand)
+  }
+
+  public delete (id: string) {
+    return this.repositories.brand.delete(id)
+  }
+}

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

@@ -0,0 +1,11 @@
+import { CategoryEntity } from './category.entity';
+import CategoryRepository from './category.repository';
+import { CreateCategoryValidator, UpdateCategoryValidator } from './category.validator';
+export default class CategoryController {
+    protected readonly repository: CategoryRepository;
+    find(): Promise<CategoryEntity[]>;
+    read(id: string): Promise<CategoryEntity>;
+    create(validator: CreateCategoryValidator): Promise<CategoryEntity>;
+    update(id: string, validator: UpdateCategoryValidator): Promise<CategoryEntity>;
+    delete(id: string): Promise<void>;
+}

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

@@ -0,0 +1,43 @@
+import { Body, Controller, Delete, Get, HttpCode, Inject, Param, Post, Put } from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+import { CategoryEntity } from './category.entity'
+import CategoryRepository from './category.repository'
+import { CreateCategoryValidator, UpdateCategoryValidator } from './category.validator'
+
+@Controller(CategoryEntity.$path)
+@ApiTags(CategoryController.name)
+export default class CategoryController {
+  @Inject() protected readonly repository: CategoryRepository
+
+  @Get('/')
+  async find (): Promise<CategoryEntity[]> {
+
+    return this.repository.find()
+  }
+
+  @Get('/:id')
+  async read (@Param('id') id: string): Promise<CategoryEntity> {
+
+    return this.repository.read(id)
+  }
+
+  @Post('/')
+  @HttpCode(201)
+  async create (@Body() validator: CreateCategoryValidator): Promise<CategoryEntity> {
+
+    return this.repository.create(validator)
+  }
+
+  @Put('/:id')
+  async update (@Param('id') id: string, @Body() validator: UpdateCategoryValidator): Promise<CategoryEntity> {
+
+    return this.repository.update(id, validator)
+  }
+
+  @Delete('/:id')
+  @HttpCode(204)
+  async delete (@Param('id') id: string): Promise<void> {
+
+    return this.repository.delete(id)
+  }
+}

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

@@ -0,0 +1,4 @@
+import { ModuleMetadata } from '@nestjs/common';
+export declare const metadata: ModuleMetadata;
+export default class CategoryModule {
+}

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

@@ -0,0 +1,14 @@
+import { Module, ModuleMetadata } from '@nestjs/common'
+import CategoryController from './category.controller'
+import CategoryRepository from './category.repository'
+
+export const metadata: ModuleMetadata = {
+  imports: [],
+  controllers: [CategoryController],
+  providers: [CategoryRepository],
+  exports: []
+}
+
+@Module(metadata)
+export default class CategoryModule {
+}

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

@@ -0,0 +1,13 @@
+import AppRepository from '../../app.repository';
+import { CategoryEntity } from './category.entity';
+import { CreateCategoryValidator, UpdateCategoryValidator } from './category.validator';
+export default class CategoryRepository extends AppRepository {
+    protected readonly repositories: {
+        category: import("fireorm").BaseFirestoreRepository<CategoryEntity>;
+    };
+    find(): Promise<CategoryEntity[]>;
+    read(id: string): Promise<CategoryEntity>;
+    create(validator: CreateCategoryValidator): Promise<CategoryEntity>;
+    update(id: any, validator: UpdateCategoryValidator): Promise<CategoryEntity>;
+    delete(id: string): Promise<void>;
+}

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

@@ -0,0 +1,36 @@
+import { getRepository } from 'fireorm'
+import AppRepository from '../../app.repository'
+import { CategoryEntity } from './category.entity'
+import { CreateCategoryValidator, UpdateCategoryValidator } from './category.validator'
+
+export default class CategoryRepository extends AppRepository {
+  protected readonly repositories = {
+    category: getRepository(CategoryEntity)
+  }
+
+  public find () {
+    return this.repositories.category.find()
+  }
+
+  public read (id: string) {
+    return this.repositories.category.findById(id)
+  }
+
+  public create (validator: CreateCategoryValidator) {
+    const category = new CategoryEntity()
+    category.name = validator.name
+
+    return this.repositories.category.create(category)
+  }
+
+  public update (id, validator: UpdateCategoryValidator) {
+    const category = <CategoryEntity>{}
+    category.name = validator.name
+
+    return this.repositories.category.update(category)
+  }
+
+  public delete (id: string) {
+    return this.repositories.category.delete(id)
+  }
+}

package/src/inventory/inventory.module.d.ts

@@ -0,0 +1,4 @@
+import { ModuleMetadata } from '@nestjs/common';
+export declare const metadata: ModuleMetadata;
+export default class InventoryModule {
+}

package/src/inventory/inventory.module.ts

@@ -0,0 +1,17 @@
+import { Module, ModuleMetadata } from '@nestjs/common'
+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: []
+}
+
+@Module(metadata)
+export default class InventoryModule {
+
+}

package/src/inventory/products/media/media.controller.d.ts

@@ -0,0 +1,7 @@
+import { ProductMediaEntity } from './media.entity';
+import MediaRepository from './media.repository';
+export default class MediaController {
+    protected readonly repository: MediaRepository;
+    find(productId: string): Promise<ProductMediaEntity[]>;
+    read(productId: string, id: string): Promise<ProductMediaEntity | null>;
+}

package/src/inventory/products/media/media.controller.ts

@@ -0,0 +1,23 @@
+import { Controller, Get, Inject, Param } from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+import { ProductMediaEntity } from './media.entity'
+import MediaRepository from './media.repository'
+
+@Controller(':product/media')
+@ApiTags(MediaController.name)
+export default class MediaController {
+  @Inject() protected readonly repository: MediaRepository
+
+  @Get('/')
+  async find (@Param('product') productId: string): Promise<ProductMediaEntity[]> {
+
+    return this.repository.find(productId)
+  }
+
+  @Get('/:id')
+  async read (@Param('product') productId: string, @Param('id') id: string): Promise<ProductMediaEntity | null> {
+
+    return this.repository.read(productId, id)
+  }
+
+}

package/src/inventory/products/media/media.module.d.ts

@@ -0,0 +1,4 @@
+import { ModuleMetadata } from '@nestjs/common';
+export declare const metadata: ModuleMetadata;
+export default class MediaModule {
+}

package/src/inventory/products/media/media.module.ts

@@ -0,0 +1,14 @@
+import { Module, ModuleMetadata } from '@nestjs/common'
+import MediaController from './media.controller'
+import MediaRepository from './media.repository'
+
+export const metadata: ModuleMetadata = {
+  imports: [],
+  controllers: [MediaController],
+  providers: [MediaRepository],
+  exports: []
+}
+
+@Module(metadata)
+export default class MediaModule {
+}

package/src/inventory/products/media/media.repository.d.ts

@@ -0,0 +1,10 @@
+import AppRepository from '../../../app.repository';
+import { ProductEntity } from '../product.entity';
+import { ProductMediaEntity } from './media.entity';
+export default class MediaRepository extends AppRepository {
+    protected readonly repositories: {
+        product: import("fireorm").BaseFirestoreRepository<ProductEntity>;
+    };
+    find(productID: string): Promise<ProductMediaEntity[]>;
+    read(productID: string, id: string): Promise<ProductMediaEntity>;
+}

package/src/inventory/products/media/media.repository.ts

@@ -0,0 +1,22 @@
+import { getRepository } from 'fireorm'
+import AppRepository from '../../../app.repository'
+import { ProductEntity } from '../product.entity'
+import { ProductMediaEntity } from './media.entity'
+
+export default class MediaRepository extends AppRepository {
+  protected readonly repositories = {
+    product: getRepository(ProductEntity)
+  }
+
+  async find (productID: string): Promise<ProductMediaEntity[]> {
+    const product = await this.repositories.product.findById(productID)
+
+    return product.media.find()
+  }
+
+  async read (productID: string, id: string): Promise<ProductMediaEntity> {
+    const product = await this.repositories.product.findById(productID)
+
+    return product.media.findById(id)
+  }
+}

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

@@ -0,0 +1,12 @@
+/// <reference types="@types/multer" />
+import { ProductEntity } from './product.entity';
+import ProductRepository from './product.repository';
+import { CreateProductValidator, UpdateProductValidator } from './product.validator';
+export default class ProductController {
+    protected readonly repository: ProductRepository;
+    find(): Promise<ProductEntity[]>;
+    create(validator: CreateProductValidator, images: Express.Multer.File[]): Promise<ProductEntity>;
+    read(id: string): Promise<ProductEntity>;
+    update(validator: UpdateProductValidator, id: string): Promise<ProductEntity>;
+    delete(id: string): Promise<void>;
+}

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

@@ -0,0 +1,59 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  Inject,
+  Param,
+  Patch,
+  Post,
+  UploadedFiles,
+  UseInterceptors
+} from '@nestjs/common'
+import { FilesInterceptor } from '@nestjs/platform-express'
+import { ApiTags } from '@nestjs/swagger'
+import { Express } from 'express'
+import { ProductEntity } from './product.entity'
+import ProductRepository from './product.repository'
+import { CreateProductValidator, UpdateProductValidator } from './product.validator'
+
+@Controller(ProductEntity.$path)
+@ApiTags(ProductController.name)
+export default class ProductController {
+  @Inject() protected readonly repository: ProductRepository
+
+  @Get('/')
+  async find (): Promise<ProductEntity[]> {
+
+    return this.repository.find()
+  }
+
+  @Post('/')
+  @UseInterceptors(FilesInterceptor('images'))
+  async create (@Body() validator: CreateProductValidator, @UploadedFiles() images: Express.Multer.File[]): Promise<ProductEntity> {
+
+    return this.repository.create(validator, images)
+  }
+
+  @Get('/:id')
+  async read (@Param('id') id: string): Promise<ProductEntity> {
+
+    return this.repository.read(id)
+  }
+
+  @Patch('/:id')
+  @UseInterceptors(FilesInterceptor('images'))
+  async update (@Body() validator: UpdateProductValidator, @Param('id') id: string): Promise<ProductEntity> {
+
+    return this.repository.update(id, validator)
+  }
+
+  @Delete('/:id')
+  @HttpCode(204)
+  async delete (@Param('id') id: string): Promise<void> {
+
+    return this.repository.delete(id)
+  }
+
+}

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

@@ -0,0 +1,4 @@
+import { ModuleMetadata } from '@nestjs/common';
+export declare const metadata: ModuleMetadata;
+export default class ProductModule {
+}