@dismissible/nestjs-api 0.0.2-canary.5daf195.0

package/src/cors/cors.config.spec.ts

@@ -0,0 +1,162 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { CorsConfig } from './cors.config';
+
+describe('CorsConfig', () => {
+  describe('enabled', () => {
+    it('should transform string "true" to boolean true', () => {
+      const config = plainToInstance(CorsConfig, { enabled: 'true' });
+      expect(config.enabled).toBe(true);
+    });
+
+    it('should transform string "false" to boolean false', () => {
+      const config = plainToInstance(CorsConfig, { enabled: 'false' });
+      expect(config.enabled).toBe(false);
+    });
+
+    it('should keep boolean true as true', () => {
+      const config = plainToInstance(CorsConfig, { enabled: true });
+      expect(config.enabled).toBe(true);
+    });
+
+    it('should keep boolean false as false', () => {
+      const config = plainToInstance(CorsConfig, { enabled: false });
+      expect(config.enabled).toBe(false);
+    });
+  });
+
+  describe('origins', () => {
+    it('should transform comma-separated string to array', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        origins: 'http://localhost:3000,http://localhost:4000',
+      });
+      expect(config.origins).toEqual(['http://localhost:3000', 'http://localhost:4000']);
+    });
+
+    it('should trim whitespace from origins', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        origins: 'http://localhost:3000 , http://localhost:4000 ',
+      });
+      expect(config.origins).toEqual(['http://localhost:3000', 'http://localhost:4000']);
+    });
+
+    it('should handle single origin string', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        origins: 'http://localhost:3000',
+      });
+      expect(config.origins).toEqual(['http://localhost:3000']);
+    });
+
+    it('should keep array as array', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        origins: ['http://localhost:3000', 'http://localhost:4000'],
+      });
+      expect(config.origins).toEqual(['http://localhost:3000', 'http://localhost:4000']);
+    });
+  });
+
+  describe('methods', () => {
+    it('should transform comma-separated string to array', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        methods: 'GET,POST,DELETE',
+      });
+      expect(config.methods).toEqual(['GET', 'POST', 'DELETE']);
+    });
+
+    it('should trim whitespace from methods', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        methods: 'GET , POST , DELETE',
+      });
+      expect(config.methods).toEqual(['GET', 'POST', 'DELETE']);
+    });
+  });
+
+  describe('allowedHeaders', () => {
+    it('should transform comma-separated string to array', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        allowedHeaders: 'Content-Type,Authorization,x-request-id',
+      });
+      expect(config.allowedHeaders).toEqual(['Content-Type', 'Authorization', 'x-request-id']);
+    });
+
+    it('should trim whitespace from headers', () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        allowedHeaders: 'Content-Type , Authorization , x-request-id',
+      });
+      expect(config.allowedHeaders).toEqual(['Content-Type', 'Authorization', 'x-request-id']);
+    });
+  });
+
+  describe('credentials', () => {
+    it('should transform string "true" to boolean true', () => {
+      const config = plainToInstance(CorsConfig, { enabled: true, credentials: 'true' });
+      expect(config.credentials).toBe(true);
+    });
+
+    it('should transform string "false" to boolean false', () => {
+      const config = plainToInstance(CorsConfig, { enabled: true, credentials: 'false' });
+      expect(config.credentials).toBe(false);
+    });
+
+    it('should keep boolean values unchanged', () => {
+      const configTrue = plainToInstance(CorsConfig, { enabled: true, credentials: true });
+      const configFalse = plainToInstance(CorsConfig, { enabled: true, credentials: false });
+      expect(configTrue.credentials).toBe(true);
+      expect(configFalse.credentials).toBe(false);
+    });
+  });
+
+  describe('maxAge', () => {
+    it('should transform string to number', () => {
+      const config = plainToInstance(CorsConfig, { enabled: true, maxAge: '86400' });
+      expect(config.maxAge).toBe(86400);
+    });
+
+    it('should keep number unchanged', () => {
+      const config = plainToInstance(CorsConfig, { enabled: true, maxAge: 3600 });
+      expect(config.maxAge).toBe(3600);
+    });
+  });
+
+  describe('validation', () => {
+    it('should pass validation with valid config', async () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+        origins: ['http://localhost:3000'],
+        methods: ['GET', 'POST'],
+        allowedHeaders: ['Content-Type'],
+        credentials: true,
+        maxAge: 86400,
+      });
+
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should pass validation with only required fields', async () => {
+      const config = plainToInstance(CorsConfig, {
+        enabled: true,
+      });
+
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should fail validation when enabled is missing', async () => {
+      const config = plainToInstance(CorsConfig, {});
+
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].property).toBe('enabled');
+    });
+  });
+});

