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

package/src/app-test.factory.ts

@@ -0,0 +1,39 @@
+import { Test, TestingModuleBuilder } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import { FastifyAdapter, NestFastifyApplication } from '@nestjs/platform-fastify';
+import { AppModule, AppModuleOptions } from './app.module';
+import { configureApp } from './app.setup';
+import { PrismaService } from '@dismissible/nestjs-postgres-storage';
+
+export type TestAppOptions = {
+  moduleOptions?: AppModuleOptions;
+  customize?: (builder: TestingModuleBuilder) => TestingModuleBuilder;
+};
+
+export async function createTestApp(options?: TestAppOptions): Promise<INestApplication> {
+  let builder = Test.createTestingModule({
+    imports: [AppModule.forRoot(options?.moduleOptions)],
+  });
+
+  if (options?.customize) {
+    builder = options.customize(builder);
+  }
+
+  const moduleFixture = await builder.compile();
+  const app = moduleFixture.createNestApplication<NestFastifyApplication>(
+    new FastifyAdapter({
+      bodyLimit: 10 * 1024, // 10kb
+    }),
+  );
+  await configureApp(app);
+  await app.init();
+
+  await app.getHttpAdapter().getInstance().ready();
+
+  return app;
+}
+
+export async function cleanupTestData(app: INestApplication): Promise<void> {
+  const prisma = app.get(PrismaService);
+  await prisma.dismissibleItem.deleteMany({});
+}

package/src/app.module.ts

@@ -0,0 +1,60 @@
+import { DynamicModule, Module, ModuleMetadata, Type } from '@nestjs/common';
+import { HealthModule } from './health';
+import { ConfigModule } from './config';
+import { AppConfig } from './config/app.config';
+import { join } from 'path';
+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({})
+export class AppModule {
+  static forRoot(options?: AppModuleOptions) {
+    return {
+      module: AppModule,
+      ...this.getModuleMetadata(options),
+    };
+  }
+
+  static getModuleMetadata(options?: AppModuleOptions): ModuleMetadata {
+    return {
+      imports: [
+        ConfigModule.forRoot({
+          path: options?.configPath ?? join(__dirname, '../config'),
+          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 {
+                connectionString: config.connectionString,
+              };
+            },
+            inject: [PostgresStorageConfig],
+          }),
+        }),
+      ],
+    };
+  }
+}

package/src/app.setup.ts

@@ -0,0 +1,52 @@
+import { INestApplication, ValidationPipe } from '@nestjs/common';
+import { NestFastifyApplication } from '@nestjs/platform-fastify';
+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;
+
+  const helmetConfig = app.get(HelmetConfig);
+  if (helmetConfig.enabled) {
+    await fastifyApp.register(fastifyHelmet, {
+      contentSecurityPolicy: helmetConfig.contentSecurityPolicy ?? true,
+      crossOriginEmbedderPolicy: helmetConfig.crossOriginEmbedderPolicy ?? true,
+      hsts: {
+        maxAge: helmetConfig.hstsMaxAge ?? 31536000,
+        includeSubDomains: helmetConfig.hstsIncludeSubDomains ?? true,
+        preload: helmetConfig.hstsPreload ?? false,
+      },
+    });
+  }
+
+  const corsConfig = app.get(CorsConfig);
+  if (corsConfig.enabled) {
+    app.enableCors({
+      origin: corsConfig.origins ?? ['http://localhost:3001', 'http://localhost:5173'],
+      methods: corsConfig.methods ?? ['GET', 'POST', 'DELETE', 'OPTIONS'],
+      allowedHeaders: corsConfig.allowedHeaders ?? [
+        'Content-Type',
+        'Authorization',
+        'x-request-id',
+      ],
+      credentials: corsConfig.credentials ?? true,
+      maxAge: corsConfig.maxAge ?? 86400,
+    });
+  }
+
+  const validationConfig = app.get(ValidationConfig);
+  app.useGlobalPipes(
+    new ValidationPipe({
+      whitelist: validationConfig.whitelist ?? true,
+      forbidNonWhitelisted: validationConfig.forbidNonWhitelisted ?? true,
+      transform: validationConfig.transform ?? true,
+      disableErrorMessages: validationConfig.disableErrorMessages ?? true,
+    }),
+  );
+
+  const swaggerConfig = app.get(SwaggerConfig);
+  configureAppWithSwagger(app, swaggerConfig);
+}

