@nest-omni/core 1.0.21 → 1.0.24

package/.hygen/new/crud/controller.ejs.t

@@ -0,0 +1,82 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.controllerFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('Controller') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ moduleName = h.moduleName(name);
+ fileName = h.fileName(name);
+ ControllerName = h.ControllerName(name);
+ ServiceName = h.ServiceName(name);
+ serviceName = h.changeCase.camel(ServiceName);
+ createFunctionName = 'create' + ClassName;
+ updateFunctionName = 'update' + ClassName;
+ deleteFunctionName = 'delete' + ClassName;
+ getAllFunctionName = 'getAll' + ClassName;
+ getSingleFunctionName = 'getSingle' + ClassName;
+ CreateDtoName = h.CreateDtoName(name);
+ createDtoName = h.changeCase.camel(CreateDtoName);
+ UpdateDtoName = h.UpdateDtoName(name);
+ updateDtoName = h.changeCase.camel(UpdateDtoName);
+ PageOptionsDtoName = h.PageOptionsDtoName(name);
+ pageOptionsDtoName = h.changeCase.camel(PageOptionsDtoName);
+ DtoName = h.DtoName(name);
+ createDtoFileName = h.createDtoFileName(name);
+ dtoFileName = h.dtoFileName(name);
+ pageOptionsDtoFileName = h.pageOptionsDtoFileName(name);
+ updateDtoFileName = h.updateDtoFileName(name);
+ serviceFileName = h.serviceFileName(name);
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ entityFileName = h.entityFileName(name);
+ GetDtoName = 'Get' + DtoName;
+ getDtoFileName = 'get-' + dtoFileName;
+
+%>import { Body, Controller, Delete, Put, Post } from '@nestjs/common';
+import { ApiBody, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { Crud } from '@dataui/crud';
+
+import { <%= EntityName %> } from './<%= entityFileName %>';
+import { <%= ServiceName %> } from './<%= serviceFileName %>';
+
+import { dto } from './requests';
+import { serialize } from './responses';
+import { targetConstructorToSchema } from '@nest-omni/core/validator-json';
+import { I18nService } from 'nestjs-i18n';
+import { BulkIdDto } from '@nest-omni/core/common/dto/bulk-id.dto';
+
+@Crud({
+  model: { type: <%= EntityName %> },
+  dto,
+  serialize,
+  query: {
+    alwaysPaginate: true,
+  },
+})
+@Controller('<%= h.inflection.pluralize(fileName).toLowerCase() %>')
+@ApiTags('<%= h.inflection.pluralize(fileName).toLowerCase() %>')
+export class <%= ControllerName %> {
+  constructor(
+    public service: <%= ServiceName %>,
+    public i18n: I18nService,
+  ) {}
+
+  @Post('validator')
+  async getCreateRules(): Promise<any> {
+    return targetConstructorToSchema(dto.create, this.i18n);
+  }
+
+  @Put('validator')
+  async getUpdateRules(): Promise<any> {
+    return targetConstructorToSchema(dto.update, this.i18n);
+  }
+
+  @Delete('/bulk')
+  @ApiBody({ type: BulkIdDto })
+  @ApiOperation({ summary: 'bulk deletion of records' })
+  async deleteBulk(@Body() bulkId: BulkIdDto) {
+    return await this.service.deleteBulk(bulkId);
+  }
+}

package/.hygen/new/crud/create.dto.ejs.t

@@ -0,0 +1,12 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/requests/<%= h.createDtoFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('CreateDTO') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ CreateDtoName = h.CreateDtoName(name);
+
+%>import { <%= EntityName %> } from '../<%= entityFileName %>';
+export class <%= CreateDtoName %> extends <%= EntityName %> {}

package/.hygen/new/crud/entity.ejs.t

@@ -0,0 +1,25 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.entityFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('Entity') %>
+---
+<%
+ ClassName = h.ClassName(name);
+ DtoName = h.DtoName(name);
+ fieldName = h.changeCase.camel(ClassName);
+ dtoFileName = h.dtoFileName(name);
+ translationEntityFileName = h.translationEntityFileName(name);
+ DtoOptionName = h.DtoOptionName(name);
+ TableName = h.TableName(name);
+ EntityName = h.EntityName(name);
+ TranslationEntityName = h.TranslationEntityName(name);
+ translationEntityName = h.changeCase.camel(TranslationEntityName);
+%>import { Entity, Column } from 'typeorm';
+
+import { AbstractEntity } from '@nest-omni/core/common/abstract.entity';
+
+@Entity({ name: '<%= TableName %>' })
+export class <%= EntityName %> extends AbstractEntity {
+  @Column({ type: 'varchar', nullable: false })
+  name: string;
+}

package/.hygen/new/crud/get.dto.ejs.t

@@ -0,0 +1,19 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/responses/get-<%= h.dtoFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('DTO') %>
+---
+<%
+
+ DtoName = h.DtoName(name);
+ DtoOptionName = h.DtoOptionName(name);
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ entityFileName = h.entityFileName(name);
+
+  GetDtoName = 'Get' + DtoName;
+  getDtoFileName = 'get-' + dtoFileName;
+
+%>import { <%= EntityName %> } from '../<%= entityFileName %>';
+
+export class <%= GetDtoName %> extends <%= EntityName %> {}

package/.hygen/new/crud/index-dto.ejs.t

@@ -0,0 +1,29 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/requests/index.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('DTO') %>
+---
+<%
+
+ DtoName = h.DtoName(name);
+ DtoOptionName = h.DtoOptionName(name);
+
+ CreateDtoName = h.CreateDtoName(name);
+ createDtoName = h.changeCase.camel(CreateDtoName);
+ UpdateDtoName = h.UpdateDtoName(name);
+ updateDtoName = h.changeCase.camel(UpdateDtoName);
+
+ createDtoFileName = h.createDtoFileName(name);
+ updateDtoFileName = h.updateDtoFileName(name);
+
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ entityFileName = h.entityFileName(name);
+
+%>import { <%= CreateDtoName %> } from './<%= createDtoFileName %>';
+import { <%= UpdateDtoName %> } from './<%= updateDtoFileName %>';
+
+export const dto = {
+  create: <%= CreateDtoName %>,
+  update: <%= UpdateDtoName %>,
+};

package/.hygen/new/crud/index-response.dto.ejs.t

@@ -0,0 +1,18 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/responses/index.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('DTO') %>
+---
+<%
+
+ DtoName = h.DtoName(name);
+ dtoFileName = h.dtoFileName(name);
+
+ GetDtoName = 'Get' + DtoName;
+ getDtoFileName = 'get-' + dtoFileName;
+
+%>import { <%= GetDtoName %> } from './<%= getDtoFileName %>';
+
+export const serialize = {
+  get: <%= GetDtoName %>,
+};

package/.hygen/new/crud/module.ejs.t

@@ -0,0 +1,32 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.moduleFileName(name) %>.ts"
+unless_exists: true
+---
+<%
+
+ ModuleName = h.ModuleName(name);
+ fileName = h.inflection.dasherize(name);
+
+ ControllerName = h.ControllerName(name);
+ controllerFileName = h.controllerFileName(name);
+
+ ServiceName = h.ServiceName(name);
+ serviceFileName = h.serviceFileName(name);
+
+  EntityName = h.EntityName(name);
+  entityName = h.changeCase.camel(EntityName);
+  entityFileName = h.entityFileName(name);
+
+%>import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { <%= ControllerName %> } from './<%= controllerFileName %>';
+import { <%= EntityName %> } from './<%= entityFileName %>';
+import { <%= ServiceName %> } from './<%= serviceFileName %>';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([<%= EntityName %>])],
+  providers: [<%= ServiceName %>],
+  controllers: [<%= ControllerName %>],
+})
+export class <%= ModuleName %> {}

