@hg-ts/http-controller 0.5.17 → 0.5.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hg-ts/http-controller",
-  "version": "0.5.17",
+  "version": "0.5.19",
   "main": "dist/index.js",
   "type": "module",
   "exports": {
@@ -18,15 +18,15 @@
     "test:dev": "vitest watch"
   },
   "devDependencies": {
-    "@hg-ts-config/typescript": "0.5.17",
-    "@hg-ts/exception": "0.5.17",
-    "@hg-ts/execution-mode": "0.5.17",
-    "@hg-ts/knex": "0.5.17",
-    "@hg-ts/linter": "0.5.17",
-    "@hg-ts/logger": "0.5.17",
-    "@hg-ts/tests": "0.5.17",
-    "@hg-ts/types": "0.5.17",
-    "@hg-ts/validation": "0.5.17",
+    "@hg-ts-config/typescript": "0.5.19",
+    "@hg-ts/exception": "0.5.19",
+    "@hg-ts/execution-mode": "0.5.19",
+    "@hg-ts/knex": "0.5.19",
+    "@hg-ts/linter": "0.5.19",
+    "@hg-ts/logger": "0.5.19",
+    "@hg-ts/tests": "0.5.19",
+    "@hg-ts/types": "0.5.19",
+    "@hg-ts/validation": "0.5.19",
     "@nestjs/common": "11.1.0",
     "@nestjs/core": "11.1.0",
     "@nestjs/platform-fastify": "11.1.0",
@@ -47,11 +47,11 @@
     "vitest": "4.0.14"
   },
   "peerDependencies": {
-    "@hg-ts/exception": "0.5.17",
-    "@hg-ts/execution-mode": "0.5.17",
-    "@hg-ts/knex": "0.5.17",
-    "@hg-ts/logger": "0.5.17",
-    "@hg-ts/validation": "0.5.17",
+    "@hg-ts/exception": "0.5.19",
+    "@hg-ts/execution-mode": "0.5.19",
+    "@hg-ts/knex": "0.5.19",
+    "@hg-ts/logger": "0.5.19",
+    "@hg-ts/validation": "0.5.19",
     "@nestjs/common": "*",
     "@nestjs/core": "*",
     "@nestjs/platform-fastify": "*",

package/src/decorators/decorators.ts

@@ -0,0 +1,43 @@
+import { BaseException } from '@hg-ts/exception';
+import { createSchema } from '@hg-ts/validation';
+
+import { ApiResponse } from '@nestjs/swagger';
+
+import { ExceptionStatusAlreadyDefinedException } from '../exceptions/index.js';
+import { ExceptionService } from '../services/index.js';
+
+export type ExceptionMap = Map<Class<BaseException, any[]>, number>;
+
+export const EXCEPTION_METADATA_KEY = Symbol('EXCEPTION_METADATA_KEY');
+
+export class Http {
+	private constructor() {}
+
+	public static ExceptionStatus(exception: Class<BaseException, any[]>, statusCode: number): MethodDecorator {
+		return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
+			const statusMap: ExceptionMap =
+				Reflect.getMetadata(EXCEPTION_METADATA_KEY, target, propertyKey) ?? new Map();
+
+			if (statusMap.has(exception)) {
+				throw new ExceptionStatusAlreadyDefinedException(exception);
+			}
+
+			statusMap.set(exception, statusCode);
+			Reflect.defineMetadata(EXCEPTION_METADATA_KEY, statusMap, target, propertyKey);
+
+			const exceptionVariants = [...statusMap.entries()];
+
+			const schemas = exceptionVariants
+				.filter(([, exceptionStatusCode]) => exceptionStatusCode === statusCode)
+				.map(([item]) => ExceptionService.getSchema(item))
+				.map(item => item.schema)
+				.map(item => createSchema(item, { io: 'input' }))
+				.map(item => item.schema as any);
+
+			ApiResponse({
+				schema: schemas.length === 1 ? schemas[0] : { oneOf: schemas },
+				status: statusCode,
+			})(target, propertyKey, descriptor);
+		};
+	}
+}

package/src/decorators/index.ts

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

