@mikemajesty/microservice-crud 0.0.1

package/src/templates/postgres/core/use-cases/getByID.js

@@ -0,0 +1,32 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getCoreUsecaseGetByID = (name) => `import { ${capitalizeFirstLetter(name)}GetByIDInput, ${capitalizeFirstLetter(name)}GetByIDOutput } from '@/modules/${name}/types';
+import { ${capitalizeFirstLetter(name)}GetByIdSchema } from '@/modules/${name}/types';
+import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
+import { ApiNotFoundException } from '@/utils/exception';
+
+import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
+import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
+
+export class ${capitalizeFirstLetter(name)}GetByIdUsecase {
+  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
+
+  @ValidateSchema(${capitalizeFirstLetter(name)}GetByIdSchema)
+  async execute({ id }: ${capitalizeFirstLetter(name)}GetByIDInput): Promise<${capitalizeFirstLetter(name)}GetByIDOutput> {
+    const ${name} = await this.${name}Repository.findById(id);
+
+    if (!${name}) {
+      throw new ApiNotFoundException('${name}NotFound');
+    }
+
+    return new ${capitalizeFirstLetter(name)}Entity(${name});
+  }
+}
+`
+
+module.exports = {
+  getCoreUsecaseGetByID
+}

package/src/templates/postgres/core/use-cases/list.js

@@ -0,0 +1,23 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getCoreUsecaseList = (name) => `import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput, ${capitalizeFirstLetter(name)}ListSchema } from '@/modules/${name}/types';
+import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
+
+import { I${capitalizeFirstLetter(name)}Repository } from '../repository/${name}';
+
+export class ${capitalizeFirstLetter(name)}ListUsecase {
+  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
+
+  @ValidateSchema(${capitalizeFirstLetter(name)}ListSchema)
+  async execute(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput> {
+    return await this.${name}Repository.paginate(input);
+  }
+}
+`
+
+module.exports = {
+  getCoreUsecaseList
+}

package/src/templates/postgres/core/use-cases/update.js

@@ -0,0 +1,39 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getCoreUsecaseUpdate = (name) => `import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
+import { ${capitalizeFirstLetter(name)}UpdateInput, ${capitalizeFirstLetter(name)}UpdateOutput, ${capitalizeFirstLetter(name)}UpdateSchema } from '@/modules/${name}/types';
+import { ValidateSchema } from '@/utils/decorators/validate-schema.decorator';
+import { ApiNotFoundException } from '@/utils/exception';
+
+import { ${capitalizeFirstLetter(name)}Entity } from './../entity/${name}';
+
+export class ${capitalizeFirstLetter(name)}UpdateUsecase {
+  constructor(private readonly ${name}Repository: I${capitalizeFirstLetter(name)}Repository) {}
+
+  @ValidateSchema(${capitalizeFirstLetter(name)}UpdateSchema)
+  async execute(input: ${capitalizeFirstLetter(name)}UpdateInput): Promise<${capitalizeFirstLetter(name)}UpdateOutput> {
+    const ${name} = await this.${name}Repository.findById(input.id);
+
+    if (!${name}) {
+      throw new ApiNotFoundException('${name}NotFound');
+    }
+
+    const ${name}Finded = new ${capitalizeFirstLetter(name)}Entity(${name});
+
+    const entity = new ${capitalizeFirstLetter(name)}Entity({ ...${name}Finded, ...input });
+
+    await this.${name}Repository.updateOne({ id: entity.id }, entity);
+
+    const updated = await this.${name}Repository.findById(entity.id);
+
+    return new ${capitalizeFirstLetter(name)}Entity(updated);
+  }
+}
+`
+
+module.exports = {
+  getCoreUsecaseUpdate
+}

package/src/templates/postgres/modules/adapter.js