package/src/cors/cors.config.ts

@@ -0,0 +1,37 @@
+import { IsArray, IsBoolean, IsNumber, IsOptional, IsString } from 'class-validator';
+import { Type } from 'class-transformer';
+import { TransformBoolean, TransformCommaSeparated } from '@dismissible/nestjs-validation';
+
+export class CorsConfig {
+  @IsBoolean()
+  @TransformBoolean()
+  public readonly enabled!: boolean;
+
+  @IsArray()
+  @IsString({ each: true })
+  @IsOptional()
+  @TransformCommaSeparated()
+  public readonly origins?: string[];
+
+  @IsArray()
+  @IsString({ each: true })
+  @IsOptional()
+  @TransformCommaSeparated()
+  public readonly methods?: string[];
+
+  @IsArray()
+  @IsString({ each: true })
+  @IsOptional()
+  @TransformCommaSeparated()
+  public readonly allowedHeaders?: string[];
+
+  @IsBoolean()
+  @IsOptional()
+  @TransformBoolean()
+  public readonly credentials?: boolean;
+
+  @IsNumber()
+  @IsOptional()
+  @Type(() => Number)
+  public readonly maxAge?: number;
+}

package/src/cors/index.ts

@@ -0,0 +1 @@
+export * from './cors.config';

package/src/health/health.controller.spec.ts

@@ -0,0 +1,24 @@
+import { HealthController } from './health.controller';
+
+describe('HealthController', () => {
+  let controller: HealthController;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date('2024-01-20T15:30:00.000Z'));
+    controller = new HealthController();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('getHealth', () => {
+    it('should return the exact response from service', () => {
+      const result = controller.getHealth();
+
+      expect(result.status).toBe('ok');
+      expect(result.timestamp).toBe('2024-01-20T15:30:00.000Z');
+    });
+  });
+});

package/src/health/health.controller.ts

@@ -0,0 +1,16 @@
+import { Controller, Get, HttpCode, HttpStatus } from '@nestjs/common';
+
+@Controller('health')
+export class HealthController {
+  @Get()
+  @HttpCode(HttpStatus.OK)
+  getHealth(): {
+    status: string;
+    timestamp: string;
+  } {
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+    };
+  }
+}

package/src/health/health.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { HealthController } from './health.controller';
+
+@Module({
+  controllers: [HealthController],
+  providers: [],
+  exports: [],
+})
+export class HealthModule {}

package/src/health/index.ts

@@ -0,0 +1,2 @@
+export * from './health.module';
+export * from './health.controller';

package/src/helmet/helmet.config.spec.ts