package/.hygen/new/crud/prompt.js

@@ -0,0 +1,89 @@
+'use strict'
+
+module.exports = {
+  prompt: ({ prompter, args }) => {
+    return prompter.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: 'Name:',
+        validate(value) {
+          if (!value.length) {
+            return 'Module must have a name.';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'MultiSelect',
+        name: 'blocks',
+        message: 'Blocks:',
+        initial: [
+          'Controller',
+          'CreateCommand',
+          'CreateDTO',
+          'DTO',
+          'Entity',
+          'GetQuery',
+          //'Module',
+          // 'NotFoundException',
+          'PageOptionsDTO',
+          'Repository',
+          'Service',
+          'UpdateDTO'
+        ],
+        choices: [
+          {
+            name: 'Controller',
+            value: 'controller',
+          },
+          {
+            name: 'CreateCommand',
+            value: 'create-command',
+          },
+          {
+            name: 'CreateDTO',
+            value: 'create-dto',
+          },
+          {
+            name: 'DTO',
+            value: 'dto',
+          },
+          {
+            name: 'Entity',
+            value: 'entity',
+          },
+          {
+            name: 'GetQuery',
+            value: 'get-query',
+          },
+          {
+            name: 'NotFoundException',
+            value: 'not-found-exception',
+          },
+          {
+            name: 'PageOptionsDTO',
+            value: 'page-options-dto',
+          },
+          {
+            name: 'Repository',
+            value: 'repository',
+          },
+          {
+            name: 'Service',
+            value: 'service',
+          },
+          {
+            name: 'UpdateDTO',
+            value: 'update-dto',
+          },
+        ],
+      }
+    ])
+    .then(answer => {
+      //// For debugging
+      // console.log(answer)
+      return answer;
+    })
+  }
+}

package/.hygen/new/crud/service.ejs.t

@@ -0,0 +1,76 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.serviceFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('Service') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ fieldName = h.changeCase.camel(ClassName);
+
+ DtoName = h.DtoName(name);
+ dtoFileName = h.dtoFileName(name);
+
+
+ CreateCommandName = h.CreateCommandName(name);
+ createCommandFileName = h.createCommandFileName(name);
+
+
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ entityFileName = h.entityFileName(name);
+
+ ServiceName = h.ServiceName(name);
+
+ UpdateDtoName = h.UpdateDtoName(name);
+ updateDtoFileName = h.updateDtoFileName(name);
+ updateDtoName = h.changeCase.camel(UpdateDtoName);
+
+ fileName = h.fileName(name);
+
+ RepositoryName = h.RepositoryName(name);
+ repositoryName = h.changeCase.camel(RepositoryName);
+ repositoryFileName = h.repositoryFileName(name);
+
+ NotFoundExceptionName = h.NotFoundExceptionName(name);
+ notFoundExceptionFileName = h.notFoundExceptionFileName(name);
+
+ createFunctionName = 'create' + ClassName;
+ updateFunctionName = 'update' + ClassName;
+ deleteFunctionName = 'delete' + ClassName;
+ getAllFunctionName = 'getAll' + ClassName;
+ getSingleFunctionName = 'getSingle' + ClassName;
+ controllerName = moduleName + 'Controller';
+ serviceName = moduleName + 'Service';
+ CreateDtoName = h.CreateDtoName(name);
+ createDtoFileName = h.createDtoFileName(name);
+
+ PageOptionsDtoName = h.PageOptionsDtoName(name);
+ pageOptionsDtoName = h.changeCase.camel(PageOptionsDtoName);
+ pageOptionsDtoFileName = h.pageOptionsDtoFileName(name);
+
+%>import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { TypeOrmCrudService } from '@dataui/crud-typeorm';
+import { I18nService } from 'nestjs-i18n';
+import { BulkIdDto } from '@nest-omni/core/common/dto/bulk-id.dto';
+import { Repository } from 'typeorm';
+import { <%= EntityName %> } from './<%= entityFileName %>';
+
+@Injectable()
+export class <%= ServiceName %> extends TypeOrmCrudService<<%= EntityName %>> {
+  constructor(
+    @InjectRepository(<%= EntityName %>) repo:Repository<<%= EntityName %>>,
+    public i18n: I18nService,
+  ) {
+    super(repo);
+  }
+
+  async deleteBulk(bulkIdDto: BulkIdDto) {
+    return this.repo
+      .createQueryBuilder()
+      .delete()
+      .andWhereInIds(bulkIdDto.id)
+      .execute();
+  }
+}

