@node-c/api-rest 1.0.0-alpha37 → 1.0.0-alpha39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@node-c/api-rest",
-  "version": "1.0.0-alpha37",
+  "version": "1.0.0-alpha39",
   "license": "MIT",
   "main": "dist/index.js",
   "scripts": {
@@ -18,7 +18,7 @@
     "class-validator": "^0.14.1"
   },
   "peerDependencies": {
-    "@node-c/api-http": "^1.0.0-alpha37",
-    "@node-c/core": "^1.0.0-alpha37"
+    "@node-c/api-http": "^1.0.0-alpha39",
+    "@node-c/core": "^1.0.0-alpha39"
   }
 }

package/src/entityController/dto/base.dto.ts

@@ -1,17 +0,0 @@
-import { DomainBaseAdditionalServiceOptionsOverrides, DomainPersistanceServicesKey, GenericObject } from '@node-c/core';
-
-import { IsArray, IsNotEmptyObject, IsObject, IsOptional } from 'class-validator';
-
-/*
- * We need the Options type here, so we can easily extend overriden classes' BaseDto
- */
-export class BaseDto<Options> {
-  @IsNotEmptyObject()
-  @IsObject()
-  @IsOptional()
-  optionsOverridesByService?: GenericObject<Partial<Options>> & DomainBaseAdditionalServiceOptionsOverrides;
-
-  @IsArray()
-  @IsOptional()
-  persistanceServices?: DomainPersistanceServicesKey[];
-}

package/src/entityController/dto/bulkCreate.dto.ts

@@ -1,15 +0,0 @@
-import { ArrayNotEmpty, IsArray, IsDefined } from 'class-validator';
-
-import { BaseDto } from './base.dto';
-
-import { BulkCreateBody, BulkCreateOptions } from '../rest.entity.controller.definitions';
-
-export class BulkCreateDto<Entity, Options extends BulkCreateOptions<Entity>>
-  extends BaseDto<Options>
-  implements BulkCreateBody<Entity>
-{
-  @ArrayNotEmpty()
-  @IsArray()
-  @IsDefined()
-  data: Partial<Entity>[];
-}

package/src/entityController/dto/create.dto.ts

@@ -1,15 +0,0 @@
-import { IsDefined, IsNotEmptyObject, IsObject } from 'class-validator';
-
-import { BaseDto } from './base.dto';
-
-import { CreateBody, CreateOptions } from '../rest.entity.controller.definitions';
-
-export class CreateDto<Entity, Options extends CreateOptions<Entity>>
-  extends BaseDto<Options>
-  implements CreateBody<Entity>
-{
-  @IsDefined()
-  @IsNotEmptyObject()
-  @IsObject()
-  data: Partial<Entity>;
-}

package/src/entityController/dto/delete.dto.ts

@@ -1,12 +0,0 @@
-import { DomainDeleteOptions, GenericObject } from '@node-c/core';
-
-import { IsDefined, IsNotEmptyObject, IsObject } from 'class-validator';
-
-import { BaseDto } from './base.dto';
-
-export class DeleteDto<Options extends DomainDeleteOptions> extends BaseDto<Options> implements DomainDeleteOptions {
-  @IsDefined()
-  @IsNotEmptyObject()
-  @IsObject()
-  filters: GenericObject<unknown>;
-}

package/src/entityController/dto/find.dto.ts

@@ -1,37 +0,0 @@
-import { DomainFindOptions, GenericObject, PersistanceOrderByDirection } from '@node-c/core';
-
-import { IsArray, IsBooleanString, IsNotEmptyObject, IsNumberString, IsObject, IsOptional } from 'class-validator';
-
-import { BaseDto } from './base.dto';
-
-export class FindDto<Options extends DomainFindOptions> extends BaseDto<Options> implements DomainFindOptions {
-  @IsNotEmptyObject()
-  @IsObject()
-  @IsOptional()
-  filters?: GenericObject;
-
-  @IsBooleanString()
-  @IsOptional()
-  findAll?: boolean;
-
-  @IsArray()
-  @IsOptional()
-  include?: string[];
-
-  @IsObject()
-  @IsOptional()
-  @IsNotEmptyObject()
-  orderBy?: GenericObject<PersistanceOrderByDirection>;
-
-  @IsNumberString()
-  @IsOptional()
-  page?: number;
-
-  @IsNumberString()
-  @IsOptional()
-  perPage?: number;
-
-  @IsArray()
-  @IsOptional()
-  select?: string[];
-}