@@ -0,0 +1,197 @@
+import 'reflect-metadata';
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+import { HelmetConfig } from './helmet.config';
+
+describe('HelmetConfig', () => {
+  describe('enabled', () => {
+    it('should transform string "true" to boolean true', () => {
+      const config = plainToInstance(HelmetConfig, { enabled: 'true' });
+      expect(config.enabled).toBe(true);
+    });
+
+    it('should transform string "false" to boolean false', () => {
+      const config = plainToInstance(HelmetConfig, { enabled: 'false' });
+      expect(config.enabled).toBe(false);
+    });
+
+    it('should keep boolean true as true', () => {
+      const config = plainToInstance(HelmetConfig, { enabled: true });
+      expect(config.enabled).toBe(true);
+    });
+
+    it('should keep boolean false as false', () => {
+      const config = plainToInstance(HelmetConfig, { enabled: false });
+      expect(config.enabled).toBe(false);
+    });
+  });
+
+  describe('contentSecurityPolicy', () => {
+    it('should transform string "true" to boolean true', () => {
+      const config = plainToInstance(HelmetConfig, {
+        enabled: true,
+        contentSecurityPolicy: 'true',
+      });
+      expect(config.contentSecurityPolicy).toBe(true);
+    });
+
+    it('should transform string "false" to boolean false', () => {
+      const config = plainToInstance(HelmetConfig, {
+        enabled: true,
+        contentSecurityPolicy: 'false',
+      });
+      expect(config.contentSecurityPolicy).toBe(false);
+    });
+
+    it('should keep boolean values unchanged', () => {
+      const configTrue = plainToInstance(HelmetConfig, {
+        enabled: true,
+        contentSecurityPolicy: true,
+      });
+      const configFalse = plainToInstance(HelmetConfig, {
+        enabled: true,
+        contentSecurityPolicy: false,
+      });
+      expect(configTrue.contentSecurityPolicy).toBe(true);
+      expect(configFalse.contentSecurityPolicy).toBe(false);
+    });
+  });
+
+  describe('crossOriginEmbedderPolicy', () => {
+    it('should transform string "true" to boolean true', () => {
+      const config = plainToInstance(HelmetConfig, {
+        enabled: true,
+        crossOriginEmbedderPolicy: 'true',
+      });
+      expect(config.crossOriginEmbedderPolicy).toBe(true);
+    });
+
+    it('should transform string "false" to boolean false', () => {
+      const config = plainToInstance(HelmetConfig, {
+        enabled: true,
+        crossOriginEmbedderPolicy: 'false',
+      });
+      expect(config.crossOriginEmbedderPolicy).toBe(false);
+    });
+
+    it('should keep boolean values unchanged', () => {
+      const configTrue = plainToInstance(HelmetConfig, {
+        enabled: true,
+        crossOriginEmbedderPolicy: true,
+      });
+      const configFalse = plainToInstance(HelmetConfig, {
+        enabled: true,
+        crossOriginEmbedderPolicy: false,
+      });
+      expect(configTrue.crossOriginEmbedderPolicy).toBe(true);
+      expect(configFalse.crossOriginEmbedderPolicy).toBe(false);
+    });
+  });
+
+  describe('hstsMaxAge', () => {
+    it('should transform string to number', () => {
+      const config = plainToInstance(HelmetConfig, { enabled: true, hstsMaxAge: '31536000' });
+      expect(config.hstsMaxAge).toBe(31536000);
+    });
+
+    it('should keep number unchanged', () => {
+      const config = plainToInstance(HelmetConfig, { enabled: true, hstsMaxAge: 86400 });
+      expect(config.hstsMaxAge).toBe(86400);
+    });
+  });
+
+  describe('hstsIncludeSubDomains', () => {
+    it('should transform string "true" to boolean true', () => {
+      const config = plainToInstance(HelmetConfig, {
+        enabled: true,
+        hstsIncludeSubDomains: 'true',
+      });
+      expect(config.hstsIncludeSubDomains).toBe(true);
+    });
+
+    it('should transform string "false" to boolean false', () => {
+      const config = plainToInstance(HelmetConfig, {
+        enabled: true,
+        hstsIncludeSubDomains: 'false',
+      });
+      expect(config.hstsIncludeSubDomains).toBe(false);
+    });
+
+    it('should keep boolean values unchanged', () => {
+      const configTrue = plainToInstance(HelmetConfig, {
+        enabled: true,
+        hstsIncludeSubDomains: true,
+      });
+      const configFalse = plainToInstance(HelmetConfig, {
+        enabled: true,
+        hstsIncludeSubDomains: false,
+      });
+      expect(configTrue.hstsIncludeSubDomains).toBe(true);
+      expect(configFalse.hstsIncludeSubDomains).toBe(false);
+    });
+  });
+
+  describe('hstsPreload', () => {
+    it('should transform string "true" to boolean true', () => {
+      const config = plainToInstance(HelmetConfig, {
+        enabled: true,
+        hstsPreload: 'true',
+      });
+      expect(config.hstsPreload).toBe(true);
+    });
+
+    it('should transform string "false" to boolean false', () => {
+      const config = plainToInstance(HelmetConfig, {
+        enabled: true,
+        hstsPreload: 'false',
+      });
+      expect(config.hstsPreload).toBe(false);
+    });
+
+    it('should keep boolean values unchanged', () => {
+      const configTrue = plainToInstance(HelmetConfig, {
+        enabled: true,
+        hstsPreload: true,
+      });
+      const configFalse = plainToInstance(HelmetConfig, {
+        enabled: true,
+        hstsPreload: false,
+      });
+      expect(configTrue.hstsPreload).toBe(true);
+      expect(configFalse.hstsPreload).toBe(false);
+    });
+  });
+
+  describe('validation', () => {
+    it('should pass validation with valid config', async () => {
+      const config = plainToInstance(HelmetConfig, {
+        enabled: true,
+        contentSecurityPolicy: true,
+        crossOriginEmbedderPolicy: true,
+        hstsMaxAge: 31536000,
+        hstsIncludeSubDomains: true,
+        hstsPreload: false,
+      });
+
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should pass validation with only required fields', async () => {
+      const config = plainToInstance(HelmetConfig, {
+        enabled: true,
+      });
+
+      const errors = await validate(config);
+      expect(errors).toHaveLength(0);
+    });
+
+    it('should fail validation when enabled is missing', async () => {
+      const config = plainToInstance(HelmetConfig, {});
+
+      const errors = await validate(config);
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].property).toBe('enabled');
+    });
+  });
+});