@@ -0,0 +1,42 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getModuleAdapter = (name) => `import {
+  ${capitalizeFirstLetter(name)}CreateInput,
+  ${capitalizeFirstLetter(name)}CreateOutput,
+  ${capitalizeFirstLetter(name)}DeleteInput,
+  ${capitalizeFirstLetter(name)}DeleteOutput,
+  ${capitalizeFirstLetter(name)}GetByIDInput,
+  ${capitalizeFirstLetter(name)}GetByIDOutput,
+  ${capitalizeFirstLetter(name)}ListInput,
+  ${capitalizeFirstLetter(name)}ListOutput,
+  ${capitalizeFirstLetter(name)}UpdateInput,
+  ${capitalizeFirstLetter(name)}UpdateOutput
+} from './types';
+
+export abstract class I${capitalizeFirstLetter(name)}CreateAdapter {
+  abstract execute(input: ${capitalizeFirstLetter(name)}CreateInput): Promise<${capitalizeFirstLetter(name)}CreateOutput>;
+}
+
+export abstract class I${capitalizeFirstLetter(name)}UpdateAdapter {
+  abstract execute(input: ${capitalizeFirstLetter(name)}UpdateInput): Promise<${capitalizeFirstLetter(name)}UpdateOutput>;
+}
+
+export abstract class I${capitalizeFirstLetter(name)}GetByIDAdapter {
+  abstract execute(input: ${capitalizeFirstLetter(name)}GetByIDInput): Promise<${capitalizeFirstLetter(name)}GetByIDOutput>;
+}
+
+export abstract class I${capitalizeFirstLetter(name)}ListAdapter {
+  abstract execute(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput>;
+}
+
+export abstract class I${capitalizeFirstLetter(name)}DeleteAdapter {
+  abstract execute(input: ${capitalizeFirstLetter(name)}DeleteInput): Promise<${capitalizeFirstLetter(name)}DeleteOutput>;
+}
+`
+
+module.exports = {
+  getModuleAdapter
+}

package/src/templates/postgres/modules/controller.js