package/.hygen/new/crud/update.dto.ejs.t

@@ -0,0 +1,11 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/requests/<%= h.updateDtoFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('UpdateDTO') %>
+---
+<%
+
+UpdateDtoName = h.UpdateDtoName(name);
+
+%>import { <%= EntityName %> } from '../<%= entityFileName %>';
+export class <%= UpdateDtoName %> extends <%= EntityName %> {}

package/.hygen/new/module/controller.ejs.t

@@ -0,0 +1,93 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.controllerFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('Controller') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ moduleName = h.moduleName(name);
+ fileName = h.fileName(name);
+ ControllerName = h.ControllerName(name);
+ ServiceName = h.ServiceName(name);
+ serviceName = h.changeCase.camel(ServiceName);
+ createFunctionName = 'create' + ClassName;
+ updateFunctionName = 'update' + ClassName;
+ deleteFunctionName = 'delete' + ClassName;
+ getAllFunctionName = 'getAll' + ClassName;
+ getSingleFunctionName = 'getSingle' + ClassName;
+ CreateDtoName = h.CreateDtoName(name);
+ createDtoName = h.changeCase.camel(CreateDtoName);
+ UpdateDtoName = h.UpdateDtoName(name);
+ updateDtoName = h.changeCase.camel(UpdateDtoName);
+ PageOptionsDtoName = h.PageOptionsDtoName(name);
+ pageOptionsDtoName = h.changeCase.camel(PageOptionsDtoName);
+ DtoName = h.DtoName(name);
+ createDtoFileName = h.createDtoFileName(name);
+ dtoFileName = h.dtoFileName(name);
+ pageOptionsDtoFileName = h.pageOptionsDtoFileName(name);
+ updateDtoFileName = h.updateDtoFileName(name);
+ serviceFileName = h.serviceFileName(name);
+
+%>import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Post,
+  Put,
+  Query,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+
+import type { PageDto } from '@omni/core/common/dto/page.dto';
+import { <%= CreateDtoName %> } from './dtos/<%= createDtoFileName %>';
+import type { <%= DtoName %> } from './dtos/<%= dtoFileName %>';
+import { <%= PageOptionsDtoName %> } from './dtos/<%= pageOptionsDtoFileName %>';
+import { <%= UpdateDtoName %> } from './dtos/<%= updateDtoFileName %>';
+import { <%= ServiceName %> } from './<%= serviceFileName %>';
+
+@Controller('<%= h.inflection.pluralize(fileName).toLowerCase() %>')
+@ApiTags('<%= h.inflection.pluralize(fileName).toLowerCase() %>')
+export class <%= ControllerName %> {
+  constructor(private <%= serviceName %>: <%= ServiceName %>) {}
+
+  @Post()
+  @HttpCode(HttpStatus.CREATED)
+  async <%= createFunctionName %>(@Body() <%= createDtoName %>: <%= CreateDtoName %>) {
+    const entity = await this.<%= serviceName %>.<%= createFunctionName %>(<%= createDtoName %>);
+
+    return entity.toDto();
+  }
+
+  @Get()
+  @HttpCode(HttpStatus.OK)
+  <%= getAllFunctionName %>(@Query() <%= pageOptionsDtoName %>: <%= PageOptionsDtoName %>): Promise<PageDto<<%= DtoName %>>> {
+    return this.<%= serviceName %>.<%= getAllFunctionName %>(<%= pageOptionsDtoName %>);
+  }
+
+  @Get(':id')
+  @HttpCode(HttpStatus.OK)
+  async <%= getSingleFunctionName %>(@UUIDParam('id') id: Uuid): Promise<<%= DtoName %>> {
+    const entity = await this.<%= serviceName %>.<%= getSingleFunctionName %>(id);
+
+    return entity.toDto();
+  }
+
+  @Put(':id')
+  @HttpCode(HttpStatus.ACCEPTED)
+  <%= updateFunctionName %>(
+    @UUIDParam('id') id: Uuid,
+    @Body() <%= updateDtoName %>: <%= UpdateDtoName %>,
+  ): Promise<void> {
+    return this.<%= serviceName %>.<%= updateFunctionName %>(id, <%= updateDtoName %>);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.ACCEPTED)
+  async <%= deleteFunctionName %>(@UUIDParam('id') id: Uuid): Promise<void> {
+    await this.<%= serviceName %>.<%= deleteFunctionName %>(id);
+  }
+}