package/src/exceptions/exception-schema-already-exists.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from '@hg-ts/exception';
+
+export class ExceptionSchemaAlreadyExistsException extends BaseException {
+	public constructor(exception: Class<BaseException, any[]>) {
+		super(`Schema for exception "${exception.name}" already exists`);
+	}
+}

package/src/exceptions/exception-schema-not-found.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from '@hg-ts/exception';
+
+export class ExceptionSchemaNotFoundException extends BaseException {
+	public constructor(exception: Class<BaseException, any[]>) {
+		super(`Schema for exception "${exception.name}" not found`);
+	}
+}

package/src/exceptions/exception-status-already-defined.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from '@hg-ts/exception';
+
+export class ExceptionStatusAlreadyDefinedException extends BaseException {
+	public constructor(exception: Class<BaseException, any[]>) {
+		super(`Status for exception "${exception.name}" already defined`);
+	}
+}

package/src/exceptions/index.ts

@@ -0,0 +1,3 @@
+export * from './exception-schema-already-exists.exception.js';
+export * from './exception-schema-not-found.exception.js';
+export * from './exception-status-already-defined.exception.js';

package/src/http-controller.module.ts

@@ -0,0 +1,49 @@
+import {
+	DynamicModule,
+	Module,
+} from '@nestjs/common';
+import {
+	APP_INTERCEPTOR,
+	APP_PIPE,
+} from '@nestjs/core';
+import {
+	DatabaseInterceptor,
+	ExceptionMapperInterceptor,
+	ValidationPipe,
+} from './middlewares/index.js';
+
+import { SwaggerService } from './services/index.js';
+
+type HttpControllerModuleOptions = {
+	disableTransactions?: boolean;
+};
+
+@Module({
+	providers: [
+		SwaggerService,
+		{
+			provide: APP_INTERCEPTOR,
+			useClass: ExceptionMapperInterceptor,
+		},
+		{
+			provide: APP_PIPE,
+			useClass: ValidationPipe,
+		},
+	],
+})
+export class HttpControllerModule {
+	public static forRoot(options: HttpControllerModuleOptions = {}): DynamicModule {
+		const { disableTransactions = false } = options;
+		return {
+			module: HttpControllerModule,
+			providers: disableTransactions
+				? []
+				: [
+					{
+						provide: APP_INTERCEPTOR,
+						useClass: DatabaseInterceptor,
+					},
+				],
+		};
+	}
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { Http } from './decorators/index.js';
+export { ExceptionService, SwaggerService } from './services/index.js';
+export * from './http-controller.module.js';

package/src/middlewares/database.interceptor.ts

@@ -0,0 +1,40 @@
+import { KnexService } from '@hg-ts/knex';
+import { Logger } from '@hg-ts/logger';
+
+import {
+	CallHandler,
+	Catch,
+	ExecutionContext,
+	Inject,
+	NestInterceptor,
+	Optional,
+} from '@nestjs/common';
+
+import {
+	from,
+	lastValueFrom,
+	Observable,
+} from 'rxjs';
+
+@Catch()
+export class DatabaseInterceptor implements NestInterceptor {
+	@Inject()
+	protected readonly logger: Logger;
+
+	@Optional()
+	@Inject()
+	private readonly postgresService?: KnexService;
+
+	public intercept(
+		_context: ExecutionContext,
+		next: CallHandler,
+	): Observable<any> {
+		if (!this.postgresService) {
+			this.logger.warning('PostgresService not provided');
+			return next.handle();
+		}
+		const transactionalPromise = this.postgresService.runInTransaction(async() => lastValueFrom(next.handle()));
+
+		return from(transactionalPromise);
+	}
+}

package/src/middlewares/exception-mapper.interceptor.ts

@@ -0,0 +1,83 @@
+import {
+	BaseException,
+	ErrorException,
+} from '@hg-ts/exception';
+import { Logger } from '@hg-ts/logger';
+import { ValidationException } from '@hg-ts/validation';
+
+import {
+	CallHandler,
+	Catch,
+	ExecutionContext,
+	Inject,
+	NestInterceptor,
+} from '@nestjs/common';
+import { isAxiosError } from 'axios';
+import { FastifyReply } from 'fastify';
+import {
+	Observable,
+	tap,
+} from 'rxjs';
+import {
+	EXCEPTION_METADATA_KEY,
+	ExceptionMap,
+} from '../decorators/index.js';
+
+@Catch()
+export class ExceptionMapperInterceptor implements NestInterceptor {
+	@Inject()
+	protected readonly logger: Logger;
+
+	public intercept(
+		context: ExecutionContext,
+		next: CallHandler,
+	): Observable<any> {
+		return next.handle().pipe(tap({
+			error: error => {
+				const response = context.switchToHttp().getResponse<FastifyReply>();
+
+				if (isAxiosError(error)) {
+					response.status(error.status ?? 500).send(error.response?.data);
+
+					return;
+				}
+				const exception = this.getException(error);
+				const exceptionMap = this.getExceptionMap(context);
+				const exceptionCtor = this.getExceptionCtor(exception);
+				const status = exceptionMap.get(exceptionCtor);
+
+				response.status(status ?? 500).send(exception.toJSON());
+			},
+		}));
+	}
+
+	private getExceptionMap(context: ExecutionContext): ExceptionMap {
+		const exceptionMap: ExceptionMap = Reflect.getMetadata(
+			EXCEPTION_METADATA_KEY,
+			context.getClass().prototype,
+			context.getHandler().name,
+		) ?? new Map();
+
+		if (!exceptionMap.has(ValidationException)) {
+			exceptionMap.set(ValidationException, 404);
+		}
+		return exceptionMap;
+	}
+
+	private getExceptionCtor<T extends BaseException>(exception: T): Class<T, any[]> {
+		return Object.getPrototypeOf(exception)!.constructor as Class<T, any[]>;
+	}
+
+
+	private getException(exception: unknown): BaseException {
+		if (exception instanceof BaseException) {
+			return exception;
+		}
+
+		if (exception instanceof Error) {
+			return new ErrorException(exception);
+		}
+
+		return new ErrorException(new Error(String(exception)));
+	}
+}

package/src/middlewares/index.ts

@@ -0,0 +1,3 @@
+export * from './validation.pipe.js';
+export * from './exception-mapper.interceptor.js';
+export * from './database.interceptor.js';

package/src/middlewares/validation.pipe.ts

@@ -0,0 +1,39 @@
+import {
+	isZodDto,
+	ZodType,
+} from '@hg-ts/validation';
+
+import {
+	ArgumentMetadata,
+	PipeTransform,
+} from '@nestjs/common';
+
+import assert from 'node:assert/strict';
+
+export class ValidationPipe implements PipeTransform<unknown, unknown> {
+	private readonly dto: ZodType | null;
+
+	public constructor(dto?: ZodType) {
+		this.dto = dto ?? null;
+	}
+
+	public transform(value: unknown, { metatype }: ArgumentMetadata): unknown {
+		const schema = this.getSchema(metatype);
+
+		return schema.parse(value);
+	}
+
+	public static getInstance(): ValidationPipe {
+		return new ValidationPipe();
+	}
+
+	private getSchema(metatype?: Class<any, any[]>): ZodType {
+		if (this.dto) {
+			return this.dto;
+		}
+
+		assert.ok(isZodDto(metatype));
+
+		return metatype.schema;
+	}
+}

package/src/services/exception.service.ts

@@ -0,0 +1,34 @@
+import { BaseException } from '@hg-ts/exception';
+import { ZodDto } from '@hg-ts/validation';
+import {
+	ExceptionSchemaAlreadyExistsException,
+	ExceptionSchemaNotFoundException,
+} from '../exceptions/index.js';
+
+export class ExceptionService {
+	private static readonly exceptionMap = new Map<Class<BaseException>, ZodDto>();
+
+	public static registerSchema<T extends BaseException>(
+		this: typeof ExceptionService,
+		exception: Class<T, any[]>,
+		schema: ZodDto<ReturnType<T['toJSON']>>,
+	): void {
+		if (this.exceptionMap.has(exception)) {
+			throw new ExceptionSchemaAlreadyExistsException(exception);
+		}
+
+		this.exceptionMap.set(exception, schema);
+	}
+
+	public static getSchema<T extends BaseException>(
+		this: typeof ExceptionService,
+		exception: Class<T, any[]>,
+	): ZodDto<ReturnType<T['toJSON']>> {
+		const schema = this.exceptionMap.get(exception);
+		if (!schema) {
+			throw new ExceptionSchemaNotFoundException(exception);
+		}
+
+		return schema;
+	}
+}

package/src/services/index.ts

@@ -0,0 +1,2 @@
+export * from './swagger.service.js';
+export * from './exception.service.js';

package/src/services/swagger.service.ts

@@ -0,0 +1,42 @@
+import { WillNeverHappenedException } from '@hg-ts/exception';
+import {
+	createSchema,
+	isZodDto,
+} from '@hg-ts/validation';
+
+import { INestApplication } from '@nestjs/common';
+import {
+	DocumentBuilder,
+	SwaggerModule,
+} from '@nestjs/swagger';
+import { SchemaObject } from '@nestjs/swagger/dist/interfaces/open-api-spec.interface.js';
+import { SchemaObjectFactory } from '@nestjs/swagger/dist/services/schema-object-factory.js';
+
+export class SwaggerService {
+	public setup(app: INestApplication): void {
+		this.patchSwaggerModule();
+
+		const config = new DocumentBuilder()
+			.setOpenAPIVersion('3.0.0')
+			.build();
+
+		const document = SwaggerModule.createDocument(app, config);
+
+		SwaggerModule.setup('/api', app, document, { jsonDocumentUrl: '/api/json' });
+	}
+
+	private patchSwaggerModule(): void {
+		SchemaObjectFactory.prototype.exploreModelSchema = function(
+			type: Class | Function | any,
+			schemas: any | Record<string, SchemaObject>,
+		): string {
+			if (!isZodDto(type)) {
+				throw new WillNeverHappenedException('Type will be zod schema');
+			}
+
+			schemas[type.name] = createSchema(type.schema, { io: 'input' }).schema;
+
+			return type.name;
+		};
+	}
+}

package/src/tests/abstracts/base-controller-suite.ts

@@ -0,0 +1,47 @@
+import { LoggerModule } from '@hg-ts/logger';
+import { Suite } from '@hg-ts/tests';
+
+import { INestApplication } from '@nestjs/common';
+import { FastifyAdapter } from '@nestjs/platform-fastify';
+import {
+	Test as TestFactory,
+	TestingModule,
+} from '@nestjs/testing';
+
+import axios, { AxiosInstance } from 'axios';
+import { HttpControllerModule } from '../../http-controller.module.js';
+
+export abstract class BaseControllerSuite extends Suite {
+	protected module: TestingModule;
+	protected container: INestApplication;
+	protected client: AxiosInstance;
+	private readonly moduleCtor: Class<any, any[]>;
+
+	public constructor(moduleCtor: Class<any, any[]>) {
+		super();
+
+		this.moduleCtor = moduleCtor;
+	}
+
+	public override async setUp(): Promise<void> {
+		this.module = await TestFactory
+			.createTestingModule({ imports: [this.moduleCtor, LoggerModule, HttpControllerModule] })
+			.compile();
+
+		const port = this.getPort();
+
+
+		this.container = this.module.createNestApplication(new FastifyAdapter());
+
+		await this.container.init();
+		await this.container.listen(port, 'localhost');
+
+		this.client = axios.create({ baseURL: `http://localhost:${port}` });
+	}
+
+	public override async tearDown(): Promise<void> {
+		await this.container.close();
+	}
+
+	protected abstract getPort(): number;
+}

package/src/tests/abstracts/index.ts

@@ -0,0 +1 @@
+export * from './base-controller-suite.js';

package/src/tests/echo/controllers/dto/echo-get.query.ts

@@ -0,0 +1,5 @@
+import { z } from '@hg-ts/validation';
+
+const echoGetQuerySchema = z.object({ test: z.string() });
+
+export class EchoGetQuery extends echoGetQuerySchema.toClass() {}

package/src/tests/echo/controllers/dto/echo-post.body.ts

@@ -0,0 +1,5 @@
+import { z } from '@hg-ts/validation';
+
+const echoPostBodySchema = z.object({ test: z.number() });
+
+export class EchoPostBody extends echoPostBodySchema.toClass() {}

package/src/tests/echo/controllers/dto/index.ts

@@ -0,0 +1,2 @@
+export * from './echo-get.query.js';
+export * from './echo-post.body.js';

package/src/tests/echo/controllers/echo.controller.ts

@@ -0,0 +1,45 @@
+import {
+	Body,
+	Controller,
+	Get,
+	Param,
+	Post,
+	Query,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import {
+	EchoGetQuery,
+	EchoPostBody,
+} from './dto/index.js';
+
+@ApiTags('Echo')
+@Controller('/echo')
+export class EchoController {
+	@Get('/query')
+	public async getEchoQuery(
+		@Query() query: EchoGetQuery,
+	): Promise<EchoGetQuery> {
+		return query;
+	}
+
+	@Get('/param/:test')
+	public async getEchoParam(
+		@Param() params: EchoGetQuery,
+	): Promise<EchoGetQuery> {
+		return params;
+	}
+
+	@Post('/query')
+	public async postEchoQuery(
+		@Query() query: EchoGetQuery,
+	): Promise<EchoGetQuery> {
+		return query;
+	}
+
+	@Post('/body')
+	public async postEchoBody(
+		@Body() body: EchoPostBody,
+	): Promise<EchoPostBody> {
+		return body;
+	}
+}

package/src/tests/echo/controllers/index.ts

@@ -0,0 +1 @@
+export * from './echo.controller.js';

package/src/tests/echo/echo.test.module.ts

@@ -0,0 +1,6 @@
+import { Module } from '@nestjs/common';
+
+import { EchoController } from './controllers/index.js';
+
+@Module({ controllers: [EchoController] })
+export class EchoTestModule {}

package/src/tests/echo/echo.test.ts

@@ -0,0 +1,73 @@
+import {
+	Describe,
+	expect,
+	ExpectException,
+	Test,
+} from '@hg-ts/tests';
+
+import { BaseControllerSuite } from '../abstracts/index.js';
+import { EchoTestModule } from './echo.test.module.js';
+
+@Describe()
+export class EchoTest extends BaseControllerSuite {
+	public constructor() {
+		super(EchoTestModule);
+	}
+
+	@Test()
+	public async echoGet(): Promise<void> {
+		const value = '3.12';
+		const params: Record<string, unknown> = { test: value };
+		const response = await this.client.get('/echo/query', { params });
+
+		expect(response.data).toMatchObject(params);
+	}
+
+	@Test()
+	public async echoPostQuery(): Promise<void> {
+		const value = '3.12';
+		const params: Record<string, unknown> = { test: value };
+		const response = await this.client.post('/echo/query', null, { params });
+
+		expect(response.data).toMatchObject(params);
+	}
+
+	@Test()
+	public async echoPostBody(): Promise<void> {
+		const value = 3.12;
+		const data: Record<string, unknown> = { test: value };
+		const response = await this.client.post('/echo/body', data);
+
+		expect(response.data).toMatchObject(data);
+	}
+
+	@Test()
+	public async echoGetParam(): Promise<void> {
+		const value = '3.12';
+		const params: Record<string, unknown> = { test: value };
+		const response = await this.client.get(`/echo/param/${value}`);
+
+		expect(response.data).toMatchObject(params);
+	}
+
+	@Test()
+	@ExpectException()
+	public async echoGetInvalidQuery(): Promise<void> {
+		const value = '5.16';
+		const params: Record<string, unknown> = { unknownKey: value };
+		await this.client.get('/echo/query', { params });
+	}
+
+	@Test()
+	@ExpectException()
+	public async echoGetFieldInvalidQuery(): Promise<void> {
+		const value = '9.10 unknown text';
+		const params: Record<string, unknown> = { unknownField: value };
+
+		await this.client.get('/echo/query/field', { params });
+	}
+
+	protected override getPort(): number {
+		return 50003;
+	}
+}

package/src/tests/exception/controllers/dtos/common-exception.dto.ts

@@ -0,0 +1,10 @@
+import { z } from '@hg-ts/validation';
+
+const schema = z.object({
+	name: z.string(),
+	code: z.number().nullable(),
+	message: z.string(),
+	stack: z.array(z.string()),
+});
+
+export class CommonExceptionDto extends schema.toClass() {}

package/src/tests/exception/controllers/dtos/index.ts

@@ -0,0 +1 @@
+export * from './common-exception.dto.js';

package/src/tests/exception/controllers/exception.controller.ts

@@ -0,0 +1,25 @@
+import { baseExceptionSchema } from '@hg-ts/validation';
+
+import {
+	Controller,
+	Get,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+
+import { Http } from '../../../decorators/index.js';
+import { ExceptionService } from '../../../services/index.js';
+import { MockNotFoundException } from '../exceptions/index.js';
+
+ExceptionService.registerSchema(MockNotFoundException, baseExceptionSchema.toClass());
+
+
+@ApiTags('Exception')
+@Controller('/exception')
+export class ExceptionController {
+	@Http.ExceptionStatus(MockNotFoundException, 404)
+	@Get('/404')
+	public async getNotFound(
+	): Promise<never> {
+		throw new MockNotFoundException();
+	}
+}

package/src/tests/exception/controllers/index.ts

@@ -0,0 +1 @@
+export * from './exception.controller.js';

package/src/tests/exception/exception.test.module.ts

@@ -0,0 +1,6 @@
+import { Module } from '@nestjs/common';
+
+import { ExceptionController } from './controllers/index.js';
+
+@Module({ controllers: [ExceptionController] })
+export class ExceptionTestModule {}

package/src/tests/exception/exception.test.ts

@@ -0,0 +1,45 @@
+import {
+	Describe,
+	expect,
+	ExpectException,
+	Test,
+} from '@hg-ts/tests';
+import {
+	AxiosError,
+	isAxiosError,
+} from 'axios';
+
+import { BaseControllerSuite } from '../abstracts/index.js';
+import { ExceptionTestModule } from './exception.test.module.js';
+
+@Describe()
+export class ExceptionTest extends BaseControllerSuite {
+	public constructor() {
+		super(ExceptionTestModule);
+	}
+
+	@Test()
+	@ExpectException(AxiosError)
+	public async echoGetFieldInvalidQuery(): Promise<void> {
+		const value = '9.10 unknown text';
+		const params: Record<string, unknown> = { unknownField: value };
+
+		try {
+			await this.client.get('/exception/404', { params });
+		} catch (error) {
+			this.checkIsAxiosError(isAxiosError(error));
+
+			expect(error.status).toBe(404);
+
+			throw error;
+		}
+	}
+
+	protected override getPort(): number {
+		return 50001;
+	}
+
+	private checkIsAxiosError(isAxiosError: boolean): asserts isAxiosError {
+		expect(isAxiosError).toBe(true);
+	}
+}

package/src/tests/exception/exceptions/index.ts

@@ -0,0 +1,2 @@
+export * from './mock-not-found.exception.js';
+export * from './mock-conflict.exception.js';

package/src/tests/exception/exceptions/mock-conflict.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from '@hg-ts/exception';
+
+export class MockConflictException extends BaseException {
+	public constructor() {
+		super('Test conflict');
+	}
+}

package/src/tests/exception/exceptions/mock-not-found.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from '@hg-ts/exception';
+
+export class MockNotFoundException extends BaseException {
+	public constructor() {
+		super('Test not found');
+	}
+}

package/src/tests/http-methods/controllers/empty-response.controller.ts

@@ -0,0 +1,59 @@
+import { expect } from '@hg-ts/tests';
+
+import {
+	All,
+	Controller,
+	Delete,
+	Get,
+	Options,
+	Patch,
+	Post,
+	Put,
+	Search,
+} from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+
+@ApiTags('Empty Response')
+@Controller('/empty-response')
+export class EmptyResponseController {
+	@Get()
+	public async getEmptyReturn(): Promise<void> {
+		expect(true).toBe(true);
+	}
+
+	@Post()
+	public async postEmptyReturn(): Promise<void> {
+		expect(true).toBe(true);
+	}
+
+	@Put()
+	public async putEmptyReturn(): Promise<void> {
+		expect(true).toBe(true);
+	}
+
+	@Patch()
+	public async patchEmptyReturn(): Promise<void> {
+		expect(true).toBe(true);
+	}
+
+	@Options()
+	public async optionsEmptyReturn(): Promise<void> {
+		expect(true).toBe(true);
+	}
+
+	@Delete()
+	public async deleteEmptyReturn(): Promise<void> {
+		expect(true).toBe(true);
+	}
+
+	@Search()
+	public async searchEmptyReturn(): Promise<void> {
+		expect(true).toBe(true);
+	}
+
+	@ApiTags('Empty Response All')
+	@All('/all')
+	public async allEmptyReturn(): Promise<void> {
+		expect(true).toBe(true);
+	}
+}

package/src/tests/http-methods/controllers/index.ts

@@ -0,0 +1 @@
+export * from './empty-response.controller.js';

package/src/tests/http-methods/http-methods.test.module.ts

@@ -0,0 +1,6 @@
+import { Module } from '@nestjs/common';
+
+import { EmptyResponseController } from './controllers/index.js';
+
+@Module({ controllers: [EmptyResponseController] })
+export class HttpMethodsTestModule {}

package/src/tests/http-methods/http-methods.test.ts

@@ -0,0 +1,75 @@
+import {
+	Describe,
+	expect,
+	Test,
+} from '@hg-ts/tests';
+
+import { HttpMethod } from '../../types.js';
+
+import { BaseControllerSuite } from '../abstracts/index.js';
+import { HttpMethodsTestModule } from './http-methods.test.module.js';
+
+@Describe()
+export class HttpMethodsTest extends BaseControllerSuite {
+	public constructor() {
+		super(HttpMethodsTestModule);
+	}
+
+	@Test()
+	public async emptyGetTest(): Promise<void> {
+		await this.testEmptyResponseTest(HttpMethod.GET);
+	}
+
+	@Test()
+	public async emptyPostTest(): Promise<void> {
+		await this.testEmptyResponseTest(HttpMethod.POST);
+	}
+
+	@Test()
+	public async emptyPutTest(): Promise<void> {
+		await this.testEmptyResponseTest(HttpMethod.PUT);
+	}
+
+	@Test()
+	public async emptyPatchTest(): Promise<void> {
+		await this.testEmptyResponseTest(HttpMethod.PATCH);
+	}
+
+	@Test()
+	public async emptyDeleteTest(): Promise<void> {
+		await this.testEmptyResponseTest(HttpMethod.DELETE);
+	}
+
+	@Test()
+	public async emptyOptionsTest(): Promise<void> {
+		await this.testEmptyResponseTest(HttpMethod.OPTIONS);
+	}
+
+	@Test()
+	public async emptySearchTest(): Promise<void> {
+		await this.testEmptyResponseTest(HttpMethod.SEARCH);
+	}
+
+	@Test()
+	public async emptyAllTest(): Promise<void> {
+		const methods = Object.values(HttpMethod);
+
+		await Promise.all(methods.map(async method => this.testEmptyResponseTest(method, '/all')));
+
+		expect.assertions(methods.length * 2);
+	}
+
+	protected override getPort(): number {
+		return 50002;
+	}
+
+	private async testEmptyResponseTest(method: HttpMethod, suffixPath = ''): Promise<void> {
+		const response = await this.client.request({
+			method,
+			url: `/empty-response${suffixPath}`,
+		});
+
+		expect(response.data).toBe('');
+		expect.assertions(2);
+	}
+}

package/src/types.ts

@@ -0,0 +1,9 @@
+export enum HttpMethod {
+	GET = 'GET',
+	POST = 'POST',
+	PUT = 'PUT',
+	PATCH = 'PATCH',
+	DELETE = 'DELETE',
+	OPTIONS = 'OPTIONS',
+	SEARCH = 'SEARCH',
+}