@@ -0,0 +1,95 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getModuleController = (name) => `import { Body, Controller, Delete, Get, Param, Post, Put, Query } from '@nestjs/common';
+import { ApiBearerAuth, ApiBody, ApiParam, ApiQuery, ApiResponse, ApiTags } from '@nestjs/swagger';
+
+import { UserRole } from '@/core/user/entity/user';
+import { Roles } from '@/utils/decorators/role.decorator';
+import { SearchHttpSchema } from '@/utils/search';
+import { SortHttpSchema } from '@/utils/sort';
+
+import {
+  I${capitalizeFirstLetter(name)}CreateAdapter,
+  I${capitalizeFirstLetter(name)}DeleteAdapter,
+  I${capitalizeFirstLetter(name)}GetByIDAdapter,
+  I${capitalizeFirstLetter(name)}ListAdapter,
+  I${capitalizeFirstLetter(name)}UpdateAdapter
+} from './adapter';
+import { SwagggerRequest, SwagggerResponse } from './swagger';
+import {
+  ${capitalizeFirstLetter(name)}CreateInput,
+  ${capitalizeFirstLetter(name)}CreateOutput,
+  ${capitalizeFirstLetter(name)}DeleteInput,
+  ${capitalizeFirstLetter(name)}DeleteOutput,
+  ${capitalizeFirstLetter(name)}GetByIDInput,
+  ${capitalizeFirstLetter(name)}GetByIDOutput,
+  ${capitalizeFirstLetter(name)}ListInput,
+  ${capitalizeFirstLetter(name)}ListOutput,
+  ${capitalizeFirstLetter(name)}UpdateInput,
+  ${capitalizeFirstLetter(name)}UpdateOutput
+} from './types';
+
+@Controller()
+@ApiTags('${name}')
+@ApiBearerAuth()
+@Roles(UserRole.BACKOFFICE)
+export class ${capitalizeFirstLetter(name)}Controller {
+  constructor(
+    private readonly ${name}Create: I${capitalizeFirstLetter(name)}CreateAdapter,
+    private readonly ${name}Update: I${capitalizeFirstLetter(name)}UpdateAdapter,
+    private readonly ${name}GetByID: I${capitalizeFirstLetter(name)}GetByIDAdapter,
+    private readonly ${name}List: I${capitalizeFirstLetter(name)}ListAdapter,
+    private readonly ${name}Delete: I${capitalizeFirstLetter(name)}DeleteAdapter
+  ) {}
+
+  @Post('/${name}')
+  @ApiResponse(SwagggerResponse.create[200])
+  @ApiBody(SwagggerRequest.createBody)
+  async create(@Body() input: ${capitalizeFirstLetter(name)}CreateInput): ${capitalizeFirstLetter(name)}CreateOutput {
+    return await this.${name}Create.execute(input);
+  }
+
+  @Put('/${name}')
+  @ApiResponse(SwagggerResponse.update[200])
+  @ApiResponse(SwagggerResponse.update[404])
+  @ApiBody(SwagggerRequest.updateBody)
+  async update(@Body() input: ${capitalizeFirstLetter(name)}UpdateInput): ${capitalizeFirstLetter(name)}UpdateOutput {
+    return await this.${name}Update.execute(input);
+  }
+
+  @Get('/${name}/:id')
+  @ApiParam({ name: 'id', required: true })
+  @ApiResponse(SwagggerResponse.getByID[200])
+  @ApiResponse(SwagggerResponse.getByID[404])
+  async getById(@Param() input: ${capitalizeFirstLetter(name)}GetByIDInput): ${capitalizeFirstLetter(name)}GetByIDOutput {
+    return await this.${name}GetByID.execute(input);
+  }
+
+  @Get('/${name}')
+  @ApiQuery(SwagggerRequest.listQuery.pagination.limit)
+  @ApiQuery(SwagggerRequest.listQuery.pagination.page)
+  @ApiQuery(SwagggerRequest.listQuery.sort)
+  @ApiQuery(SwagggerRequest.listQuery.search)
+  @ApiResponse(SwagggerResponse.list[200])
+  async list(@Query() input: ${capitalizeFirstLetter(name)}ListInput): ${capitalizeFirstLetter(name)}ListOutput {
+    input.sort = SortHttpSchema.parse(input.sort);
+    input.search = SearchHttpSchema.parse(input.search);
+    return await this.${name}List.execute(input);
+  }
+
+  @Delete('/${name}/:id')
+  @ApiParam({ name: 'id', required: true })
+  @ApiResponse(SwagggerResponse.delete[200])
+  @ApiResponse(SwagggerResponse.delete[404])
+  async delete(@Param() input: ${capitalizeFirstLetter(name)}DeleteInput): ${capitalizeFirstLetter(name)}DeleteOutput {
+    return await this.${name}Delete.execute(input);
+  }
+}
+`
+
+module.exports = {
+  getModuleController
+}

package/src/templates/postgres/modules/module.js

