@dismissible/nestjs-api 0.0.2-canary.c91edbc.0 → 0.0.2-canary.d2f56d7.0

package/config/.env.yaml

@@ -14,11 +14,28 @@ helmet:
 
 cors:
   enabled: ${DISMISSIBLE_CORS_ENABLED:-true}
-  origins: ${DISMISSIBLE_CORS_ORIGINS:-http://localhost:3000}
+  origins: ${DISMISSIBLE_CORS_ORIGINS:-http://localhost:3001,http://localhost:5173}
   methods: ${DISMISSIBLE_CORS_METHODS:-GET,POST,DELETE,OPTIONS}
   allowedHeaders: ${DISMISSIBLE_CORS_ALLOWED_HEADERS:-Content-Type,Authorization,x-request-id}
   credentials: ${DISMISSIBLE_CORS_CREDENTIALS:-true}
   maxAge: ${DISMISSIBLE_CORS_MAX_AGE:-86400}
 
 db:
-  connectionString: ${DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING:-'postgresql://postgres:postgres@localhost:5432/dismissible'}
+  connectionString: ${DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING:-postgresql://postgres:postgres@localhost:5432/dismissible}
+
+jwtAuth:
+  enabled: ${DISMISSIBLE_JWT_AUTH_ENABLED:-false}
+  wellKnownUrl: ${DISMISSIBLE_JWT_AUTH_WELL_KNOWN_URL:-}
+  issuer: ${DISMISSIBLE_JWT_AUTH_ISSUER:-}
+  audience: ${DISMISSIBLE_JWT_AUTH_AUDIENCE:-}
+  algorithms:
+    - ${DISMISSIBLE_JWT_AUTH_ALGORITHMS:-RS256}
+  jwksCacheDuration: ${DISMISSIBLE_JWT_AUTH_JWKS_CACHE_DURATION:-600000}
+  requestTimeout: ${DISMISSIBLE_JWT_AUTH_REQUEST_TIMEOUT:-30000}
+  priority: ${DISMISSIBLE_JWT_AUTH_PRIORITY:--100}
+
+validation:
+  disableErrorMessages: ${DISMISSIBLE_VALIDATION_DISABLE_ERROR_MESSAGES:-true}
+  whitelist: ${DISMISSIBLE_VALIDATION_WHITELIST:-true}
+  forbidNonWhitelisted: ${DISMISSIBLE_VALIDATION_FORBID_NON_WHITELISTED:-true}
+  transform: ${DISMISSIBLE_VALIDATION_TRANSFORM:-true}

package/jest.config.ts

@@ -3,11 +3,33 @@ export default {
   preset: '../jest.preset.js',
   testEnvironment: 'node',
   transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.json' }],
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
   },
   moduleFileExtensions: ['ts', 'js', 'html'],
   coverageDirectory: '../coverage/api',
   testMatch: ['**/*.spec.ts'],
   testPathIgnorePatterns: ['\\.e2e-spec\\.ts$'],
   transformIgnorePatterns: ['node_modules/(?!(nest-typed-config|uuid)/)'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.spec.ts',
+    '!src/**/*.e2e-spec.ts',
+    '!src/**/*.interface.ts',
+    '!src/**/*.dto.ts',
+    '!src/**/*.enum.ts',
+    '!src/**/index.ts',
+    '!src/**/*.module.ts',
+    '!src/main.ts',
+    '!src/bootstrap.ts',
+    '!src/app.setup.ts',
+    '!src/app-test.factory.ts',
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80,
+    },
+  },
 };

package/jest.e2e-config.ts

@@ -3,10 +3,12 @@ export default {
   preset: '../jest.preset.js',
   testEnvironment: 'node',
   transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.json' }],
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.e2e.json' }],
   },
   moduleFileExtensions: ['ts', 'js', 'html'],
   coverageDirectory: '../coverage/api-e2e',
   testMatch: ['**/*.e2e-spec.ts'],
   transformIgnorePatterns: ['node_modules/(?!(nest-typed-config|uuid)/)'],
+  // Run tests sequentially to avoid database conflicts
+  maxWorkers: 1,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dismissible/nestjs-api",
-  "version": "0.0.2-canary.c91edbc.0",
+  "version": "0.0.2-canary.d2f56d7.0",
   "description": "Dismissible API application",
   "main": "./src/main.js",
   "types": "./src/main.d.ts",
@@ -15,14 +15,20 @@
     "dismissible-api": "./src/main.js"
   },
   "scripts": {
-    "start": "node src/main.js"
+    "start": "node src/main.js",
+    "prisma:generate": "npx dismissible-prisma generate",
+    "prisma:migrate:deploy": "npx dismissible-prisma migrate deploy",
+    "prisma:migrate:dev": "npx dismissible-prisma migrate dev",
+    "prisma:db:push": "npx dismissible-prisma db push",
+    "prisma:studio": "npx dismissible-prisma studio"
   },
   "dependencies": {
-    "@dismissible/nestjs-dismissible": "^0.0.2-canary.c91edbc.0",
-    "@dismissible/nestjs-dismissible-item": "^0.0.2-canary.c91edbc.0",
-    "@dismissible/nestjs-storage": "^0.0.2-canary.c91edbc.0",
-    "@dismissible/nestjs-postgres-storage": "^0.0.2-canary.c91edbc.0",
-    "@dismissible/nestjs-logger": "^0.0.2-canary.c91edbc.0",
+    "@dismissible/nestjs-dismissible": "^0.0.2-canary.d2f56d7.0",
+    "@dismissible/nestjs-dismissible-item": "^0.0.2-canary.d2f56d7.0",
+    "@dismissible/nestjs-jwt-auth-hook": "^0.0.1",
+    "@dismissible/nestjs-storage": "^0.0.2-canary.d2f56d7.0",
+    "@dismissible/nestjs-postgres-storage": "^0.0.2-canary.d2f56d7.0",
+    "@dismissible/nestjs-logger": "^0.0.2-canary.d2f56d7.0",
     "@nestjs/common": "^11.1.9",
     "@nestjs/core": "^11.1.9",
     "@nestjs/platform-fastify": "^11.1.9",

package/project.json

@@ -65,19 +65,22 @@
     "prisma:generate": {
       "executor": "nx:run-commands",
       "options": {
-        "command": "npx prisma generate --schema=libs/postgres-storage/prisma/schema.prisma"
+        "command": "npm run prisma:generate",
+        "cwd": "api"
       }
     },
     "prisma:migrate": {
       "executor": "nx:run-commands",
       "options": {
-        "command": "npx prisma migrate dev --schema=libs/postgres-storage/prisma/schema.prisma"
+        "command": "npm run prisma:migrate:dev",
+        "cwd": "api"
       }
     },
     "prisma:push": {
       "executor": "nx:run-commands",
       "options": {
-        "command": "npx prisma db push --schema=libs/postgres-storage/prisma/schema.prisma"
+        "command": "npm run prisma:db:push",
+        "cwd": "api"
       }
     },
     "npm-publish": {

package/scripts/performance-test.ts

@@ -673,7 +673,7 @@ async function runCreatePhase(
   for (let i = 0; i < config.createCount; i++) {
     const userId = userIds[i % userIds.length];
     const itemId = itemIds[i];
-    paths.push(`/v1/user/${userId}/dismissible-item/${itemId}`);
+    paths.push(`/v1/users/${userId}/items/${itemId}`);
   }
 
   const instance = autocannon(
@@ -741,7 +741,7 @@ async function runGetPhase(
   for (let i = 0; i < itemsToGet; i++) {
     const userId = userIds[i % userIds.length];
     const itemId = itemIds[i];
-    paths.push(`/v1/user/${userId}/dismissible-item/${itemId}`);
+    paths.push(`/v1/users/${userId}/items/${itemId}`);
   }
 
   const instance = autocannon(

package/src/app.module.ts

@@ -1,4 +1,4 @@
-import { Module, ModuleMetadata, Type } from '@nestjs/common';
+import { DynamicModule, Module, ModuleMetadata, Type } from '@nestjs/common';
 import { HealthModule } from './health';
 import { ConfigModule } from './config';
 import { AppConfig } from './config/app.config';
@@ -7,11 +7,17 @@ import { DismissibleModule } from '@dismissible/nestjs-dismissible';
 import { IDismissibleLogger } from '@dismissible/nestjs-logger';
 import { DefaultAppConfig } from './config/default-app.config';
 import { PostgresStorageConfig, PostgresStorageModule } from '@dismissible/nestjs-postgres-storage';
+import {
+  JwtAuthHookModule,
+  JwtAuthHook,
+  JwtAuthHookConfig,
+} from '@dismissible/nestjs-jwt-auth-hook';
 
 export type AppModuleOptions = {
   configPath?: string;
   schema?: new () => DefaultAppConfig;
   logger?: Type<IDismissibleLogger>;
+  imports?: DynamicModule[];
 };
 
 @Module({})
@@ -31,8 +37,14 @@ export class AppModule {
           schema: options?.schema ?? AppConfig,
         }),
         HealthModule,
+        ...(options?.imports ?? []),
+        JwtAuthHookModule.forRootAsync({
+          useFactory: (config: JwtAuthHookConfig) => config,
+          inject: [JwtAuthHookConfig],
+        }),
         DismissibleModule.forRoot({
           logger: options?.logger,
+          hooks: [JwtAuthHook],
           storage: PostgresStorageModule.forRootAsync({
             useFactory(config: PostgresStorageConfig) {
               return {

package/src/app.setup.ts

@@ -4,6 +4,7 @@ import fastifyHelmet from '@fastify/helmet';
 import { SwaggerConfig, configureAppWithSwagger } from './swagger';
 import { CorsConfig } from './cors';
 import { HelmetConfig } from './helmet';
+import { ValidationConfig } from './validation';
 
 export async function configureApp(app: INestApplication): Promise<void> {
   const fastifyApp = app as NestFastifyApplication;
@@ -26,7 +27,7 @@ export async function configureApp(app: INestApplication): Promise<void> {
   const corsConfig = app.get(CorsConfig);
   if (corsConfig.enabled) {
     app.enableCors({
-      origin: corsConfig.origins ?? ['http://localhost:3000'],
+      origin: corsConfig.origins ?? ['http://localhost:3001', 'http://localhost:5173'],
       methods: corsConfig.methods ?? ['GET', 'POST', 'DELETE', 'OPTIONS'],
       allowedHeaders: corsConfig.allowedHeaders ?? [
         'Content-Type',
@@ -39,12 +40,13 @@ export async function configureApp(app: INestApplication): Promise<void> {
   }
 
   // Global validation pipe for request validation
+  const validationConfig = app.get(ValidationConfig);
   app.useGlobalPipes(
     new ValidationPipe({
-      whitelist: true,
-      forbidNonWhitelisted: true,
-      transform: true,
-      disableErrorMessages: false,
+      whitelist: validationConfig.whitelist ?? true,
+      forbidNonWhitelisted: validationConfig.forbidNonWhitelisted ?? true,
+      transform: validationConfig.transform ?? true,
+      disableErrorMessages: validationConfig.disableErrorMessages ?? true,
     }),
   );
 

package/src/config/app.config.spec.ts

@@ -0,0 +1,118 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { AppConfig } from './app.config';
+import { SwaggerConfig } from '../swagger/swagger.config';
+import { PostgresStorageConfig } from '@dismissible/nestjs-postgres-storage';
+import { JwtAuthHookConfig } from '@dismissible/nestjs-jwt-auth-hook';
+
+describe('AppConfig', () => {
+  describe('transformation', () => {
+    it('should transform all nested configs correctly', () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true },
+        db: { connectionString: 'postgresql://localhost:5432/test' },
+        jwtAuth: {
+          enabled: true,
+          wellKnownUrl: 'https://auth.example.com/.well-known/openid-configuration',
+        },
+      });
+
+      expect(config.swagger).toBeInstanceOf(SwaggerConfig);
+      expect(config.swagger.enabled).toBe(true);
+      expect(config.db).toBeInstanceOf(PostgresStorageConfig);
+      expect(config.db.connectionString).toBe('postgresql://localhost:5432/test');
+      expect(config.jwtAuth).toBeInstanceOf(JwtAuthHookConfig);
+      expect(config.jwtAuth.enabled).toBe(true);
+      expect(config.jwtAuth.wellKnownUrl).toBe(
+        'https://auth.example.com/.well-known/openid-configuration',
+      );
+    });
+  });
+
+  describe('validation', () => {
+    it('should pass validation with all required nested configs', async () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true },
+        db: { connectionString: 'postgresql://localhost:5432/test' },
+        jwtAuth: {
+          enabled: true,
+          wellKnownUrl: 'https://auth.example.com/.well-known/openid-configuration',
+        },
+      });
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should fail validation when swagger config has invalid nested property', async () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true, path: 123 },
+        db: { connectionString: 'postgresql://localhost:5432/test' },
+        jwtAuth: {
+          enabled: true,
+          wellKnownUrl: 'https://auth.example.com/.well-known/openid-configuration',
+        },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const swaggerError = errors.find((e) => e.property === 'swagger');
+      expect(swaggerError).toBeDefined();
+    });
+
+    it('should fail validation when db config is invalid', async () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true },
+        db: { connectionString: 123 },
+        jwtAuth: {
+          enabled: true,
+          wellKnownUrl: 'https://auth.example.com/.well-known/openid-configuration',
+        },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const dbError = errors.find((e) => e.property === 'db');
+      expect(dbError).toBeDefined();
+    });
+
+    it('should fail validation when jwtAuth config is invalid', async () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true },
+        db: { connectionString: 'postgresql://localhost:5432/test' },
+        jwtAuth: { enabled: true, wellKnownUrl: 'not-a-valid-url' },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const jwtAuthError = errors.find((e) => e.property === 'jwtAuth');
+      expect(jwtAuthError).toBeDefined();
+    });
+
+    it('should fail validation when jwtAuth enabled is false but wellKnownUrl is required', async () => {
+      const config = plainToInstance(AppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+        swagger: { enabled: true },
+        db: { connectionString: 'postgresql://localhost:5432/test' },
+        jwtAuth: { enabled: false },
+      });
+      const errors = await validate(config);
+      // When enabled is false, wellKnownUrl is not required due to ValidateIf
+      expect(errors).toHaveLength(0);
+    });
+  });
+});

package/src/config/app.config.ts

@@ -3,6 +3,7 @@ import { Type } from 'class-transformer';
 import { SwaggerConfig } from '../swagger';
 import { DefaultAppConfig } from './default-app.config';
 import { PostgresStorageConfig } from '@dismissible/nestjs-postgres-storage';
+import { JwtAuthHookConfig } from '@dismissible/nestjs-jwt-auth-hook';
 
 export class AppConfig extends DefaultAppConfig {
   @ValidateNested()
@@ -12,4 +13,8 @@ export class AppConfig extends DefaultAppConfig {
   @ValidateNested()
   @Type(() => PostgresStorageConfig)
   public readonly db!: PostgresStorageConfig;
+
+  @ValidateNested()
+  @Type(() => JwtAuthHookConfig)
+  public readonly jwtAuth!: JwtAuthHookConfig;
 }

package/src/config/default-app.config.spec.ts

@@ -0,0 +1,74 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { DefaultAppConfig } from './default-app.config';
+import { ServerConfig } from '../server/server.config';
+import { CorsConfig } from '../cors/cors.config';
+import { HelmetConfig } from '../helmet/helmet.config';
+
+describe('DefaultAppConfig', () => {
+  describe('transformation', () => {
+    it('should transform all nested configs correctly', () => {
+      const config = plainToInstance(DefaultAppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+      });
+
+      expect(config.server).toBeInstanceOf(ServerConfig);
+      expect(config.server.port).toBe(3001);
+      expect(config.cors).toBeInstanceOf(CorsConfig);
+      expect(config.cors.enabled).toBe(true);
+      expect(config.helmet).toBeInstanceOf(HelmetConfig);
+      expect(config.helmet.enabled).toBe(true);
+    });
+  });
+
+  describe('validation', () => {
+    it('should pass validation with all required nested configs', async () => {
+      const config = plainToInstance(DefaultAppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+      });
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should fail validation when server config is invalid', async () => {
+      const config = plainToInstance(DefaultAppConfig, {
+        server: { port: 'not-a-number' },
+        cors: { enabled: true },
+        helmet: { enabled: true },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const serverError = errors.find((e) => e.property === 'server');
+      expect(serverError).toBeDefined();
+    });
+
+    it('should fail validation when cors config has invalid nested property', async () => {
+      const config = plainToInstance(DefaultAppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true, maxAge: 'not-a-number' },
+        helmet: { enabled: true },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const corsError = errors.find((e) => e.property === 'cors');
+      expect(corsError).toBeDefined();
+    });
+
+    it('should fail validation when helmet config has invalid nested property', async () => {
+      const config = plainToInstance(DefaultAppConfig, {
+        server: { port: 3001 },
+        cors: { enabled: true },
+        helmet: { enabled: true, hstsMaxAge: 'not-a-number' },
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const helmetError = errors.find((e) => e.property === 'helmet');
+      expect(helmetError).toBeDefined();
+    });
+  });
+});

package/src/config/default-app.config.ts

@@ -3,6 +3,7 @@ import { Type } from 'class-transformer';
 import { ServerConfig } from '../server/server.config';
 import { CorsConfig } from '../cors';
 import { HelmetConfig } from '../helmet';
+import { ValidationConfig } from '../validation';
 
 export class DefaultAppConfig {
   @ValidateNested()
@@ -16,4 +17,8 @@ export class DefaultAppConfig {
   @ValidateNested()
   @Type(() => HelmetConfig)
   public readonly helmet!: HelmetConfig;
+
+  @ValidateNested()
+  @Type(() => ValidationConfig)
+  public readonly validation!: ValidationConfig;
 }

package/src/cors/cors.config.ts

@@ -1,6 +1,6 @@
 import { IsArray, IsBoolean, IsNumber, IsOptional, IsString } from 'class-validator';
 import { Type } from 'class-transformer';
-import { TransformBoolean, TransformCommaSeparated } from '../utils';
+import { TransformBoolean, TransformCommaSeparated } from '@dismissible/nestjs-validation';
 
 export class CorsConfig {
   @IsBoolean()

package/src/helmet/helmet.config.ts

@@ -1,6 +1,6 @@
 import { IsBoolean, IsNumber, IsOptional } from 'class-validator';
 import { Type } from 'class-transformer';
-import { TransformBoolean } from '../utils';
+import { TransformBoolean } from '@dismissible/nestjs-validation';
 
 /**
  * @see https://helmetjs.github.io/

package/src/server/server.config.spec.ts

@@ -0,0 +1,65 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { ServerConfig } from './server.config';
+
+describe('ServerConfig', () => {
+  describe('port', () => {
+    it('should transform string to number', () => {
+      const config = plainToInstance(ServerConfig, { port: '3001' });
+      expect(config.port).toBe(3001);
+    });
+
+    it('should keep number unchanged', () => {
+      const config = plainToInstance(ServerConfig, { port: 3001 });
+      expect(config.port).toBe(3001);
+    });
+
+    it('should handle different port numbers', () => {
+      const config = plainToInstance(ServerConfig, { port: '8080' });
+      expect(config.port).toBe(8080);
+    });
+  });
+
+  describe('validation', () => {
+    it('should pass validation with valid port number', async () => {
+      const config = plainToInstance(ServerConfig, { port: 3001 });
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should pass validation with string port that transforms to number', async () => {
+      const config = plainToInstance(ServerConfig, { port: '3001' });
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should fail validation when port is missing', async () => {
+      const config = plainToInstance(ServerConfig, {});
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].property).toBe('port');
+    });
+
+    it('should fail validation when port is not a number', async () => {
+      const config = plainToInstance(ServerConfig, { port: 'not-a-number' });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].property).toBe('port');
+    });
+
+    it('should fail validation when port is null', async () => {
+      const config = plainToInstance(ServerConfig, { port: null });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].property).toBe('port');
+    });
+
+    it('should fail validation when port is undefined', async () => {
+      const config = plainToInstance(ServerConfig, { port: undefined });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].property).toBe('port');
+    });
+  });
+});

package/src/swagger/swagger.config.spec.ts

@@ -0,0 +1,113 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { SwaggerConfig } from './swagger.config';
+
+describe('SwaggerConfig', () => {
+  describe('enabled', () => {
+    it('should transform string "true" to boolean true', () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: 'true' });
+      expect(config.enabled).toBe(true);
+    });
+
+    it('should transform string "false" to boolean false', () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: 'false' });
+      expect(config.enabled).toBe(false);
+    });
+
+    it('should keep boolean true as true', () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: true });
+      expect(config.enabled).toBe(true);
+    });
+
+    it('should keep boolean false as false', () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: false });
+      expect(config.enabled).toBe(false);
+    });
+
+    it('should transform other string values to false', () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: 'yes' });
+      expect(config.enabled).toBe(false);
+    });
+
+    it('should handle case-insensitive "true"', () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: 'TRUE' });
+      expect(config.enabled).toBe(true);
+    });
+
+    it('should handle case-insensitive "True"', () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: 'True' });
+      expect(config.enabled).toBe(true);
+    });
+  });
+
+  describe('path', () => {
+    it('should accept string path', () => {
+      const config = plainToInstance(SwaggerConfig, {
+        enabled: true,
+        path: 'api-docs',
+      });
+      expect(config.path).toBe('api-docs');
+    });
+
+    it('should allow path to be optional', () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: true });
+      expect(config.path).toBeUndefined();
+    });
+  });
+
+  describe('validation', () => {
+    it('should pass validation with valid config', async () => {
+      const config = plainToInstance(SwaggerConfig, {
+        enabled: true,
+        path: 'docs',
+      });
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should pass validation with only required fields', async () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: true });
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should pass validation when enabled is transformed from string', async () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: 'true' });
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should fail validation when enabled is missing', async () => {
+      const config = plainToInstance(SwaggerConfig, {});
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].property).toBe('enabled');
+    });
+
+    it('should fail validation when enabled is null', async () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: null });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].property).toBe('enabled');
+    });
+
+    it('should fail validation when enabled is undefined', async () => {
+      const config = plainToInstance(SwaggerConfig, { enabled: undefined });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].property).toBe('enabled');
+    });
+
+    it('should fail validation when path is not a string', async () => {
+      const config = plainToInstance(SwaggerConfig, {
+        enabled: true,
+        path: 123,
+      });
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      const pathError = errors.find((e) => e.property === 'path');
+      expect(pathError).toBeDefined();
+    });
+  });
+});