package/src/bootstrap.ts

@@ -0,0 +1,29 @@
+import { NestFactory } from '@nestjs/core';
+import { FastifyAdapter, NestFastifyApplication } from '@nestjs/platform-fastify';
+import { AppModule } from './app.module';
+import { ServerConfig } from './server/server.config';
+import { configureApp } from './app.setup';
+import { DefaultAppConfig } from './config/default-app.config';
+import { IDismissibleLogger } from '@dismissible/nestjs-logger';
+import { Type } from '@nestjs/common';
+
+export type IBootstrapOptions = {
+  configPath?: string;
+  schema?: new () => DefaultAppConfig;
+  logger?: Type<IDismissibleLogger>;
+};
+
+export async function bootstrap(options?: IBootstrapOptions) {
+  const app = await NestFactory.create<NestFastifyApplication>(
+    AppModule.forRoot(options),
+    new FastifyAdapter({
+      bodyLimit: 10 * 1024, // 10kb
+    }),
+  );
+  await configureApp(app);
+
+  const serverConfig = app.get(ServerConfig);
+  const port = serverConfig.port ?? 3000;
+  await app.listen(port, '0.0.0.0');
+  console.log(`🚀 Application is running on: http://localhost:${port}`);
+}

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

@@ -0,0 +1,117 @@
+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);
+      expect(errors).toHaveLength(0);
+    });
+  });
+});

package/src/config/app.config.ts

@@ -0,0 +1,20 @@
+import { ValidateNested } from 'class-validator';
+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()
+  @Type(() => SwaggerConfig)
+  public readonly swagger!: SwaggerConfig;
+
+  @ValidateNested()
+  @Type(() => PostgresStorageConfig)
+  public readonly db!: PostgresStorageConfig;
+
+  @ValidateNested()
+  @Type(() => JwtAuthHookConfig)
+  public readonly jwtAuth!: JwtAuthHookConfig;
+}

package/src/config/config.module.spec.ts