@@ -0,0 +1,80 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getModule = (name) => `import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
+import { getRepositoryToken, TypeOrmModule } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { ${capitalizeFirstLetter(name)}Entity } from '@/core/${name}/entity/${name}';
+import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
+import { ${capitalizeFirstLetter(name)}CreateUsecase } from '@/core/${name}/use-cases/${name}-create';
+import { ${capitalizeFirstLetter(name)}DeleteUsecase } from '@/core/${name}/use-cases/${name}-delete';
+import { ${capitalizeFirstLetter(name)}GetByIdUsecase } from '@/core/${name}/use-cases/${name}-getByID';
+import { ${capitalizeFirstLetter(name)}ListUsecase } from '@/core/${name}/use-cases/${name}-list';
+import { ${capitalizeFirstLetter(name)}UpdateUsecase } from '@/core/${name}/use-cases/${name}-update';
+import { LoggerModule } from '@/infra/logger';
+import { TokenModule } from '@/libs/auth';
+import { IsLoggedMiddleware } from '@/utils/middlewares/is-logged.middleware';
+
+import {
+  I${capitalizeFirstLetter(name)}CreateAdapter,
+  I${capitalizeFirstLetter(name)}DeleteAdapter,
+  I${capitalizeFirstLetter(name)}GetByIDAdapter,
+  I${capitalizeFirstLetter(name)}ListAdapter,
+  I${capitalizeFirstLetter(name)}UpdateAdapter
+} from './adapter';
+import { ${capitalizeFirstLetter(name)}Controller } from './controller';
+import { ${capitalizeFirstLetter(name)}Repository } from './repository';
+import { ${capitalizeFirstLetter(name)}Schema } from './schema';
+
+@Module({
+  imports: [TokenModule, LoggerModule, TypeOrmModule.forFeature([${capitalizeFirstLetter(name)}Schema])],
+  controllers: [${capitalizeFirstLetter(name)}Controller],
+  providers: [
+    {
+      provide: I${capitalizeFirstLetter(name)}Repository,
+      useFactory: (repository: Repository<${capitalizeFirstLetter(name)}Schema & ${capitalizeFirstLetter(name)}Entity>) => {
+        return new ${capitalizeFirstLetter(name)}Repository(repository);
+      },
+      inject: [getRepositoryToken(${capitalizeFirstLetter(name)}Schema)]
+    },
+    {
+      provide: I${capitalizeFirstLetter(name)}CreateAdapter,
+      useFactory: (repository: I${capitalizeFirstLetter(name)}Repository) => new ${capitalizeFirstLetter(name)}CreateUsecase(repository),
+      inject: [I${capitalizeFirstLetter(name)}Repository]
+    },
+    {
+      provide: I${capitalizeFirstLetter(name)}UpdateAdapter,
+      useFactory: (repository: I${capitalizeFirstLetter(name)}Repository) => new ${capitalizeFirstLetter(name)}UpdateUsecase(repository),
+      inject: [I${capitalizeFirstLetter(name)}Repository]
+    },
+    {
+      provide: I${capitalizeFirstLetter(name)}GetByIDAdapter,
+      useFactory: (repository: I${capitalizeFirstLetter(name)}Repository) => new ${capitalizeFirstLetter(name)}GetByIdUsecase(repository),
+      inject: [I${capitalizeFirstLetter(name)}Repository]
+    },
+    {
+      provide: I${capitalizeFirstLetter(name)}ListAdapter,
+      useFactory: (repository: I${capitalizeFirstLetter(name)}Repository) => new ${capitalizeFirstLetter(name)}ListUsecase(repository),
+      inject: [I${capitalizeFirstLetter(name)}Repository]
+    },
+    {
+      provide: I${capitalizeFirstLetter(name)}DeleteAdapter,
+      useFactory: (repository: I${capitalizeFirstLetter(name)}Repository) => new ${capitalizeFirstLetter(name)}DeleteUsecase(repository),
+      inject: [I${capitalizeFirstLetter(name)}Repository]
+    }
+  ],
+  exports: []
+})
+export class ${capitalizeFirstLetter(name)}Module implements NestModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer.apply(IsLoggedMiddleware).forRoutes(${capitalizeFirstLetter(name)}Controller);
+  }
+}
+`
+
+module.exports = {
+  getModule
+}

package/src/templates/postgres/modules/repository.js

