@mikemajesty/microservice-crud 0.0.1

package/README.md

@@ -0,0 +1,92 @@
+# Nestjs CLI monorepo
+
+### [Monorepo](https://github.com/mikemajesty/nestjs-monorepo) CLI
+
+### install
+  - 
+    ```
+    $ npm i -g @mikemajesty/microservice-crud
+    ```
+  ---
+### Usage
+  - 1 - type cli command
+    ```bash
+    $ microservice-crud
+    ```
+  - 2 select template type [API, MODULE, TEST]
+  <br>[<img alt="mikemajesty" src="https://raw.githubusercontent.com/mikemajesty/microservice-crud/master/img/select-template.png">](https://github.com/mikemajesty)
+
+  
+  
+  
+  - 3 - type template name
+        <br>[<img alt="mikemajesty" src="https://raw.githubusercontent.com/mikemajesty/microservice-crud/master/img/template-name.png">](https://github.com/mikemajesty)
+ 
+ 
+ 
+ - 4 - Select path template
+    ```bash
+    # API must be inside [apps] folder - nestjs-monorepo/apps/
+    # MODULE must be inside [api] folder - nestjs-monorepo/apps/auth-api/src/modules/
+    # TEST must be inside [*] folder - nestjs-monorepo/*
+    ```
+  
+---
+### API skeleton
+```
+.
+└── main-api
+    ├── Dockerfile
+    ├── jest.config.js
+    ├── package.json
+    ├── src
+    │   ├── main.ts
+    │   └── modules
+    │       ├── health
+    │       │   ├── adapter.ts
+    │       │   ├── controller.ts
+    │       │   ├── module.ts
+    │       │   ├── service.ts
+    │       │   ├── swagger.ts
+    │       │   └── __tests__
+    │       │       ├── controller.e2e.spec.ts
+    │       │       ├── module.spec.ts
+    │       │       └── service.spec.ts
+    │       └── module.ts
+    ├── tests
+    │   └── initialization.js
+    ├── tsconfig.build.json
+    └── tsconfig.json
+```
+
+### MODULE skeleton
+```
+.
+└── module
+    ├── adapter.ts
+    ├── controller.ts
+    ├── module.ts
+    ├── service.ts
+    ├── swagger.ts
+    └── __tests__
+        ├── controller.e2e.spec.ts
+        ├── module.spec.ts
+        └── service.spec.ts
+```
+### TEST skeleton
+```
+.
+└── __tests__
+    ├── controller.e2e.spec.ts
+    ├── module.spec.ts
+    └── service.spec.ts
+```
+---
+The following is a list of all the people that have contributed Nestjs monorepo CLI. Thanks for your contributions!
+
+[<img alt="mikemajesty" src="https://avatars1.githubusercontent.com/u/11630212?s=460&v=4&s=117" width="117">](https://github.com/mikemajesty)
+
+## License
+
+It is available under the MIT license.
+[License](https://opensource.org/licenses/mit-license.php)

package/bin/microservice-crud

@@ -0,0 +1,3 @@
+#! /usr/bin/env node
+require = require('esm')(module /*, options */)
+require('../src/cli').cli(process.argv);

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@mikemajesty/microservice-crud",
+  "version": "0.0.01",
+  "description": "Monorepo CLI",
+  "main": "src/cli.js",
+  "scripts": {
+    "permission": "chmod -R 777 ./bin/*",
+    "crud": "node ./bin/microservice-crud"
+  },
+  "bin": {
+    "@mikemajesty/microservice-crud": "bin/microservice-crud",
+    "microservice-crud": "bin/microservice-crud"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "cli",
+    "microservice-crud"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "arg": "^5.0.1",
+    "cli-select": "^1.1.2",
+    "colorette": "^2.0.19",
+    "esm": "^3.2.25",
+    "fs": "^0.0.1-security",
+    "fs-extra": "^10.1.0",
+    "prompt-sync": "^4.2.0",
+    "rimraf": "^3.0.2"
+  }
+}

package/src/cli.js

@@ -0,0 +1,314 @@
+import fs from 'fs';
+import { bold, green, red } from 'colorette';
+const fse = require('fs-extra');
+import path from 'path';
+const { exec } = require('child_process');
+const cliSelect = require('cli-select');
+const prompt = require('prompt-sync')();
+
+const { getCoreUsecaseCreateTest } = require('./templates/postgres/core/use-cases/__tests__/create.spec');
+const { getCoreUsecaseUpdateTest } = require('./templates/postgres/core/use-cases/__tests__/update.spec');
+const { getCoreUsecaseDeleteTest } = require('./templates/postgres/core/use-cases/__tests__/delete.spec');
+const { getCoreUsecaseListTest } = require('./templates/postgres/core/use-cases/__tests__/list.spec');
+const { getCoreUsecaseGetByIDTest } = require('./templates/postgres/core/use-cases/__tests__/getByID.spec');
+const { getCoreUsecaseGetByID } = require('./templates/postgres/core/use-cases/getByID');
+const { getCoreUsecaseList } = require('./templates/postgres/core/use-cases/list');
+const { getCoreEntity } = require('./templates/postgres/core/entity/entity');
+const { getCoreRepository } = require('./templates/postgres/core/repository/repository');
+const { getCoreUsecaseCreate } = require('./templates/postgres/core/use-cases/create');
+const { getCoreUsecaseDelete } = require('./templates/postgres/core/use-cases/delete');
+const { getCoreUsecaseUpdate } = require('./templates/postgres/core/use-cases/update');
+
+const { getModuleAdapter } = require('./templates/postgres/modules/adapter');
+const { getModuleController } = require('./templates/postgres/modules/controller');
+const { getModule } = require('./templates/postgres/modules/module');
+const { getModuleRepository } = require('./templates/postgres/modules/repository');
+const { getModuleSchema } = require('./templates/postgres/modules/schema');
+const { getModuleSwagger } = require('./templates/postgres/modules/swagger');
+const { getModuleType } = require('./templates/postgres/modules/types');
+
+const { getCoreUsecaseCreateTest: getCoreUsecaseCreateMongoTest } = require('./templates/mongo/core/use-cases/__tests__/create.spec');
+const { getCoreUsecaseUpdateTest: getCoreUsecaseUpdateMongoTest } = require('./templates/mongo/core/use-cases/__tests__/update.spec');
+const { getCoreUsecaseDeleteTest: getCoreUsecaseDeleteMongoTest } = require('./templates/mongo/core/use-cases/__tests__/delete.spec');
+const { getCoreUsecaseListTest: getCoreUsecaseListMongoTest } = require('./templates/mongo/core/use-cases/__tests__/list.spec');
+const { getCoreUsecaseGetByIDTest: getCoreUsecaseGetByIDMongoTest } = require('./templates/mongo/core/use-cases/__tests__/getByID.spec');
+const { getCoreUsecaseGetByID: getCoreUsecaseGetByIDMongo } = require('./templates/mongo/core/use-cases/getByID');
+const { getCoreUsecaseList: getCoreUsecaseListMongo } = require('./templates/mongo/core/use-cases/list');
+const { getCoreEntity: getCoreEntityMongo } = require('./templates/mongo/core/entity/entity');
+const { getCoreRepository: getCoreRepositoryMongo } = require('./templates/mongo/core/repository/repository');
+const { getCoreUsecaseCreate: getCoreUsecaseCreateMongo } = require('./templates/mongo/core/use-cases/create');
+const { getCoreUsecaseDelete: getCoreUsecaseDeleteMongo } = require('./templates/mongo/core/use-cases/delete');
+const { getCoreUsecaseUpdate: getCoreUsecaseUpdateMongo } = require('./templates/mongo/core/use-cases/update');
+
+const { getModuleAdapter: getModuleAdapterMongo } = require('./templates/mongo/modules/adapter');
+const { getModuleController: getModuleControllerMongo } = require('./templates/mongo/modules/controller');
+const { getModule: getModuleMongo } = require('./templates/mongo/modules/module');
+const { getModuleRepository: getModuleRepositoryMongo } = require('./templates/mongo/modules/repository');
+const { getModuleSchema: getModuleSchemaMongo } = require('./templates/mongo/modules/schema');
+const { getModuleSwagger: getModuleSwaggerMongo } = require('./templates/mongo/modules/swagger');
+const { getModuleType: getModuleTypeMongo } = require('./templates/mongo/modules/types');
+
+
+const createPostgresCrud = async (name) => {
+  if (!name) throw new Error('--name is required')
+  name = name.toLowerCase()
+
+  const dirRoot = `${__dirname}/scafold/postgres/${name}`
+
+  try {
+    if (fs.existsSync(dirRoot)) {
+      fs.rmSync(dirRoot, { recursive: true });
+    }
+
+    fs.mkdirSync(dirRoot)
+
+    fs.mkdirSync(`${dirRoot}/modules`)
+
+    fs.mkdirSync(`${dirRoot}/core`)
+
+    const dirCore = `${dirRoot}/core/${name}`;
+    fs.mkdirSync(dirCore)
+
+    const entityPath = `${dirCore}/entity`;
+    const repositoryPath = `${dirCore}/repository`;
+    const useCasesPath = `${dirCore}/use-cases`;
+
+    fs.mkdirSync(entityPath)
+    fs.mkdirSync(repositoryPath)
+    fs.mkdirSync(useCasesPath)
+
+    fs.writeFileSync(`${entityPath}/${name}.ts`, getCoreEntity(name))
+    fs.writeFileSync(`${repositoryPath}/${name}.ts`, getCoreRepository(name))
+
+
+    fs.writeFileSync(`${useCasesPath}/${name}-create.ts`, getCoreUsecaseCreate(name))
+    fs.writeFileSync(`${useCasesPath}/${name}-delete.ts`, getCoreUsecaseDelete(name))
+    fs.writeFileSync(`${useCasesPath}/${name}-getByID.ts`, getCoreUsecaseGetByID(name))
+    fs.writeFileSync(`${useCasesPath}/${name}-list.ts`, getCoreUsecaseList(name))
+    fs.writeFileSync(`${useCasesPath}/${name}-update.ts`, getCoreUsecaseUpdate(name))
+
+    const useCasesPathTest = `${useCasesPath}/__tests__`
+    fs.mkdirSync(useCasesPathTest)
+
+    fs.writeFileSync(`${useCasesPathTest}/${name}-create.spec.ts`, getCoreUsecaseCreateTest(name))
+    fs.writeFileSync(`${useCasesPathTest}/${name}-update.spec.ts`, getCoreUsecaseUpdateTest(name))
+    fs.writeFileSync(`${useCasesPathTest}/${name}-delete.spec.ts`, getCoreUsecaseDeleteTest(name))
+    fs.writeFileSync(`${useCasesPathTest}/${name}-list.spec.ts`, getCoreUsecaseListTest(name))
+    fs.writeFileSync(`${useCasesPathTest}/${name}-getByID.spec.ts`, getCoreUsecaseGetByIDTest(name))
+
+    const modulesPath = `${dirRoot}/modules/${name}`;
+    fs.mkdirSync(modulesPath)
+
+    fs.writeFileSync(`${modulesPath}/adapter.ts`, getModuleAdapter(name))
+    fs.writeFileSync(`${modulesPath}/controller.ts`, getModuleController(name))
+    fs.writeFileSync(`${modulesPath}/module.ts`, getModule(name))
+    fs.writeFileSync(`${modulesPath}/repository.ts`, getModuleRepository(name))
+    fs.writeFileSync(`${modulesPath}/schema.ts`, getModuleSchema(name))
+    fs.writeFileSync(`${modulesPath}/swagger.ts`, getModuleSwagger(name))
+    fs.writeFileSync(`${modulesPath}/types.ts`, getModuleType(name))
+
+    return `${name}`
+  } catch (error) {
+    console.log('error', error)
+    if (fs.existsSync(dirRoot)) {
+      fs.rmSync(dirRoot, { recursive: true });
+    }
+    return `${name}`
+  }
+
+}
+
+const createMongoCrud = async (name) => {
+  if (!name) throw new Error('--name is required')
+  name = name.toLowerCase()
+
+  const dirRoot = `${__dirname}/scafold/mongo/${name}`
+
+  try {
+    if (fs.existsSync(dirRoot)) {
+      fs.rmSync(dirRoot, { recursive: true });
+    }
+
+    fs.mkdirSync(dirRoot)
+
+    fs.mkdirSync(`${dirRoot}/modules`)
+
+    fs.mkdirSync(`${dirRoot}/core`)
+
+    const dirCore = `${dirRoot}/core/${name}`;
+    fs.mkdirSync(dirCore)
+
+    const entityPath = `${dirCore}/entity`;
+    const repositoryPath = `${dirCore}/repository`;
+    const useCasesPath = `${dirCore}/use-cases`;
+
+    fs.mkdirSync(entityPath)
+    fs.mkdirSync(repositoryPath)
+    fs.mkdirSync(useCasesPath)
+
+    fs.writeFileSync(`${entityPath}/${name}.ts`, getCoreEntityMongo(name))
+    fs.writeFileSync(`${repositoryPath}/${name}.ts`, getCoreRepositoryMongo(name))
+
+
+    fs.writeFileSync(`${useCasesPath}/${name}-create.ts`, getCoreUsecaseCreateMongo(name))
+    fs.writeFileSync(`${useCasesPath}/${name}-delete.ts`, getCoreUsecaseDeleteMongo(name))
+    fs.writeFileSync(`${useCasesPath}/${name}-getByID.ts`, getCoreUsecaseGetByIDMongo(name))
+    fs.writeFileSync(`${useCasesPath}/${name}-list.ts`, getCoreUsecaseListMongo(name))
+    fs.writeFileSync(`${useCasesPath}/${name}-update.ts`, getCoreUsecaseUpdateMongo(name))
+
+    const useCasesPathTest = `${useCasesPath}/__tests__`
+    fs.mkdirSync(useCasesPathTest)
+
+    fs.writeFileSync(`${useCasesPathTest}/${name}-create.spec.ts`, getCoreUsecaseCreateMongoTest(name))
+    fs.writeFileSync(`${useCasesPathTest}/${name}-update.spec.ts`, getCoreUsecaseUpdateMongoTest(name))
+    fs.writeFileSync(`${useCasesPathTest}/${name}-delete.spec.ts`, getCoreUsecaseDeleteMongoTest(name))
+    fs.writeFileSync(`${useCasesPathTest}/${name}-list.spec.ts`, getCoreUsecaseListMongoTest(name))
+    fs.writeFileSync(`${useCasesPathTest}/${name}-getByID.spec.ts`, getCoreUsecaseGetByIDMongoTest(name))
+
+    const modulesPath = `${dirRoot}/modules/${name}`;
+    fs.mkdirSync(modulesPath)
+
+    fs.writeFileSync(`${modulesPath}/adapter.ts`, getModuleAdapterMongo(name))
+    fs.writeFileSync(`${modulesPath}/controller.ts`, getModuleControllerMongo(name))
+    fs.writeFileSync(`${modulesPath}/module.ts`, getModuleMongo(name))
+    fs.writeFileSync(`${modulesPath}/repository.ts`, getModuleRepositoryMongo(name))
+    fs.writeFileSync(`${modulesPath}/schema.ts`, getModuleSchemaMongo(name))
+    fs.writeFileSync(`${modulesPath}/swagger.ts`, getModuleSwaggerMongo(name))
+    fs.writeFileSync(`${modulesPath}/types.ts`, getModuleTypeMongo(name))
+
+    return `${name}`
+  } catch (error) {
+    console.log('error', error)
+    if (fs.existsSync(dirRoot)) {
+      fs.rmSync(dirRoot, { recursive: true });
+    }
+    return `${name}`
+  }
+
+}
+
+export const parseArgumentsInoOptions = async (input) => {
+  return {
+    mongoCrud: input.type === 'mongo:crud' ? await createMongoCrud(input.name) : false,
+    postgresCrud: input.type === 'postgres:crud' ? await createPostgresCrud(input.name) : false
+  }
+}
+
+export async function cli(args) {
+
+  console.log(bold(green('Selecting template...')))
+  const cli = await cliSelect({
+    values: [bold('POTGRES:CRUD'), bold('MONGO:CRUD')],
+    valueRenderer: (value, selected) => {
+      if (selected) {
+        return value;
+      }
+
+      return value;
+    },
+  })
+
+  const mapSelectType = { 0: 'postgres:crud', 1: 'mongo:crud' }[cli.id]
+  const userInput = { name: undefined, type: undefined }
+
+  userInput.type = mapSelectType
+
+  if (!userInput.type) {
+    console.log(red('Type is required'))
+    return
+  }
+
+  const name = prompt(bold(`Type your ${userInput.type.toUpperCase()} name: `));
+
+  if (!name) {
+    console.log(red('Name is required'))
+    return
+  }
+
+  userInput.name = name
+
+  const options = await parseArgumentsInoOptions(userInput)
+
+  const paths = []
+
+  for (const key in options) {
+    if (options[key]) {
+      paths.push(path.resolve(`${__dirname}/../src/scafold/${userInput.type === 'postgres:crud' ? 'postgres' : 'mongo'}/`, options[key]))
+    }
+  }
+
+  try {
+
+    exec('zenity --file-selection --directory --title="Choose your path" --filename=$HOME/', async (err, dest) => {
+      const src = paths[0]
+
+      if (err) {
+        if (fs.existsSync(src)) {
+          fs.rmSync(src, { recursive: true });
+        }
+        console.error(err.message)
+        return
+      }
+
+      // VALIDATE 
+      fs.readdir(dest.replace('\n', '') + '/src', function (err, folders) {
+        if (err) {
+          if (fs.existsSync(src)) {
+            fs.rmSync(src, { recursive: true });
+          }
+          console.error(err.message)
+          return
+        }
+
+        for (const folder of ['core', 'modules']) {
+          const source = folders.find(f => f === folder)
+          if (!source) {
+            console.log(bold(red('error')))
+            console.error('select nestjs microservice api root')
+            return
+          }
+        }
+      });
+
+
+
+      // CREATE CRUD
+      fs.readdir(src, function (err, folders) {
+        if (err) {
+          if (fs.existsSync(src)) {
+            fs.rmSync(src, { recursive: true });
+          }
+          console.error(err.message)
+          return
+        }
+
+
+        for (const folder of folders) {
+          const source = `${src}/${folder}`;
+          const destination = `${dest}/src/${folder}`.replace('\n', '');
+
+          fse.copySync(source, destination, { overwrite: true });
+
+          if (fs.existsSync(source)) {
+            fs.rmSync(source, { recursive: true });
+          }
+        }
+      });
+
+
+      // fs.rmSync(src, { recursive: true });
+      
+      // console.log(bold(green('done')))
+
+      // if (userInput.type === 'api') {
+      //   console.log(red('!!!!!!!!!!REAMDE!!!!!!!'), bold('https://github.com/mikemajesty/microservice-crud/blob/master/APP.md'))
+      // }
+    });
+
+  } catch (error) {
+    console.log(error)
+    if (fs.existsSync(paths[0])) {
+      fs.rmSync(paths[0], { recursive: true });
+    }
+  }
+}

package/src/templates/mongo/core/entity/entity.js

@@ -0,0 +1,49 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getCoreEntity = (name) => `import { z } from 'zod';
+
+import { IEntity, withID } from '@/utils/entity';
+
+const ID = z.string().uuid();
+const Name = z.string().min(1).max(200).trim();
+const CreatedAt = z.date().nullish();
+const UpdatedAt = z.date().nullish();
+const DeletedAt = z.date().default(null).nullish();
+
+export const ${capitalizeFirstLetter(name)}EntitySchema = z.object({
+  id: ID,
+  name: Name,
+  createdAt: CreatedAt,
+  updatedAt: UpdatedAt,
+  deletedAt: DeletedAt
+});
+
+type ${capitalizeFirstLetter(name)} = z.infer<typeof ${capitalizeFirstLetter(name)}EntitySchema>;
+
+export class ${capitalizeFirstLetter(name)}Entity implements IEntity {
+  id: string;
+
+  name: string;
+
+  deletedAt?: Date;
+
+  createdAt: Date;
+
+  updatedAt: Date;
+
+  constructor(entity: ${capitalizeFirstLetter(name)}) {
+    Object.assign(this, ${capitalizeFirstLetter(name)}EntitySchema.parse(withID(entity)));
+  }
+
+  setDelete() {
+    this.deletedAt = new Date();
+  }
+}
+`
+
+module.exports = {
+  getCoreEntity
+}

package/src/templates/mongo/core/repository/repository.js

@@ -0,0 +1,18 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getCoreRepository = (name) => `import { IRepository } from '@/infra/repository';
+import { ${capitalizeFirstLetter(name)}ListInput, ${capitalizeFirstLetter(name)}ListOutput } from '@/modules/${name}/types';
+
+import { ${capitalizeFirstLetter(name)}Entity } from '../entity/${name}';
+
+export abstract class I${capitalizeFirstLetter(name)}Repository extends IRepository<${capitalizeFirstLetter(name)}Entity> {
+  abstract paginate(input: ${capitalizeFirstLetter(name)}ListInput): Promise<${capitalizeFirstLetter(name)}ListOutput>;
+}
+`
+
+module.exports = {
+  getCoreRepository
+}

package/src/templates/mongo/core/use-cases/__tests__/create.spec.js

@@ -0,0 +1,63 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getCoreUsecaseCreateTest = (name) => `import { Test } from '@nestjs/testing';
+
+import { I${capitalizeFirstLetter(name)}CreateAdapter } from '@/modules/${name}/adapter';
+import { ${capitalizeFirstLetter(name)}CreateInput } from '@/modules/${name}/types';
+import { expectZodError } from '@/utils/tests';
+
+import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
+import { ${capitalizeFirstLetter(name)}CreateUsecase } from '../${name}-create';
+
+const ${name} = {
+  name: 'dummy'
+} as ${capitalizeFirstLetter(name)}CreateInput;
+
+describe('${capitalizeFirstLetter(name)}CreateUsecase', () => {
+  let usecase: I${capitalizeFirstLetter(name)}CreateAdapter;
+  let repository: I${capitalizeFirstLetter(name)}Repository;
+
+  beforeEach(async () => {
+    const app = await Test.createTestingModule({
+      providers: [
+        {
+          provide: I${capitalizeFirstLetter(name)}Repository,
+          useValue: {}
+        },
+        {
+          provide: I${capitalizeFirstLetter(name)}CreateAdapter,
+          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository) => {
+            return new ${capitalizeFirstLetter(name)}CreateUsecase(${name}Repository);
+          },
+          inject: [I${capitalizeFirstLetter(name)}Repository]
+        }
+      ]
+    }).compile();
+
+    usecase = app.get(I${capitalizeFirstLetter(name)}CreateAdapter);
+    repository = app.get(I${capitalizeFirstLetter(name)}Repository);
+  });
+
+  test('should create successfully', async () => {
+    repository.findOne = jest.fn().mockResolvedValue(null);
+    repository.create = jest.fn().mockResolvedValue(${name});
+    await expect(usecase.execute(${name})).resolves.toEqual(${name});
+  });
+
+  test('should throw error when invalid parameters', async () => {
+    await expectZodError(
+      () => usecase.execute({}),
+      (issues) => {
+        expect(issues).toEqual([{ message: 'Required', path: 'name' }]);
+      }
+    );
+  });
+});
+`
+
+module.exports = {
+  getCoreUsecaseCreateTest
+}

package/src/templates/mongo/core/use-cases/__tests__/delete.spec.js

@@ -0,0 +1,74 @@
+
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+const getCoreUsecaseDeleteTest = (name) => `import { Test } from '@nestjs/testing';
+
+import { I${capitalizeFirstLetter(name)}DeleteAdapter } from '@/modules/${name}/adapter';
+import { ApiNotFoundException } from '@/utils/exception';
+import { expectZodError, generateUUID } from '@/utils/tests';
+
+import { ${capitalizeFirstLetter(name)}Entity } from '../../entity/${name}';
+import { I${capitalizeFirstLetter(name)}Repository } from '../../repository/${name}';
+import { ${capitalizeFirstLetter(name)}DeleteUsecase } from '../${name}-delete';
+
+const ${name}Response = {
+  id: generateUUID(),
+  name: 'dummy'
+} as ${capitalizeFirstLetter(name)}Entity;
+
+describe('${capitalizeFirstLetter(name)}DeleteUsecase', () => {
+  let usecase: I${capitalizeFirstLetter(name)}DeleteAdapter;
+  let repository: I${capitalizeFirstLetter(name)}Repository;
+
+  beforeEach(async () => {
+    const app = await Test.createTestingModule({
+      imports: [],
+      providers: [
+        {
+          provide: I${capitalizeFirstLetter(name)}Repository,
+          useValue: {}
+        },
+        {
+          provide: I${capitalizeFirstLetter(name)}DeleteAdapter,
+          useFactory: (${name}Repository: I${capitalizeFirstLetter(name)}Repository) => {
+            return new ${capitalizeFirstLetter(name)}DeleteUsecase(${name}Repository);
+          },
+          inject: [I${capitalizeFirstLetter(name)}Repository]
+        }
+      ]
+    }).compile();
+
+    usecase = app.get(I${capitalizeFirstLetter(name)}DeleteAdapter);
+    repository = app.get(I${capitalizeFirstLetter(name)}Repository);
+  });
+
+  test('should throw error when invalid parameters', async () => {
+    await expectZodError(
+      () => usecase.execute({ id: 'uuid' }),
+      (issues) => {
+        expect(issues).toEqual([{ message: 'Invalid uuid', path: 'id' }]);
+      }
+    );
+  });
+
+  test('should throw error when ${name} not found', async () => {
+    repository.findById = jest.fn().mockResolvedValue(null);
+    await expect(usecase.execute({ id: generateUUID() })).rejects.toThrowError(ApiNotFoundException);
+  });
+
+  test('should delete successfully', async () => {
+    repository.findById = jest.fn().mockResolvedValue(${name}Response);
+    repository.updateOne = jest.fn();
+    await expect(usecase.execute({ id: generateUUID() })).resolves.toEqual({
+      ...${name}Response,
+      deletedAt: expect.any(Date)
+    });
+  });
+});
+`
+
+module.exports = {
+  getCoreUsecaseDeleteTest
+}