package/.hygen/new/module/create-command.ejs.t

@@ -0,0 +1,90 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/commands/<%= h.createCommandFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('CreateCommand') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ fieldName = h.changeCase.camel(ClassName);
+
+ CreateCommandName = h.CreateCommandName(name);
+ CreateHandlerName = h.CreateHandlerName(name);
+
+ CreateDtoName = h.CreateDtoName(name);
+ createDtoName = h.changeCase.camel(CreateDtoName);
+ createDtoFileName = h.createDtoFileName(name);
+
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ entityFileName = h.entityFileName(name);
+
+ RepositoryName = h.RepositoryName(name);
+ TranslationRepositoryName = h.TranslationRepositoryName(name);
+ repositoryName = h.changeCase.camel(RepositoryName);
+ translationRepositoryName = h.changeCase.camel(TranslationRepositoryName);
+ repositoryFileName = h.repositoryFileName(name);
+
+ TranslationEntityName = h.TranslationEntityName(name);
+ TranslationDtoName = h.TranslationDtoName(name);
+ translationEntityFileName = h.translationEntityFileName(name);
+ translationRepositoryFileName = h.translationRepositoryFileName(name);
+ translationEntityName = h.changeCase.camel(TranslationEntityName);
+
+%>import type { ICommand, ICommandHandler } from '@nestjs/cqrs';
+import { CommandHandler } from '@nestjs/cqrs';
+import { find } from 'lodash';
+
+import type { <%= CreateDtoName %> } from '../dtos/<%= createDtoFileName %>';
+import type { <%= EntityName %> } from '../<%= entityFileName %>';
+import { <%= RepositoryName %> } from '../<%= repositoryFileName %>';
+import type { <%= TranslationEntityName %> } from '../<%= translationEntityFileName %>';
+import { <%= TranslationRepositoryName %> } from '../<%= translationRepositoryFileName %>';
+
+export class <%= CreateCommandName %> implements ICommand {
+  constructor(
+    public readonly <%=createDtoName %>: <%= CreateDtoName %>,
+  ) {}
+}
+
+@CommandHandler(<%= CreateCommandName %>)
+export class <%= CreateHandlerName %>
+  implements ICommandHandler<<%= CreateCommandName %>, <%= EntityName %>>
+{
+  constructor(
+    private <%= repositoryName %>: <%= RepositoryName %>,
+    private <%= translationRepositoryName %>: <%= TranslationRepositoryName %>,
+  ) {}
+
+  async execute(command: <%= CreateCommandName %>) {
+    const { <%=createDtoName %> } = command;
+    const <%= entityName %> = this.<%= repositoryName %>.create();
+    const translations: <%= TranslationEntityName %>[] = [];
+
+    await this.<%= repositoryName %>.save(<%= entityName %>);
+
+    // FIXME: Create generic function for translation creation
+    for (const createTranslationDto of <%=createDtoName %>.title) {
+      const languageCode = createTranslationDto.languageCode;
+      const translationEntity = this.<%= translationRepositoryName %>.create({
+        <%= fieldName %>Id: <%= entityName %>.id,
+        languageCode,
+        title: createTranslationDto.text,
+        description: find(<%=createDtoName %>.description, {
+          languageCode,
+        })!.text,
+      });
+
+      translations.push(translationEntity);
+    }
+
+    await this.<%= translationRepositoryName %>.save(translations);
+
+    <%= entityName %>.translations = translations;
+
+    return <%= entityName %>;
+  }
+}

package/.hygen/new/module/create.dto.ejs.t

@@ -0,0 +1,11 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/dtos/<%= h.createDtoFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('CreateDTO') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ CreateDtoName = h.CreateDtoName(name);
+
+%>export class <%= CreateDtoName %> {}

package/.hygen/new/module/dto.ejs.t

@@ -0,0 +1,24 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/dtos/<%= h.dtoFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('DTO') %>
+---
+<%
+
+ DtoName = h.DtoName(name);
+ DtoOptionName = h.DtoOptionName(name);
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ entityFileName = h.entityFileName(name);
+
+%>import { AbstractDto } from '@omni/core/common/dto/abstract.dto';
+import type { <%= EntityName %> } from '../<%= entityFileName %>';
+
+export interface <%= DtoOptionName %> {
+}
+
+export class <%= DtoName %> extends AbstractDto {
+  constructor(entityName: <%= EntityName %>, options?: <%= DtoOptionName %>) {
+    super(entityName);
+  }
+}

package/.hygen/new/module/entity.ejs.t

@@ -0,0 +1,33 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.entityFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('Entity') %>
+---
+<%
+ ClassName = h.ClassName(name);
+ DtoName = h.DtoName(name);
+ fieldName = h.changeCase.camel(ClassName);
+ dtoFileName = h.dtoFileName(name);
+ translationEntityFileName = h.translationEntityFileName(name);
+ DtoOptionName = h.DtoOptionName(name);
+ TableName = h.TableName(name);
+ EntityName = h.EntityName(name);
+ TranslationEntityName = h.TranslationEntityName(name);
+ translationEntityName = h.changeCase.camel(TranslationEntityName);
+%>import { Entity, OneToMany } from 'typeorm';
+
+import { AbstractEntity } from '@omni/core/common/abstract.entity';
+import { UseDto } from '@omni/core/decorators';
+import type { <%= DtoOptionName %> } from './dtos/<%= dtoFileName %>';
+import { <%= DtoName %> } from './dtos/<%= dtoFileName %>';
+import { <%= TranslationEntityName %> } from './<%= translationEntityFileName %>';
+
+@Entity({ name: '<%= TableName %>' })
+@UseDto(<%= DtoName %>)
+export class <%= EntityName %> extends AbstractEntity<<%= DtoName %>, <%= DtoOptionName %>> {
+  @OneToMany(
+    () => <%= TranslationEntityName %>,
+    (<%= translationEntityName %>) => <%= translationEntityName %>.<%= fieldName %>,
+  )
+  translations: <%= TranslationEntityName %>[];
+}