@@ -0,0 +1,47 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getModuleRepository = (name) => `import { Injectable } from '@nestjs/common';
+import { Repository } from 'typeorm';
+
+import { ${capitalizeFirstLetter(name)}Entity } from '@/core/${name}/entity/${name}';
+import { I${capitalizeFirstLetter(name)}Repository } from '@/core/${name}/repository/${name}';
+import { PostgresRepository } from '@/infra/repository/postgres/repository';
+import { ValidateDatabaseSort } from '@/utils/decorators/validate-allowed-sort-order.decorator';
+import { SearchTypeEnum, ValidatePostgresFilter } from '@/utils/decorators/validate-postgres-filter.decorator';
+import { calucaleSkip } from '@/utils/pagination';
+
+import { ${capitalizeFirstLetter(name)}Schema } from './schema';
+import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from './types';
+
+@Injectable()
+export class ${capitalizeFirstLetter(name)}Repository
+  extends PostgresRepository<${capitalizeFirstLetter(name)}Schema & ${capitalizeFirstLetter(name)}Entity>
+  implements Omit<I${capitalizeFirstLetter(name)}Repository, 'updateMany' | 'seed'>
+{
+  constructor(readonly repository: Repository<${capitalizeFirstLetter(name)}Schema & ${capitalizeFirstLetter(name)}Entity>) {
+    super(repository);
+  }
+
+  @ValidatePostgresFilter([{ name: 'name', type: SearchTypeEnum.like }])
+  @ValidateDatabaseSort(['createdAt', 'name'])
+  async paginate(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput> {
+    const skip = calucaleSkip(input);
+
+    const [docs, total] = await this.repository.findAndCount({
+      take: input.limit,
+      skip,
+      order: input.sort,
+      where: input.search
+    });
+
+    return { docs, total, page: input.page, limit: input.limit };
+  }
+}
+`
+
+module.exports = {
+  getModuleRepository
+}

package/src/templates/postgres/modules/schema.js

@@ -0,0 +1,32 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getModuleSchema = (name) => `import { Max, Min } from 'class-validator';
+import { BaseEntity, Column, CreateDateColumn, DeleteDateColumn, Entity, UpdateDateColumn } from 'typeorm';
+
+@Entity({ name: '${name}_collection' })
+export class ${capitalizeFirstLetter(name)}Schema extends BaseEntity {
+  @Column({ type: 'uuid', primary: true })
+  id: string;
+
+  @Column('text')
+  @Min(1)
+  @Max(200)
+  name: string;
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+
+  @DeleteDateColumn({ nullable: true })
+  deletedAt: Date;
+}
+`
+
+module.exports = {
+  getModuleSchema
+}

package/src/templates/postgres/modules/swagger.js

@@ -0,0 +1,90 @@
+const getModuleSwagger = (name) => `import { CreatedModel } from '@/infra/repository/types';
+import { Swagger } from '@/utils/swagger';
+
+const entity = {
+  name: '<name>'
+};
+
+const entityFull = { ...entity, updatedAt: '<updatedAt>', createdAt: '<createdAt>', deletedAt: '<deletedAt>' };
+
+export const SwagggerResponse = {
+  create: {
+    200: Swagger.defaultResponseJSON({
+      status: 200,
+      json: { created: true, id: '<uuid>' } as CreatedModel,
+      description: '${name} created.'
+    })
+  },
+  update: {
+    200: Swagger.defaultResponseJSON({
+      status: 200,
+      json: entityFull,
+      description: '${name} updated.'
+    }),
+    404: Swagger.defaultResponseError({
+      status: 404,
+      route: 'api/${name}',
+      message: '${name}NotFound',
+      description: '${name} not found.'
+    })
+  },
+  getByID: {
+    200: Swagger.defaultResponseJSON({
+      status: 200,
+      json: entityFull,
+      description: '${name} found.'
+    }),
+    404: Swagger.defaultResponseError({
+      status: 404,
+      route: 'api/${name}/:id',
+      message: '${name}NotFound',
+      description: '${name} not found.'
+    })
+  },
+  delete: {
+    200: Swagger.defaultResponseJSON({
+      status: 200,
+      json: entityFull,
+      description: '${name} found.'
+    }),
+    404: Swagger.defaultResponseError({
+      status: 404,
+      route: 'api/${name}/:id',
+      message: '${name}NotFound',
+      description: '${name} not found.'
+    })
+  },
+  list: {
+    200: Swagger.defaultResponseJSON({
+      status: 200,
+      json: { docs: { docs: [entityFull], page: 1, limit: 1, total: 1 } },
+      description: '${name} created.'
+    })
+  }
+};
+
+export const SwagggerRequest = {
+  createBody: Swagger.defaultRequestJSON({ ...entity, id: undefined }),
+  updateBody: Swagger.defaultRequestJSON({ ...entity, id: '<id>' }),
+  listQuery: {
+    pagination: {
+      limit: Swagger.defaultApiQueryOptions({ example: 10, name: 'limit', required: false }),
+      page: Swagger.defaultApiQueryOptions({ example: 1, name: 'page', required: false })
+    },
+    sort: Swagger.defaultApiQueryOptions({
+      name: 'sort',
+      required: false,
+      description: '<b>createdAt:desc,name:asc'
+    }),
+    search: Swagger.defaultApiQueryOptions({
+      name: 'search',
+      required: false,
+      description: '<b>name:miau,breed:siamese'
+    })
+  }
+};
+`
+
+module.exports = {
+  getModuleSwagger
+}

