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

package/src/dismissible.module.ts

@@ -10,7 +10,6 @@ import { DismissibleItemMapper } from './api/dismissible-item.mapper';
 import { DateService } from './utils/date/date.service';
 import { DISMISSIBLE_HOOKS, IDismissibleLifecycleHook } from './core/lifecycle-hook.interface';
 import { LoggerModule, IDismissibleLoggerModuleOptions } from '@dismissible/nestjs-logger';
-import { BaseMetadata } from '@dismissible/nestjs-dismissible-item';
 import { ResponseService, ResponseModule } from './response';
 import { ValidationModule } from '@dismissible/nestjs-validation';
 import { IDismissibleStorageModuleOptions, StorageModule } from '@dismissible/nestjs-storage';
@@ -20,17 +19,14 @@ import { DismissibleItemModule } from '@dismissible/nestjs-dismissible-item';
 /**
  * Module configuration options.
  */
-export type IDismissibleModuleOptions<TMetadata extends BaseMetadata = BaseMetadata> =
-  IDismissibleLoggerModuleOptions &
-    IDismissibleStorageModuleOptions & {
-      hooks?: Type<IDismissibleLifecycleHook<TMetadata>>[];
-    };
+export type IDismissibleModuleOptions = IDismissibleLoggerModuleOptions &
+  IDismissibleStorageModuleOptions & {
+    hooks?: Type<IDismissibleLifecycleHook>[];
+  };
 
 @Module({})
 export class DismissibleModule {
-  static forRoot<TMetadata extends BaseMetadata = BaseMetadata>(
-    options: IDismissibleModuleOptions<TMetadata>,
-  ): DynamicModule {
+  static forRoot(options: IDismissibleModuleOptions): DynamicModule {
     const providers: Provider[] = [
       DateService,
       ResponseService,
@@ -48,7 +44,7 @@ export class DismissibleModule {
 
       providers.push({
         provide: DISMISSIBLE_HOOKS,
-        useFactory: (...hooks: IDismissibleLifecycleHook<TMetadata>[]) => hooks,
+        useFactory: (...hooks: IDismissibleLifecycleHook[]) => hooks,
         inject: options.hooks,
       });
     } else {

package/src/events/dismissible.events.ts

@@ -1,15 +1,15 @@
-import { BaseMetadata, DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
+import { DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
 import { IRequestContext } from '../request/request-context.interface';
 
 /**
  * Base class for all dismissible events.
  */
-abstract class BaseDismissibleEvent<TMetadata extends BaseMetadata = BaseMetadata> {
+abstract class BaseDismissibleEvent {
   /** The item identifier */
   readonly id: string;
 
   /** The current state of the item */
-  readonly item: DismissibleItemDto<TMetadata>;
+  readonly item: DismissibleItemDto;
 
   /** The user identifier */
   readonly userId: string;
@@ -17,12 +17,7 @@ abstract class BaseDismissibleEvent<TMetadata extends BaseMetadata = BaseMetadat
   /** The request context (optional) */
   readonly context?: IRequestContext;
 
-  constructor(
-    itemId: string,
-    item: DismissibleItemDto<TMetadata>,
-    userId: string,
-    context?: IRequestContext,
-  ) {
+  constructor(itemId: string, item: DismissibleItemDto, userId: string, context?: IRequestContext) {
     this.id = itemId;
     this.item = item;
     this.userId = userId;
@@ -33,15 +28,8 @@ abstract class BaseDismissibleEvent<TMetadata extends BaseMetadata = BaseMetadat
 /**
  * Event emitted when an existing item is retrieved.
  */
-export class ItemRetrievedEvent<
-  TMetadata extends BaseMetadata = BaseMetadata,
-> extends BaseDismissibleEvent<TMetadata> {
-  constructor(
-    itemId: string,
-    item: DismissibleItemDto<TMetadata>,
-    userId: string,
-    context?: IRequestContext,
-  ) {
+export class ItemRetrievedEvent extends BaseDismissibleEvent {
+  constructor(itemId: string, item: DismissibleItemDto, userId: string, context?: IRequestContext) {
     super(itemId, item, userId, context);
   }
 }
@@ -49,15 +37,8 @@ export class ItemRetrievedEvent<
 /**
  * Event emitted when a new item is created.
  */
-export class ItemCreatedEvent<
-  TMetadata extends BaseMetadata = BaseMetadata,
-> extends BaseDismissibleEvent<TMetadata> {
-  constructor(
-    itemId: string,
-    item: DismissibleItemDto<TMetadata>,
-    userId: string,
-    context?: IRequestContext,
-  ) {
+export class ItemCreatedEvent extends BaseDismissibleEvent {
+  constructor(itemId: string, item: DismissibleItemDto, userId: string, context?: IRequestContext) {
     super(itemId, item, userId, context);
   }
 }
@@ -65,16 +46,14 @@ export class ItemCreatedEvent<
 /**
  * Event emitted when an item is dismissed.
  */
-export class ItemDismissedEvent<
-  TMetadata extends BaseMetadata = BaseMetadata,
-> extends BaseDismissibleEvent<TMetadata> {
+export class ItemDismissedEvent extends BaseDismissibleEvent {
   /** The item state before dismissal */
-  readonly previousItem: DismissibleItemDto<TMetadata>;
+  readonly previousItem: DismissibleItemDto;
 
   constructor(
     itemId: string,
-    item: DismissibleItemDto<TMetadata>,
-    previousItem: DismissibleItemDto<TMetadata>,
+    item: DismissibleItemDto,
+    previousItem: DismissibleItemDto,
     userId: string,
     context?: IRequestContext,
   ) {
@@ -86,16 +65,14 @@ export class ItemDismissedEvent<
 /**
  * Event emitted when a dismissed item is restored.
  */
-export class ItemRestoredEvent<
-  TMetadata extends BaseMetadata = BaseMetadata,
-> extends BaseDismissibleEvent<TMetadata> {
+export class ItemRestoredEvent extends BaseDismissibleEvent {
   /** The item state before restoration */
-  readonly previousItem: DismissibleItemDto<TMetadata>;
+  readonly previousItem: DismissibleItemDto;
 
   constructor(
     itemId: string,
-    item: DismissibleItemDto<TMetadata>,
-    previousItem: DismissibleItemDto<TMetadata>,
+    item: DismissibleItemDto,
+    previousItem: DismissibleItemDto,
     userId: string,
     context?: IRequestContext,
   ) {

package/src/index.ts

@@ -6,3 +6,4 @@ export * from './utils';
 export * from './events';
 export * from './exceptions';
 export * from './testing';
+export * from './validation';

package/src/request/request-context.decorator.ts

@@ -9,6 +9,7 @@ export const RequestContext = createParamDecorator(
 
     return {
       requestId: headers['x-request-id'] ?? uuidv4(),
+      authorizationHeader: headers['authorization'],
     };
   },
 );

package/src/request/request-context.interface.ts

@@ -3,4 +3,10 @@
  */
 export interface IRequestContext {
   requestId: string;
+
+  /**
+   * Authorization header value (if present).
+   * Used by authentication hooks.
+   */
+  authorizationHeader?: string;
 }

package/src/response/http-exception-filter.spec.ts

@@ -0,0 +1,213 @@
+import { mock } from 'ts-jest-mocker';
+import { HttpException, HttpStatus, ArgumentsHost } from '@nestjs/common';
+import { FastifyReply } from 'fastify';
+import { HttpExceptionFilter } from './http-exception-filter';
+
+describe('HttpExceptionFilter', () => {
+  let filter: HttpExceptionFilter;
+  let mockArgumentsHost: jest.Mocked<ArgumentsHost>;
+  let mockHttpArgumentsHost: {
+    getResponse: jest.Mock;
+    getRequest: jest.Mock;
+    getNext: jest.Mock;
+  };
+  let mockResponse: jest.Mocked<FastifyReply>;
+
+  beforeEach(() => {
+    filter = new HttpExceptionFilter();
+
+    // Mock FastifyReply using ts-jest-mocker
+    mockResponse = mock<FastifyReply>({ failIfMockNotProvided: false });
+    mockResponse.status = jest.fn().mockReturnThis();
+    mockResponse.send = jest.fn().mockReturnThis();
+
+    // Mock HTTP arguments host
+    mockHttpArgumentsHost = {
+      getResponse: jest.fn().mockReturnValue(mockResponse),
+      getRequest: jest.fn(),
+      getNext: jest.fn(),
+    };
+
+    // Mock ArgumentsHost using ts-jest-mocker
+    mockArgumentsHost = mock<ArgumentsHost>({ failIfMockNotProvided: false });
+    mockArgumentsHost.switchToHttp = jest.fn().mockReturnValue(mockHttpArgumentsHost);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('catch', () => {
+    it('should handle HttpException with 404 status', () => {
+      // Arrange
+      const exception = new HttpException('Not found', HttpStatus.NOT_FOUND);
+
+      // Act
+      filter.catch(exception, mockArgumentsHost);
+
+      // Assert
+      expect(mockArgumentsHost.switchToHttp).toHaveBeenCalled();
+      expect(mockHttpArgumentsHost.getResponse).toHaveBeenCalled();
+      expect(mockResponse.status).toHaveBeenCalledWith(404);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: 'Not found',
+          code: 404,
+        },
+      });
+    });
+
+    it('should handle HttpException with 400 status', () => {
+      // Arrange
+      const exception = new HttpException('Bad request', HttpStatus.BAD_REQUEST);
+
+      // Act
+      filter.catch(exception, mockArgumentsHost);
+
+      // Assert
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: 'Bad request',
+          code: 400,
+        },
+      });
+    });
+
+    it('should handle HttpException with 401 status', () => {
+      // Arrange
+      const exception = new HttpException('Unauthorized', HttpStatus.UNAUTHORIZED);
+
+      // Act
+      filter.catch(exception, mockArgumentsHost);
+
+      // Assert
+      expect(mockResponse.status).toHaveBeenCalledWith(401);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: 'Unauthorized',
+          code: 401,
+        },
+      });
+    });
+
+    it('should handle HttpException with 403 status', () => {
+      // Arrange
+      const exception = new HttpException('Forbidden', HttpStatus.FORBIDDEN);
+
+      // Act
+      filter.catch(exception, mockArgumentsHost);
+
+      // Assert
+      expect(mockResponse.status).toHaveBeenCalledWith(403);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: 'Forbidden',
+          code: 403,
+        },
+      });
+    });
+
+    it('should handle HttpException with 500 status', () => {
+      // Arrange
+      const exception = new HttpException(
+        'Internal server error',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+
+      // Act
+      filter.catch(exception, mockArgumentsHost);
+
+      // Assert
+      expect(mockResponse.status).toHaveBeenCalledWith(500);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: 'Internal server error',
+          code: 500,
+        },
+      });
+    });
+
+    it('should handle HttpException with custom status code', () => {
+      // Arrange
+      const exception = new HttpException('Custom error', 418);
+
+      // Act
+      filter.catch(exception, mockArgumentsHost);
+
+      // Assert
+      expect(mockResponse.status).toHaveBeenCalledWith(418);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: 'Custom error',
+          code: 418,
+        },
+      });
+    });
+
+    it('should handle HttpException with empty message', () => {
+      // Arrange
+      const exception = new HttpException('', HttpStatus.BAD_REQUEST);
+
+      // Act
+      filter.catch(exception, mockArgumentsHost);
+
+      // Assert
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: '',
+          code: 400,
+        },
+      });
+    });
+
+    it('should handle HttpException with long message', () => {
+      // Arrange
+      const longMessage =
+        'This is a very long error message that contains multiple words and should be handled correctly by the filter';
+      const exception = new HttpException(longMessage, HttpStatus.BAD_REQUEST);
+
+      // Act
+      filter.catch(exception, mockArgumentsHost);
+
+      // Assert
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: longMessage,
+          code: 400,
+        },
+      });
+    });
+
+    it('should chain status and send methods correctly', () => {
+      // Arrange
+      const exception = new HttpException('Test error', HttpStatus.NOT_FOUND);
+
+      // Act
+      filter.catch(exception, mockArgumentsHost);
+
+      // Assert
+      expect(mockResponse.status).toHaveBeenCalled();
+      expect(mockResponse.send).toHaveBeenCalled();
+      expect(mockResponse.status).toHaveReturnedWith(mockResponse);
+      // Verify status is called before send by checking call order
+      const statusCallOrder = (mockResponse.status as jest.Mock).mock.invocationCallOrder[0];
+      const sendCallOrder = (mockResponse.send as jest.Mock).mock.invocationCallOrder[0];
+      expect(statusCallOrder).toBeLessThan(sendCallOrder);
+    });
+
+    it('should extract response from HTTP context correctly', () => {
+      // Arrange
+      const exception = new HttpException('Test', HttpStatus.BAD_REQUEST);
+
+      // Act
+      filter.catch(exception, mockArgumentsHost);
+
+      // Assert
+      expect(mockArgumentsHost.switchToHttp).toHaveBeenCalledTimes(1);
+      expect(mockHttpArgumentsHost.getResponse).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/testing/factories.ts

@@ -1,4 +1,4 @@
-import { BaseMetadata, DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
+import { DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
 import { DismissibleItemFactory } from '@dismissible/nestjs-dismissible-item';
 import { IRequestContext } from '../request/request-context.interface';
 
@@ -10,14 +10,11 @@ const testItemFactory = new DismissibleItemFactory();
 /**
  * Create a test dismissible item.
  */
-export function createTestItem<TMetadata extends BaseMetadata = BaseMetadata>(
-  overrides: Partial<DismissibleItemDto<TMetadata>> = {},
-): DismissibleItemDto<TMetadata> {
+export function createTestItem(overrides: Partial<DismissibleItemDto> = {}): DismissibleItemDto {
   return testItemFactory.create({
     id: overrides.id ?? 'test-item-id',
     createdAt: overrides.createdAt ?? new Date('2024-01-15T10:00:00.000Z'),
     userId: overrides.userId ?? 'test-user-id',
-    metadata: overrides.metadata,
     dismissedAt: overrides.dismissedAt,
   });
 }
@@ -35,9 +32,9 @@ export function createTestContext(overrides: Partial<IRequestContext> = {}): IRe
 /**
  * Create a dismissed test item.
  */
-export function createDismissedTestItem<TMetadata extends BaseMetadata = BaseMetadata>(
-  overrides: Partial<DismissibleItemDto<TMetadata>> = {},
-): DismissibleItemDto<TMetadata> {
+export function createDismissedTestItem(
+  overrides: Partial<DismissibleItemDto> = {},
+): DismissibleItemDto {
   return createTestItem({
     dismissedAt: new Date('2024-01-15T12:00:00.000Z'),
     ...overrides,

package/src/utils/dismissible.helper.ts

@@ -1,9 +1,9 @@
 import { Injectable } from '@nestjs/common';
-import { BaseMetadata, DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
+import { DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
 
 @Injectable()
 export class DismissibleHelper {
-  isDismissed<TMetadata extends BaseMetadata>(item: DismissibleItemDto<TMetadata>): boolean {
+  isDismissed(item: DismissibleItemDto): boolean {
     return item.dismissedAt !== undefined && item.dismissedAt !== null;
   }
 }

package/src/validation/dismissible-input.dto.ts

@@ -0,0 +1,47 @@
+import { IsNotEmpty, IsString, Matches, MaxLength, MinLength } from 'class-validator';
+
+/**
+ * Validation constants for dismissible input fields.
+ */
+export const VALIDATION_CONSTANTS = {
+  /** Maximum length for userId and itemId */
+  ID_MAX_LENGTH: 64,
+  /** Minimum length for userId and itemId */
+  ID_MIN_LENGTH: 1,
+  /** Pattern for valid userId and itemId (alphanumeric, dash, underscore) */
+  ID_PATTERN: /^[a-zA-Z0-9_-]+$/,
+  /** Human-readable description of the ID pattern */
+  ID_PATTERN_MESSAGE: 'must contain only alphanumeric characters, dashes, and underscores',
+} as const;
+
+/**
+ * DTO for validating dismissible input parameters (userId and itemId).
+ * Used at both controller and service layers for defense in depth.
+ */
+export class DismissibleInputDto {
+  @IsString()
+  @IsNotEmpty({ message: 'itemId is required' })
+  @MinLength(VALIDATION_CONSTANTS.ID_MIN_LENGTH, {
+    message: `itemId must be at least ${VALIDATION_CONSTANTS.ID_MIN_LENGTH} character`,
+  })
+  @MaxLength(VALIDATION_CONSTANTS.ID_MAX_LENGTH, {
+    message: `itemId must be at most ${VALIDATION_CONSTANTS.ID_MAX_LENGTH} characters`,
+  })
+  @Matches(VALIDATION_CONSTANTS.ID_PATTERN, {
+    message: `itemId ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`,
+  })
+  itemId: string;
+
+  @IsString()
+  @IsNotEmpty({ message: 'userId is required' })
+  @MinLength(VALIDATION_CONSTANTS.ID_MIN_LENGTH, {
+    message: `userId must be at least ${VALIDATION_CONSTANTS.ID_MIN_LENGTH} character`,
+  })
+  @MaxLength(VALIDATION_CONSTANTS.ID_MAX_LENGTH, {
+    message: `userId must be at most ${VALIDATION_CONSTANTS.ID_MAX_LENGTH} characters`,
+  })
+  @Matches(VALIDATION_CONSTANTS.ID_PATTERN, {
+    message: `userId ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`,
+  })
+  userId: string;
+}

package/src/validation/index.ts

@@ -0,0 +1 @@
+export * from './dismissible-input.dto';

package/tsconfig.json

@@ -5,6 +5,9 @@
   "references": [
     {
       "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
     }
   ],
   "compilerOptions": {

package/tsconfig.spec.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["node", "jest"],
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "ES2021"
+  },
+  "include": ["src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/src/api/use-cases/get-or-create/get-or-create.request.dto.ts

@@ -1,17 +0,0 @@
-import { ApiPropertyOptional } from '@nestjs/swagger';
-import { IsOptional, IsObject } from 'class-validator';
-
-/**
- * Query parameters for creating a dismissible item.
- */
-export class CreateDismissibleItemQueryDto {
-  @ApiPropertyOptional({
-    description: 'Optional metadata to attach to the item',
-    example: { key: 'value' },
-    type: 'object',
-    additionalProperties: true,
-  })
-  @IsOptional()
-  @IsObject()
-  metadata?: Record<string, string | number>;
-}

package/src/core/create-options.ts

@@ -1,9 +0,0 @@
-import { BaseMetadata } from '@dismissible/nestjs-dismissible-item';
-
-/**
- * Options for creating a new dismissible item.
- */
-export interface ICreateItemOptions<TMetadata extends BaseMetadata = BaseMetadata> {
-  /** Optional metadata to attach to the item */
-  metadata?: TMetadata;
-}