package/.hygen/new/module/get-query.ejs.t

@@ -0,0 +1,57 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/queries/<%= h.getQueryFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('GetQuery') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ fieldName = h.changeCase.camel(ClassName);
+
+ GetQueryName = h.GetQueryName(name);
+ GetHandlerName = h.GetHandlerName(name);
+
+ CreateDtoName = h.CreateDtoName(name);
+ createDtoName = h.changeCase.camel(CreateDtoName);
+ createDtoFileName = h.createDtoFileName(name);
+
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ entityFileName = h.entityFileName(name);
+
+ RepositoryName = h.RepositoryName(name);
+ TranslationRepositoryName = h.TranslationRepositoryName(name);
+ repositoryName = h.changeCase.camel(RepositoryName);
+ translationRepositoryName = h.changeCase.camel(TranslationRepositoryName);
+ repositoryFileName = h.repositoryFileName(name);
+
+ TranslationEntityName = h.TranslationEntityName(name);
+ TranslationDtoName = h.TranslationDtoName(name);
+ translationEntityFileName = h.translationEntityFileName(name);
+ translationRepositoryFileName = h.translationRepositoryFileName(name);
+ translationEntityName = h.changeCase.camel(TranslationEntityName);
+
+%>import type { ICommand, IQueryHandler } from '@nestjs/cqrs';
+import { QueryHandler } from '@nestjs/cqrs';
+
+import { <%= RepositoryName %> } from '../<%= repositoryFileName %>';
+
+export class <%= GetQueryName %> implements ICommand {
+  constructor(
+    public readonly userId: Uuid,
+  ) {}
+}
+
+@QueryHandler(<%= GetQueryName %>)
+export class <%= GetHandlerName %> implements IQueryHandler<<%= GetQueryName %>> {
+  constructor(private <%= repositoryName %>: <%= RepositoryName %>) {}
+
+  async execute(query: <%= GetQueryName %>) {
+    return this.<%= repositoryName %>.find({
+      userId: query.userId,
+    });
+  }
+}

package/.hygen/new/module/module.ejs.t

@@ -0,0 +1,44 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.moduleFileName(name) %>.ts"
+unless_exists: true
+---
+<%
+
+ ModuleName = h.ModuleName(name);
+ fileName = h.inflection.dasherize(name);
+
+ ControllerName = h.ControllerName(name);
+ controllerFileName = h.controllerFileName(name);
+
+ ServiceName = h.ServiceName(name);
+ serviceFileName = h.serviceFileName(name);
+
+ RepositoryName = h.RepositoryName(name);
+ repositoryFileName = h.repositoryFileName(name);
+
+ createCommandFileName = h.createCommandFileName(name);
+ getQueryFileName = h.getQueryFileName(name);
+
+%>import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { <%= CreateHandlerName %> } from './commands/<%= createCommandFileName %>';
+import { <%= ControllerName %> } from './<%= controllerFileName %>';
+import { <%= RepositoryName %> } from './<%= repositoryFileName %>';
+import { <%= TranslationRepositoryName %> } from './<%= translationRepositoryFileName %>';
+import { <%= ServiceName %> } from './<%= serviceFileName %>';
+import { <%= GetHandlerName %> } from './queries/<%= getQueryFileName %>';
+
+export const handlers = [
+<%= CreateHandlerName %>,
+<%= GetHandlerName %>,
+];
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([<%= RepositoryName %>, <%= TranslationRepositoryName %>]),
+  ],
+  providers: [<%= ServiceName %>, ...handlers],
+  controllers: [<%= ControllerName %>],
+})
+export class <%= ModuleName %> {}

package/.hygen/new/module/not-found.exception.ejs.t

@@ -0,0 +1,18 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/exceptions/<%= h.notFoundExceptionFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('NotFoundException') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ fieldName = h.changeCase.camel(ClassName);
+ NotFoundExceptionName = h.NotFoundExceptionName(name);
+
+%>import { NotFoundException } from '@nestjs/common';
+
+export class <%= NotFoundExceptionName %> extends NotFoundException {
+  constructor(error?: string) {
+    super('error.<%= fieldName %>NotFound', error);
+  }
+}

package/.hygen/new/module/page-options.dto.ejs.t

@@ -0,0 +1,12 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/dtos/<%= h.pageOptionsDtoFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('PageOptionsDTO') %>
+---
+<%
+
+ PageOptionsDtoName = h.PageOptionsDtoName(name);
+
+%>import { PageOptionsDto } from '@omni/core/common/dto/page-options.dto';
+
+export class <%= PageOptionsDtoName %> extends PageOptionsDto {}

package/.hygen/new/module/prompt.js