package/src/templates/postgres/modules/types.js

@@ -0,0 +1,52 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getModuleType = (name) => `import { z } from 'zod';
+
+import { ${capitalizeFirstLetter(name)}EntitySchema } from '@/core/${name}/entity/${name}';
+import { CreatedModel } from '@/infra/repository';
+import { PaginationInput, PaginationOutput, PaginationSchema } from '@/utils/pagination';
+import { SearchSchema } from '@/utils/search';
+import { SortSchema } from '@/utils/sort';
+
+type Schema = z.infer<typeof ${capitalizeFirstLetter(name)}EntitySchema>;
+
+export const ${capitalizeFirstLetter(name)}CreateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+  name: true
+});
+
+export type ${capitalizeFirstLetter(name)}CreateInput = z.infer<typeof ${capitalizeFirstLetter(name)}CreateSchema>;
+export type ${capitalizeFirstLetter(name)}CreateOutput = Promise<CreatedModel>;
+
+export const ${capitalizeFirstLetter(name)}UpdateSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+  name: true
+})
+  .partial()
+  .merge(${capitalizeFirstLetter(name)}EntitySchema.pick({ id: true }));
+
+export type ${capitalizeFirstLetter(name)}UpdateInput = z.infer<typeof ${capitalizeFirstLetter(name)}UpdateSchema>;
+export type ${capitalizeFirstLetter(name)}UpdateOutput = Promise<Schema>;
+
+export const ${capitalizeFirstLetter(name)}GetByIdSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+  id: true
+});
+export type ${capitalizeFirstLetter(name)}GetByIDInput = z.infer<typeof ${capitalizeFirstLetter(name)}GetByIdSchema>;
+export type ${capitalizeFirstLetter(name)}GetByIDOutput = Promise<Schema>;
+
+export const ${capitalizeFirstLetter(name)}ListSchema = z.intersection(PaginationSchema, SortSchema.merge(SearchSchema));
+
+export type ${capitalizeFirstLetter(name)}ListInput = PaginationInput<Schema>;
+export type ${capitalizeFirstLetter(name)}ListOutput = Promise<{ docs: Schema[] } & PaginationOutput>;
+
+export const ${capitalizeFirstLetter(name)}DeleteSchema = ${capitalizeFirstLetter(name)}EntitySchema.pick({
+  id: true
+});
+export type ${capitalizeFirstLetter(name)}DeleteInput = z.infer<typeof ${capitalizeFirstLetter(name)}DeleteSchema>;
+export type ${capitalizeFirstLetter(name)}DeleteOutput = Promise<Schema>;
+`
+
+module.exports = {
+  getModuleType
+}