@@ -0,0 +1,94 @@
+import { ConfigModule } from './config.module';
+import { TypedConfigModule } from 'nest-typed-config';
+import { fileLoader } from 'nest-typed-config';
+
+jest.mock('nest-typed-config', () => ({
+  TypedConfigModule: {
+    forRoot: jest.fn(),
+  },
+  fileLoader: jest.fn(),
+}));
+
+jest.mock('path', () => ({
+  join: jest.fn((...args) => args.join('/')),
+}));
+
+describe('ConfigModule', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('forRoot', () => {
+    it('should return a dynamic module with default path', () => {
+      const mockSchema = class TestSchema {};
+      const mockFileLoader = jest.fn();
+      (fileLoader as jest.Mock).mockReturnValue(mockFileLoader);
+      (TypedConfigModule.forRoot as jest.Mock).mockReturnValue({});
+
+      const result = ConfigModule.forRoot({
+        schema: mockSchema,
+      });
+
+      expect(result.module).toBe(ConfigModule);
+      expect(result.exports).toContain(TypedConfigModule);
+      expect(fileLoader).toHaveBeenCalledWith({
+        searchFrom: expect.stringContaining('config'),
+        ignoreEnvironmentVariableSubstitution: false,
+      });
+      expect(TypedConfigModule.forRoot).toHaveBeenCalledWith({
+        schema: mockSchema,
+        load: [mockFileLoader],
+      });
+    });
+
+    it('should use custom path when provided', () => {
+      const mockSchema = class TestSchema {};
+      const customPath = '/custom/config/path';
+      const mockFileLoader = jest.fn();
+      (fileLoader as jest.Mock).mockReturnValue(mockFileLoader);
+      (TypedConfigModule.forRoot as jest.Mock).mockReturnValue({});
+
+      const result = ConfigModule.forRoot({
+        schema: mockSchema,
+        path: customPath,
+      });
+
+      expect(result.module).toBe(ConfigModule);
+      expect(fileLoader).toHaveBeenCalledWith({
+        searchFrom: customPath,
+        ignoreEnvironmentVariableSubstitution: false,
+      });
+    });
+
+    it('should respect ignoreEnvironmentVariableSubstitution option', () => {
+      const mockSchema = class TestSchema {};
+      const mockFileLoader = jest.fn();
+      (fileLoader as jest.Mock).mockReturnValue(mockFileLoader);
+      (TypedConfigModule.forRoot as jest.Mock).mockReturnValue({});
+
+      ConfigModule.forRoot({
+        schema: mockSchema,
+        ignoreEnvironmentVariableSubstitution: true,
+      });
+
+      expect(fileLoader).toHaveBeenCalledWith({
+        searchFrom: expect.any(String),
+        ignoreEnvironmentVariableSubstitution: true,
+      });
+    });
+
+    it('should include TypedConfigModule in imports', () => {
+      const mockSchema = class TestSchema {};
+      const mockFileLoader = jest.fn();
+      (fileLoader as jest.Mock).mockReturnValue(mockFileLoader);
+      const mockTypedConfigModule = {};
+      (TypedConfigModule.forRoot as jest.Mock).mockReturnValue(mockTypedConfigModule);
+
+      const result = ConfigModule.forRoot({
+        schema: mockSchema,
+      });
+
+      expect(result.imports).toContain(mockTypedConfigModule);
+    });
+  });
+});

package/src/config/config.module.ts

@@ -0,0 +1,50 @@
+import { DynamicModule, Global, Module } from '@nestjs/common';
+import { fileLoader, TypedConfigModule } from 'nest-typed-config';
+import { join } from 'path';
+
+export interface IConfigModuleOptions<T> {
+  /**
+   * The configuration schema class to validate against
+   */
+  schema: new () => T;
+  /**
+   * The path to search for configuration files
+   * Defaults to a 'config' directory two levels up from the current file
+   */
+  path?: string;
+  /**
+   * Whether to ignore environment variable substitution in config files
+   * Defaults to false (environment variables will be substituted)
+   */
+  ignoreEnvironmentVariableSubstitution?: boolean;
+}
+
+@Global()
+@Module({})
+export class ConfigModule {
+  /**
+   * Register the ConfigModule with a configuration schema
+   * @param options Configuration options including the schema class
+   * @returns A dynamic module configured with TypedConfigModule
+   */
+  static forRoot<T extends object>(options: IConfigModuleOptions<T>): DynamicModule {
+    const configPath = options.path ?? join(__dirname, '../../config');
+    const ignoreEnvSubstitution = options.ignoreEnvironmentVariableSubstitution ?? false;
+
+    return {
+      module: ConfigModule,
+      imports: [
+        TypedConfigModule.forRoot({
+          schema: options.schema,
+          load: [
+            fileLoader({
+              searchFrom: configPath,
+              ignoreEnvironmentVariableSubstitution: ignoreEnvSubstitution,
+            }),
+          ],
+        }),
+      ],
+      exports: [TypedConfigModule],
+    };
+  }
+}

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

@@ -0,0 +1,24 @@
+import { ValidateNested } from 'class-validator';
+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()
+  @Type(() => ServerConfig)
+  public readonly server!: ServerConfig;
+
+  @ValidateNested()
+  @Type(() => CorsConfig)
+  public readonly cors!: CorsConfig;
+
+  @ValidateNested()
+  @Type(() => HelmetConfig)
+  public readonly helmet!: HelmetConfig;
+
+  @ValidateNested()
+  @Type(() => ValidationConfig)
+  public readonly validation!: ValidationConfig;
+}

package/src/config/index.ts

@@ -0,0 +1,2 @@
+export * from './app.config';
+export * from './config.module';