@@ -0,0 +1,104 @@
+'use strict'
+
+module.exports = {
+  prompt: ({ prompter, args }) => {
+    return prompter.prompt([
+      {
+        type: 'input',
+        name: 'name',
+        message: 'Name:',
+        validate(value) {
+          if (!value.length) {
+            return 'Module must have a name.';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'MultiSelect',
+        name: 'blocks',
+        message: 'Blocks:',
+        initial: [
+          'Controller',
+          'CreateCommand',
+          'CreateDTO',
+          'DTO',
+          'Entity',
+          'GetQuery',
+          //'Module',
+          'NotFoundException',
+          'PageOptionsDTO',
+          'Repository',
+          'Service',
+          'TranslationDTO',
+          'TranslationEntity',
+          'TranslationRepository',
+          'UpdateDTO'
+        ],
+        choices: [
+          {
+            name: 'Controller',
+            value: 'controller',
+          },
+          {
+            name: 'CreateCommand',
+            value: 'create-command',
+          },
+          {
+            name: 'CreateDTO',
+            value: 'create-dto',
+          },
+          {
+            name: 'DTO',
+            value: 'dto',
+          },
+          {
+            name: 'Entity',
+            value: 'entity',
+          },
+          {
+            name: 'GetQuery',
+            value: 'get-query',
+          },
+          {
+            name: 'NotFoundException',
+            value: 'not-found-exception',
+          },
+          {
+            name: 'PageOptionsDTO',
+            value: 'page-options-dto',
+          },
+          {
+            name: 'Repository',
+            value: 'repository',
+          },
+          {
+            name: 'Service',
+            value: 'service',
+          },
+          {
+            name: 'TranslationDTO',
+            value: 'translation-dto',
+          },
+          {
+            name: 'TranslationEntity',
+            value: 'translationEntity',
+          },
+          {
+            name: 'TranslationRepository',
+            value: 'translation-repository',
+          },
+          {
+            name: 'UpdateDTO',
+            value: 'update-dto',
+          },
+        ],
+      }
+    ])
+    .then(answer => {
+      //// For debugging
+      // console.log(answer)
+      return answer;
+    })
+  }
+}

package/.hygen/new/module/repository.ejs.t

@@ -0,0 +1,16 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.repositoryFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('Repository') %>
+---
+<%
+ EntityName = h.EntityName(name);
+ entityFileName = h.entityFileName(name);
+
+ RepositoryName = h.RepositoryName(name);
+%>import { EntityRepository, Repository } from 'typeorm';
+
+import { <%= EntityName %> } from './<%= entityFileName %>';
+
+@EntityRepository(<%= EntityName %>)
+export class <%= RepositoryName %> extends Repository<<%= EntityName %>> {}

package/.hygen/new/module/service.ejs.t

@@ -0,0 +1,139 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.serviceFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('Service') %>
+---
+<%
+
+ ClassName = h.ClassName(name);
+ fieldName = h.changeCase.camel(ClassName);
+
+ DtoName = h.DtoName(name);
+ dtoFileName = h.dtoFileName(name);
+
+
+ CreateCommandName = h.CreateCommandName(name);
+ createCommandFileName = h.createCommandFileName(name);
+
+
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ entityFileName = h.entityFileName(name);
+
+ ServiceName = h.ServiceName(name);
+
+ UpdateDtoName = h.UpdateDtoName(name);
+ updateDtoFileName = h.updateDtoFileName(name);
+ updateDtoName = h.changeCase.camel(UpdateDtoName);
+
+ fileName = h.fileName(name);
+
+ RepositoryName = h.RepositoryName(name);
+ repositoryName = h.changeCase.camel(RepositoryName);
+ repositoryFileName = h.repositoryFileName(name);
+
+ NotFoundExceptionName = h.NotFoundExceptionName(name);
+ notFoundExceptionFileName = h.notFoundExceptionFileName(name);
+
+ createFunctionName = 'create' + ClassName;
+ updateFunctionName = 'update' + ClassName;
+ deleteFunctionName = 'delete' + ClassName;
+ getAllFunctionName = 'getAll' + ClassName;
+ getSingleFunctionName = 'getSingle' + ClassName;
+ controllerName = moduleName + 'Controller';
+ serviceName = moduleName + 'Service';
+ CreateDtoName = h.CreateDtoName(name);
+ createDtoFileName = h.createDtoFileName(name);
+
+ PageOptionsDtoName = h.PageOptionsDtoName(name);
+ pageOptionsDtoName = h.changeCase.camel(PageOptionsDtoName);
+ pageOptionsDtoFileName = h.pageOptionsDtoFileName(name);
+
+%>import { Injectable } from '@nestjs/common';
+import { CommandBus } from '@nestjs/cqrs';
+import { Transactional } from 'typeorm-transactional';
+
+import type { PageDto } from '@omni/core/common/dto/page.dto';
+import { ValidatorService } from '@omni/core/shared/services/validator.service';
+import { <%= CreateCommandName %> } from './commands/<%= createCommandFileName %>';
+import type { <%= DtoName %> } from './dtos/<%= dtoFileName %>';
+import type { <%= PageOptionsDtoName %> } from './dtos/<%= pageOptionsDtoFileName %>';
+import { <%= NotFoundExceptionName %> } from './exceptions/<%= notFoundExceptionFileName %>';
+import type { <%= EntityName %> } from './<%= entityFileName %>';
+import { <%= RepositoryName %> } from './<%= repositoryFileName %>';
+import { <%= CreateDtoName %> } from './dtos/<%= createDtoFileName %>';
+import type { <%= UpdateDtoName %> } from './dtos/<%= updateDtoFileName %>';
+
+@Injectable()
+export class <%= ServiceName %> {
+  constructor(
+    private <%= repositoryName %>: <%= RepositoryName %>,
+    private validatorService: ValidatorService,
+    private commandBus: CommandBus,
+  ) {}
+
+  @Transactional()
+  <%= createFunctionName %>(<%= createDtoName %>: <%= CreateDtoName %>): Promise<<%= EntityName %>> {
+    return this.commandBus.execute<<%= CreateCommandName %>, <%= EntityName %>>(
+      new <%= CreateCommandName %>(<%= createDtoName %>),
+    );
+  }
+
+  async <%= getAllFunctionName %>(
+    <%= pageOptionsDtoName %>: <%= PageOptionsDtoName %>,
+  ): Promise<PageDto<<%= DtoName %>>> {
+    const queryBuilder = this.<%= repositoryName %>
+      .createQueryBuilder('<%= fieldName %>')
+      .leftJoinAndSelect('<%= fieldName %>.translations', '<%= fieldName %>Translation');
+    const [items, pageMetaDto] = await queryBuilder.paginate(<%= pageOptionsDtoName %>);
+
+    return items.toPageDto(pageMetaDto);
+  }
+
+  async <%= getSingleFunctionName %>(id: Uuid): Promise<<%= EntityName %>> {
+    const queryBuilder = this.<%= repositoryName %>
+      .createQueryBuilder('<%= fieldName %>')
+      .where('<%= fieldName %>.id = :id', { id });
+
+    const <%= entityName %> = await queryBuilder.getOne();
+
+    if (!<%= entityName %>) {
+      throw new <%= NotFoundExceptionName %>();
+    }
+
+    return <%= entityName %>;
+  }
+
+  async <%= updateFunctionName %>(
+    id: Uuid,
+    <%= updateDtoName %>: <%= UpdateDtoName %>,
+  ): Promise<void> {
+    const queryBuilder = this.<%= repositoryName %>
+      .createQueryBuilder('<%= fieldName %>')
+      .where('<%= fieldName %>.id = :id', { id });
+
+    const <%= entityName %> = await queryBuilder.getOne();
+
+    if (!<%= entityName %>) {
+      throw new <%= NotFoundExceptionName %>();
+    }
+
+    this.<%= repositoryName %>.merge(<%= entityName %>, <%= updateDtoName %>);
+
+    await this.<%= repositoryName %>.save(<%= updateDtoName %>);
+  }
+
+  async <%= deleteFunctionName %>(id: Uuid): Promise<void> {
+    const queryBuilder = this.<%= repositoryName %>
+      .createQueryBuilder('<%= fieldName %>')
+      .where('<%= fieldName %>.id = :id', { id });
+
+    const <%= entityName %> = await queryBuilder.getOne();
+
+    if (!<%= entityName %>) {
+      throw new <%= NotFoundExceptionName %>();
+    }
+
+    await this.<%= repositoryName %>.remove(<%= entityName %>);
+  }
+}

package/.hygen/new/module/translation-dto.ejs.t

@@ -0,0 +1,27 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/dtos/<%= h.translationDtoFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('TranslationDTO') %>
+---
+<%
+
+ TranslationDtoName = h.TranslationDtoName(name);
+ translationEntityFileName = h.translationEntityFileName(name);
+ TranslationEntityName = h.TranslationEntityName(name);
+ translationEntityName = h.changeCase.camel(TranslationEntityName);
+
+%>import { AbstractTranslationDto } from '@omni/core/common/dto/abstract.dto';
+import { LanguageCode } from '../../../constants';
+import { ApiEnumPropertyOptional } from '../@omni/core/decorators';
+import type { <%= TranslationEntityName %> } from '../<%= translationEntityFileName %>';
+
+export class <%= TranslationDtoName %> extends AbstractTranslationDto {
+  @ApiEnumPropertyOptional(() => LanguageCode)
+  languageCode: LanguageCode;
+
+  constructor(<%= translationEntityName %>: <%= TranslationEntityName %>) {
+    super(<%= translationEntityName %>);
+
+    this.languageCode = <%= translationEntityName %>.languageCode;
+  }
+}

package/.hygen/new/module/translation-entity.ejs.t

@@ -0,0 +1,40 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.translationEntityFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('TranslationEntity') %>
+---
+<%
+ ClassName = h.ClassName(name);
+ fieldName = h.changeCase.camel(ClassName);
+ DtoName = h.DtoName(name);
+ dtoFileName = h.dtoFileName(name);
+ translationDtoFileName = h.translationDtoFileName(name);
+ translationEntityFileName = h.translationEntityFileName(name);
+ DtoOptionName = h.DtoOptionName(name);
+ var_name = h.inflection.dasherize(name);
+ EntityName = h.EntityName(name);
+ entityName = h.changeCase.camel(EntityName);
+ TranslationEntityName = h.TranslationEntityName(name);
+ TranslationDtoName = h.TranslationDtoName(name);
+ translationEntityName = h.changeCase.camel(TranslationEntityName);
+%>import { Column, Entity, JoinColumn, ManyToOne } from 'typeorm';
+
+import { AbstractTranslationEntity } from '@omni/core/common/abstract.entity';
+import { UseDto } from '@omni/core/decorators';
+import { <%= TranslationDtoName %> } from './dtos/<%= translationDtoFileName %>';
+import { <%= EntityName %> } from './<%= entityFileName %>';
+
+@Entity({ name: '<%= var_name %>_translations' })
+@UseDto(<%= TranslationDtoName %>)
+export class <%= TranslationEntityName %> extends AbstractTranslationEntity<<%= TranslationDtoName %>> {
+  @Column({ type: 'uuid' })
+  <%= fieldName %>Id: Uuid;
+
+  @ManyToOne(() => <%= EntityName %>, (<%= entityName %>) => <%= entityName %>.translations, {
+    onDelete: 'CASCADE',
+    onUpdate: 'CASCADE',
+  })
+  @JoinColumn({ name: '<%= var_name %>_id' })
+  <%= fieldName %>: <%= EntityName %>;
+}
+

package/.hygen/new/module/translation-repository.ejs.t

@@ -0,0 +1,16 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/<%= h.translationRepositoryFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('TranslationRepository') %>
+---
+<%
+ TranslationEntityName = h.TranslationEntityName(name);
+ translationEntityFileName = h.translationEntityFileName(name);
+
+ TranslationRepositoryName = h.TranslationRepositoryName(name);
+%>import { EntityRepository, Repository } from 'typeorm';
+
+import { <%= TranslationEntityName %> } from './<%= translationEntityFileName %>';
+
+@EntityRepository(<%= TranslationEntityName %>)
+export class <%= TranslationRepositoryName %> extends Repository<<%= TranslationEntityName %>> {}

package/.hygen/new/module/update.dto.ejs.t

@@ -0,0 +1,10 @@
+---
+to: "src/modules/<%= h.fileName(name) %>/dtos/<%= h.updateDtoFileName(name) %>.ts"
+unless_exists: true
+skip_if: <%= !blocks.includes('UpdateDTO') %>
+---
+<%
+
+UpdateDtoName = h.UpdateDtoName(name);
+
+%>export class <%= UpdateDtoName %> {}

package/.hygen.js

@@ -0,0 +1,116 @@
+module.exports = {
+  templates: `${__dirname}/.hygen`,
+  helpers: {
+    ControllerName(name) {
+      return `${this.ClassName(name)}Controller`;
+    },
+    ServiceName(name) {
+      return `${this.ClassName(name)}Service`;
+    },
+    ModuleName(name) {
+      return `${this.ClassName(name)}Module`;
+    },
+    DtoName(name) {
+      return `${this.ClassName(name)}Dto`;
+    },
+    TranslationDtoName(name) {
+      return `${this.ClassName(name)}TranslationDto`;
+    },
+    UpdateDtoName(name) {
+      return `Update${this.DtoName(name)}`;
+    },
+    DtoOptionName(name) {
+      return `I${this.DtoName(name)}Options`;
+    },
+    CreateDtoName(name) {
+      return `Create${this.DtoName(name)}`;
+    },
+    EntityName(name) {
+      return `${this.ClassName(name)}Entity`;
+    },
+    TranslationEntityName(name) {
+      return `${this.ClassName(name)}TranslationEntity`;
+    },
+    CreateCommandName(name) {
+      return `Create${this.ClassName(name)}Command`;
+    },
+    CreateHandlerName(name) {
+      return `Create${this.ClassName(name)}Handler`;
+    },
+    GetHandlerName(name) {
+      return `Get${this.ClassName(name)}Handler`;
+    },
+    GetQueryName(name) {
+      return `Get${this.ClassName(name)}Query`;
+    },
+    PageOptionsDtoName(name) {
+      return this.ClassName(name) + 'PageOptionsDto';
+    },
+    NotFoundExceptionName(name) {
+      return this.ClassName(name) + 'NotFoundException';
+    },
+    entityFileName(name) {
+      return `${this.fileName(name)}.entity`;
+    },
+    translationEntityFileName(name) {
+      return `${this.fileName(name)}-translation.entity`;
+    },
+    translationDtoFileName(name) {
+      return `${this.fileName(name)}-translation.dto`;
+    },
+    repositoryFileName(name) {
+      return `${this.fileName(name)}.repository`;
+    },
+    translationRepositoryFileName(name) {
+      return `${this.fileName(name)}-translation.repository`;
+    },
+    createCommandFileName(name) {
+      return `create-${this.fileName(name)}.command`;
+    },
+    getQueryFileName(name) {
+      return `get-${this.fileName(name)}.query`;
+    },
+    controllerFileName(name) {
+      return `${this.fileName(name)}.controller`;
+    },
+    dtoFileName(name) {
+      return `${this.fileName(name)}.dto`;
+    },
+    notFoundExceptionFileName(name) {
+      return `${this.fileName(name)}-not-found.exception`;
+    },
+    createDtoFileName(name) {
+      return `create-${this.fileName(name)}.dto`;
+    },
+    updateDtoFileName(name) {
+      return `update-${this.fileName(name)}.dto`;
+    },
+    pageOptionsDtoFileName(name) {
+      return `${this.fileName(name)}-page-options.dto`;
+    },
+    serviceFileName(name) {
+      return `${this.fileName(name)}.service`;
+    },
+    moduleFileName(name) {
+      return `${this.fileName(name)}.module`;
+    },
+    ClassName(name) {
+      return this.changeCase.pascal(name);
+    },
+    TableName(name) {
+      return this.inflection.underscore(this.ClassName(name));
+    },
+    RepositoryName(name) {
+      return `${this.ClassName(name)}Repository`;
+    },
+    TranslationRepositoryName(name) {
+      return `${this.ClassName(name)}TranslationRepository`;
+    },
+    moduleName(name) {
+      return this.changeCase.camel(name);
+    },
+    fileName(name) {
+      return this.inflection.dasherize(name).toLowerCase();
+    },
+  },
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nest-omni/core",
-  "version": "1.0.21",
+  "version": "1.0.24",
   "description": "framework",
   "main": "index.js",
   "types": "index.d.ts",