package/src/helmet/helmet.config.ts

@@ -0,0 +1,60 @@
+import { IsBoolean, IsNumber, IsOptional } from 'class-validator';
+import { Type } from 'class-transformer';
+import { TransformBoolean } from '@dismissible/nestjs-validation';
+
+/**
+ * @see https://helmetjs.github.io/
+ */
+export class HelmetConfig {
+  /**
+   * Whether to enable Helmet middleware
+   */
+  @IsBoolean()
+  @TransformBoolean()
+  public readonly enabled!: boolean;
+
+  /**
+   * Whether to enable Content-Security-Policy header.
+   * @default true
+   */
+  @IsBoolean()
+  @IsOptional()
+  @TransformBoolean()
+  public readonly contentSecurityPolicy?: boolean;
+
+  /**
+   * Whether to enable Cross-Origin-Embedder-Policy header.
+   * @default true
+   */
+  @IsBoolean()
+  @IsOptional()
+  @TransformBoolean()
+  public readonly crossOriginEmbedderPolicy?: boolean;
+
+  /**
+   * HSTS max-age in seconds.
+   * @default 31536000 (1 year)
+   */
+  @IsNumber()
+  @IsOptional()
+  @Type(() => Number)
+  public readonly hstsMaxAge?: number;
+
+  /**
+   * Whether to include subdomains in HSTS header.
+   * @default true
+   */
+  @IsBoolean()
+  @IsOptional()
+  @TransformBoolean()
+  public readonly hstsIncludeSubDomains?: boolean;
+
+  /**
+   * Whether to add HSTS preload directive.
+   * @default false
+   */
+  @IsBoolean()
+  @IsOptional()
+  @TransformBoolean()
+  public readonly hstsPreload?: boolean;
+}

package/src/helmet/index.ts

@@ -0,0 +1 @@
+export * from './helmet.config';

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './config';
+export * from './server';
+export * from './bootstrap';
+export * from './app.module';
+export * from './app.setup';

package/src/main.ts

@@ -0,0 +1,3 @@
+import { bootstrap } from './bootstrap';
+
+bootstrap();

package/src/server/index.ts

@@ -0,0 +1 @@
+export * from './server.config';

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/server/server.config.ts

@@ -0,0 +1,8 @@
+import { IsNumber } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class ServerConfig {
+  @IsNumber()
+  @Type(() => Number)
+  public readonly port!: number;
+}

package/src/swagger/index.ts

@@ -0,0 +1,2 @@
+export * from './swagger.factory';
+export * from './swagger.config';