package/src/entityController/dto/findOne.dto.ts

@@ -1,24 +0,0 @@
-import { DomainFindOneOptions, GenericObject, PersistanceOrderByDirection } from '@node-c/core';
-
-import { IsArray, IsNotEmptyObject, IsObject, IsOptional } from 'class-validator';
-
-import { BaseDto } from './base.dto';
-
-export class FindOneDto<Options extends DomainFindOneOptions> extends BaseDto<Options> implements DomainFindOneOptions {
-  @IsNotEmptyObject()
-  @IsObject()
-  filters: GenericObject<unknown>;
-
-  @IsArray()
-  @IsOptional()
-  include?: string[];
-
-  @IsNotEmptyObject()
-  @IsObject()
-  @IsOptional()
-  orderBy?: GenericObject<PersistanceOrderByDirection>;
-
-  @IsArray()
-  @IsOptional()
-  select?: string[];
-}

package/src/entityController/dto/index.ts

@@ -1,9 +0,0 @@
-export * from './base.dto';
-export * from './bulkCreate.dto';
-export * from './create.dto';
-export * from './delete.dto';
-export * from './find.dto';
-export * from './findOne.dto';
-export * from './numberItem.dto';
-export * from './update.dto';
-export * from './uploadFile.dto';

package/src/entityController/dto/numberItem.dto.ts

@@ -1,12 +0,0 @@
-import { PersistanceNumberItem } from '@node-c/core';
-import { IsBoolean, IsDefined, IsNumber, IsOptional } from 'class-validator';
-
-export class NumberItemDto implements PersistanceNumberItem {
-  @IsOptional()
-  @IsBoolean()
-  deleted?: boolean;
-
-  @IsDefined()
-  @IsNumber()
-  value: number;
-}

package/src/entityController/dto/update.dto.ts

@@ -1,26 +0,0 @@
-import { GenericObject } from '@node-c/core';
-
-import { IsBoolean, IsDefined, IsNotEmptyObject, IsObject, IsOptional } from 'class-validator';
-
-import { BaseDto } from './base.dto';
-
-import { UpdateBody, UpdateOptions } from '../rest.entity.controller.definitions';
-
-export class UpdateDto<Entity, Options extends UpdateOptions<Entity>>
-  extends BaseDto<Options>
-  implements UpdateBody<Entity>
-{
-  @IsDefined()
-  @IsNotEmptyObject()
-  @IsObject()
-  data: Partial<Entity>;
-
-  @IsDefined()
-  @IsNotEmptyObject()
-  @IsObject()
-  filters: GenericObject<unknown>;
-
-  @IsOptional()
-  @IsBoolean()
-  returnData?: boolean;
-}

package/src/entityController/dto/uploadFile.dto.ts

@@ -1,12 +0,0 @@
-import { IsMimeType, IsNotEmpty, IsString } from 'class-validator';
-
-export class UploadFileDto {
-  @IsMimeType()
-  @IsNotEmpty()
-  @IsString()
-  contentType: string;
-
-  @IsNotEmpty()
-  @IsString()
-  name: string;
-}

package/src/entityController/index.ts

@@ -1,3 +0,0 @@
-export * from './dto';
-export * from './rest.entity.controller';
-export * from './rest.entity.controller.definitions';

package/src/entityController/rest.entity.controller.definitions.ts

@@ -1,28 +0,0 @@
-import {
-  DomainBulkCreateData,
-  DomainBulkCreateOptions,
-  DomainCreateData,
-  DomainCreateOptions,
-  DomainUpdateData,
-  DomainUpdateOptions,
-  GenericObject
-} from '@node-c/core';
-
-export interface BulkCreateBody<Entity> extends DomainBulkCreateOptions {
-  data: DomainBulkCreateData<Entity>;
-}
-
-export type BulkCreateOptions<Entity> = Omit<BulkCreateBody<Entity>, 'data'>;
-
-export interface CreateBody<Entity> extends DomainCreateOptions {
-  data: DomainCreateData<Entity>;
-}
-
-export type CreateOptions<Entity> = Omit<CreateBody<Entity>, 'data'>;
-
-export interface UpdateBody<Entity> extends DomainUpdateOptions {
-  data: DomainUpdateData<Entity>;
-  filters: GenericObject<unknown>;
-}
-
-export type UpdateOptions<Entity> = Omit<UpdateBody<Entity>, 'data'>;

package/src/entityController/rest.entity.controller.ts

@@ -1,282 +0,0 @@
-import {
-  Body,
-  Delete,
-  Get,
-  HttpException,
-  HttpStatus,
-  Param,
-  Patch,
-  Post,
-  Query,
-  Type,
-  UseInterceptors,
-  ValidationPipe
-} from '@nestjs/common';
-
-import { HTTPAuthorizationInterceptor, HTTPErrorInterceptor } from '@node-c/api-http';
-
-import {
-  DomainBulkCreateResult,
-  DomainCreateResult,
-  DomainDeleteOptions,
-  DomainDeleteResult,
-  DomainEntityService,
-  DomainEntityServiceDefaultData,
-  DomainFindOneOptions,
-  DomainFindOneResult,
-  DomainFindOptions,
-  DomainFindResult,
-  DomainUpdateResult,
-  PersistanceEntityService
-} from '@node-c/core';
-
-import {
-  BulkCreateDto as BaseBulkCreateDto,
-  CreateDto as BaseCreateDto,
-  DeleteDto as BaseDeleteDto,
-  FindDto as BaseFindDto,
-  FindOneDto as BaseFindOneDto,
-  UpdateDto as BaseUpdateDto
-} from './dto';
-import {
-  BulkCreateBody,
-  BulkCreateOptions,
-  CreateBody,
-  CreateOptions,
-  UpdateBody,
-  UpdateOptions
-} from './rest.entity.controller.definitions';
-
-// These types and interfaces have to be here to avoid circular dependencies.
-export type DefaultDomainEntityService<Entity> = DomainEntityService<
-  Entity,
-  PersistanceEntityService<Entity>,
-  DomainEntityServiceDefaultData<Entity>,
-  Record<string, PersistanceEntityService<Partial<Entity>>>
->;
-
-export interface DefaultDtos<Entity> {
-  BulkCreate: BaseBulkCreateDto<Entity, BulkCreateOptions<Entity>>;
-  Create: BaseCreateDto<Entity, CreateOptions<Entity>>;
-  Delete: BaseDeleteDto<DomainDeleteOptions>;
-  Find: BaseFindDto<DomainFindOptions>;
-  FindOne: BaseFindOneDto<DomainFindOneOptions>;
-  Update: BaseUpdateDto<Entity, UpdateOptions<Entity>>;
-}
-
-// TODO: a middleware for converting string booleans to booleans
-@UseInterceptors(HTTPAuthorizationInterceptor, HTTPErrorInterceptor)
-export class RESTAPIEntityControlerWithoutDto<Entity, EntityDomainService extends DefaultDomainEntityService<Entity>> {
-  inUseDefaultRoutes: { [handlerName: string]: boolean };
-
-  constructor(
-    // eslint-disable-next-line no-unused-vars
-    protected domainEntityService: EntityDomainService,
-    // eslint-disable-next-line no-unused-vars
-    protected defaultRouteMethods?: string[]
-  ) {
-    this.refreshDefaultRoutes();
-  }
-
-  protected checkRoute(handlerName: string): void {
-    if (!this.inUseDefaultRoutes || !this.inUseDefaultRoutes[handlerName]) {
-      throw new HttpException('Not found', HttpStatus.NOT_FOUND);
-    }
-  }
-
-  public bulkCreate(_body: BulkCreateBody<Entity>, ..._args: unknown[]): Promise<DomainBulkCreateResult<Entity> | void>;
-  @Post('bulk')
-  async bulkCreate(@Body() body: BulkCreateBody<Entity>): Promise<DomainBulkCreateResult<Entity>> {
-    this.checkRoute('bulkCreate');
-    const { data, ...options } = body;
-    return await this.domainEntityService.bulkCreate(data, options);
-  }
-
-  public create(_body: CreateBody<Entity>, ..._args: unknown[]): Promise<DomainCreateResult<Entity> | void>;
-  @Post()
-  async create(@Body() body: CreateBody<Entity>): Promise<DomainCreateResult<Entity>> {
-    this.checkRoute('create');
-    const { data, ...options } = body;
-    return await this.domainEntityService.create(data, options);
-  }
-
-  public delete(_body: DomainDeleteOptions, ..._args: unknown[]): Promise<DomainDeleteResult<Entity> | void>;
-  @Delete()
-  async delete(@Body() body: DomainDeleteOptions): Promise<DomainDeleteResult<Entity>> {
-    this.checkRoute('delete');
-    return await this.domainEntityService.delete(body);
-  }
-
-  public find(_query: DomainFindOptions, ..._args: unknown[]): Promise<DomainFindResult<Entity> | void>;
-  @Get()
-  async find(@Query() query: DomainFindOptions): Promise<DomainFindResult<Entity> | void> {
-    this.checkRoute('find');
-    return await this.domainEntityService.find(query);
-  }
-
-  public findOne(
-    _id: number | string,
-    _query: DomainFindOneOptions,
-    ..._args: unknown[]
-  ): Promise<DomainFindOneResult<Entity> | void>;
-  @Get('/item/:id')
-  async findOne(
-    @Param() id: number | string,
-    @Query() query: DomainFindOneOptions
-  ): Promise<DomainFindOneResult<Entity> | void> {
-    this.checkRoute('findOne');
-    let filters = query.filters;
-    if (!filters) {
-      filters = {};
-      query.filters = filters;
-    }
-    filters.id = id;
-    return await this.domainEntityService.findOne(query);
-  }
-
-  refreshDefaultRoutes(newDefaultRoutes?: string[]): void {
-    const defaultRouteMethods = newDefaultRoutes || this.defaultRouteMethods;
-    this.inUseDefaultRoutes = {};
-    if (defaultRouteMethods instanceof Array) {
-      defaultRouteMethods.forEach(item => (this.inUseDefaultRoutes[item] = true));
-    }
-  }
-
-  public update(_body: UpdateBody<Entity>, ..._args: unknown[]): Promise<DomainUpdateResult<Entity> | void>;
-  @Patch()
-  async update(@Body() body: UpdateBody<Entity>): Promise<DomainUpdateResult<Entity>> {
-    this.checkRoute('update');
-    const { data, ...options } = body;
-    return await this.domainEntityService.update(data, options);
-  }
-}
-
-/*
- * For reference on why the dto validation was done in this way - it's a limitation of Typescript itself:
- * the compiler doesn't emit generic type metadata, making it impossible to achieve a DRY OOP base class with schema validation.
- * At this point, it's a decade-old issue - see https://www.typescriptneedstypes.com/ for more details.
- */
-export class RESTAPIEntityControler<
-  Entity,
-  EntityDomainService extends DefaultDomainEntityService<Entity>,
-  Dto extends DefaultDtos<Entity> = DefaultDtos<Entity>
-> extends RESTAPIEntityControlerWithoutDto<Entity, EntityDomainService> {
-  protected defaultRouteMethods: string[];
-  protected settings: { validationWhitelist?: boolean } = { validationWhitelist: true };
-  protected validationPipe: ValidationPipe;
-
-  constructor(
-    protected domainEntityService: EntityDomainService,
-    protected dto: {
-      bulkCreate?: Dto['BulkCreate'];
-      create?: Dto['Create'];
-      delete?: Dto['Delete'];
-      find?: Dto['Find'];
-      findOne?: Dto['FindOne'];
-      update?: Dto['Update'];
-    },
-    defaultRouteMethods?: string[]
-  ) {
-    super(domainEntityService, Object.keys(dto || {}).concat(defaultRouteMethods || []));
-    // const finalDto: typeof dto = {};
-    // finalDto.bulkCreate = dto?.bulkCreate || BaseBulkCreateDto<Entity, BulkCreateOptions<Entity>>;
-    const { validationWhitelist } = this.settings;
-    this.validationPipe = new ValidationPipe({ whitelist: validationWhitelist });
-  }
-
-  @Post('bulk')
-  async bulkCreate(
-    @Body() body: Dto['BulkCreate'],
-    ...args: unknown[]
-  ): Promise<DomainBulkCreateResult<Entity> | void> {
-    return await super.bulkCreate.apply(this, [
-      await this.validationPipe.transform(body, {
-        metatype: this.dto.bulkCreate as unknown as Type,
-        type: 'body'
-      }),
-      ...(args || [])
-    ]);
-  }
-
-  @Post()
-  async create(
-    @Body()
-    body: Dto['Create'],
-    ...args: unknown[]
-  ): Promise<DomainCreateResult<Entity> | void> {
-    return await super.create.apply(this, [
-      await this.validationPipe.transform(body, {
-        metatype: this.dto.create as unknown as Type,
-        type: 'body'
-      }),
-      ...(args || [])
-    ]);
-  }
-
-  @Delete()
-  async delete(@Body() body: Dto['Delete'], ...args: unknown[]): Promise<DomainDeleteResult<Entity> | void> {
-    return await super.delete.apply(this, [
-      await this.validationPipe.transform(body, {
-        metatype: this.dto.delete as unknown as Type,
-        type: 'body'
-      }),
-      ...(args || [])
-    ]);
-  }
-
-  @Get()
-  async find(@Query() query: Dto['Find'], ...args: unknown[]): Promise<DomainFindResult<Entity> | void> {
-    return await super.find.apply(this, [
-      await this.validationPipe.transform(query, {
-        metatype: this.dto.find as unknown as Type,
-        type: 'query'
-      }),
-      ...(args || [])
-    ]);
-  }
-
-  @Get('/item/:id')
-  async findOne(
-    @Param() id: number | string,
-    @Query() query: Dto['FindOne'],
-    ...args: unknown[]
-  ): Promise<DomainFindOneResult<Entity> | void> {
-    return await super.findOne.apply(this, [
-      id,
-      await this.validationPipe.transform(query, {
-        metatype: this.dto.findOne as unknown as Type,
-        type: 'query'
-      }),
-      ...(args || [])
-    ]);
-  }
-
-  static getDefaultDtos<EntityForDtos>(): {
-    bulkCreate: DefaultDtos<EntityForDtos>['BulkCreate'];
-    create: DefaultDtos<EntityForDtos>['Create'];
-    delete: DefaultDtos<EntityForDtos>['Delete'];
-    find: DefaultDtos<EntityForDtos>['Find'];
-    findOne: DefaultDtos<EntityForDtos>['FindOne'];
-    update: DefaultDtos<EntityForDtos>['Update'];
-  } {
-    return {
-      bulkCreate: BaseBulkCreateDto as unknown as DefaultDtos<EntityForDtos>['BulkCreate'],
-      create: BaseCreateDto as unknown as DefaultDtos<EntityForDtos>['Create'],
-      delete: BaseDeleteDto as unknown as DefaultDtos<EntityForDtos>['Delete'],
-      find: BaseFindDto as unknown as DefaultDtos<EntityForDtos>['Find'],
-      findOne: BaseFindOneDto as unknown as DefaultDtos<EntityForDtos>['FindOne'],
-      update: BaseUpdateDto as unknown as DefaultDtos<EntityForDtos>['Update']
-    };
-  }
-
-  @Patch()
-  async update(@Body() body: Dto['Update'], ...args: unknown[]): Promise<DomainUpdateResult<Entity> | void> {
-    return await super.update.apply(this, [
-      await this.validationPipe.transform(body, {
-        metatype: this.dto.update as unknown as Type,
-        type: 'body'
-      }),
-      ...(args || [])
-    ]);
-  }
-}

package/src/index.ts

@@ -1 +0,0 @@
-export * from './entityController';