@dismissible/nestjs-dismissible 0.0.2-canary.8976e84.0 → 0.0.2-canary.b0d8bfe.0

package/src/dismissible.module.ts

@@ -8,9 +8,11 @@ import { DismissibleCoreService } from './core/dismissible-core.service';
 import { HookRunner } from './core/hook-runner.service';
 import { DismissibleItemMapper } from './api/dismissible-item.mapper';
 import { DateService } from './utils/date/date.service';
-import { DISMISSIBLE_HOOKS, IDismissibleLifecycleHook } from './core/lifecycle-hook.interface';
+import {
+  DISMISSIBLE_HOOKS,
+  IDismissibleLifecycleHook,
+} from '@dismissible/nestjs-dismissible-hooks';
 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 +22,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 +47,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 { IRequestContext } from '../request/request-context.interface';
+import { DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
+import { IRequestContext } from '@dismissible/nestjs-dismissible-request';
 
 /**
  * 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

@@ -1,8 +1,8 @@
 export * from './dismissible.module';
-export * from './request';
 export * from './core';
 export * from './api';
 export * from './utils';
 export * from './events';
 export * from './exceptions';
 export * from './testing';
+export * from './validation';

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

@@ -0,0 +1,179 @@
+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();
+
+    mockResponse = mock<FastifyReply>({ failIfMockNotProvided: false });
+    mockResponse.status = jest.fn().mockReturnThis();
+    mockResponse.send = jest.fn().mockReturnThis();
+
+    mockHttpArgumentsHost = {
+      getResponse: jest.fn().mockReturnValue(mockResponse),
+      getRequest: jest.fn(),
+      getNext: jest.fn(),
+    };
+
+    mockArgumentsHost = mock<ArgumentsHost>({ failIfMockNotProvided: false });
+    mockArgumentsHost.switchToHttp = jest.fn().mockReturnValue(mockHttpArgumentsHost);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('catch', () => {
+    it('should handle HttpException with 404 status', () => {
+      const exception = new HttpException('Not found', HttpStatus.NOT_FOUND);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      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', () => {
+      const exception = new HttpException('Bad request', HttpStatus.BAD_REQUEST);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: 'Bad request',
+          code: 400,
+        },
+      });
+    });
+
+    it('should handle HttpException with 401 status', () => {
+      const exception = new HttpException('Unauthorized', HttpStatus.UNAUTHORIZED);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockResponse.status).toHaveBeenCalledWith(401);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: 'Unauthorized',
+          code: 401,
+        },
+      });
+    });
+
+    it('should handle HttpException with 403 status', () => {
+      const exception = new HttpException('Forbidden', HttpStatus.FORBIDDEN);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockResponse.status).toHaveBeenCalledWith(403);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: 'Forbidden',
+          code: 403,
+        },
+      });
+    });
+
+    it('should handle HttpException with 500 status', () => {
+      const exception = new HttpException(
+        'Internal server error',
+        HttpStatus.INTERNAL_SERVER_ERROR,
+      );
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockResponse.status).toHaveBeenCalledWith(500);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: 'Internal server error',
+          code: 500,
+        },
+      });
+    });
+
+    it('should handle HttpException with custom status code', () => {
+      const exception = new HttpException('Custom error', 418);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockResponse.status).toHaveBeenCalledWith(418);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: 'Custom error',
+          code: 418,
+        },
+      });
+    });
+
+    it('should handle HttpException with empty message', () => {
+      const exception = new HttpException('', HttpStatus.BAD_REQUEST);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: '',
+          code: 400,
+        },
+      });
+    });
+
+    it('should handle HttpException with long message', () => {
+      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);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+      expect(mockResponse.send).toHaveBeenCalledWith({
+        error: {
+          message: longMessage,
+          code: 400,
+        },
+      });
+    });
+
+    it('should chain status and send methods correctly', () => {
+      const exception = new HttpException('Test error', HttpStatus.NOT_FOUND);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockResponse.status).toHaveBeenCalled();
+      expect(mockResponse.send).toHaveBeenCalled();
+      expect(mockResponse.status).toHaveReturnedWith(mockResponse);
+      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', () => {
+      const exception = new HttpException('Test', HttpStatus.BAD_REQUEST);
+
+      filter.catch(exception, mockArgumentsHost);
+
+      expect(mockArgumentsHost.switchToHttp).toHaveBeenCalledTimes(1);
+      expect(mockHttpArgumentsHost.getResponse).toHaveBeenCalledTimes(1);
+    });
+  });
+});

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

@@ -1,12 +1,12 @@
 import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
-import { Response } from 'express';
+import { FastifyReply } from 'fastify';
 import { IErrorResponseDto } from './dtos';
 
 @Catch(HttpException)
 export class HttpExceptionFilter implements ExceptionFilter {
   catch(exception: HttpException, host: ArgumentsHost) {
     const ctx = host.switchToHttp();
-    const response = ctx.getResponse<Response>();
+    const response = ctx.getResponse<FastifyReply>();
     const status = exception.getStatus();
 
     const errorResponse: IErrorResponseDto = {
@@ -16,6 +16,6 @@ export class HttpExceptionFilter implements ExceptionFilter {
       },
     };
 
-    response.status(status).json(errorResponse);
+    response.status(status).send(errorResponse);
   }
 }

package/src/response/response.service.spec.ts

@@ -5,65 +5,51 @@ describe('ResponseService', () => {
   let service: ResponseService;
 
   beforeEach(() => {
-    // Manually create the service with no dependencies
     service = new ResponseService();
   });
 
   describe('success', () => {
     it('should return a success response with the provided data', () => {
-      // Arrange
       const testData = { id: '123', name: 'Test Item' };
 
-      // Act
       const result = service.success(testData);
 
-      // Assert
       expect(result).toEqual({
         data: testData,
       });
     });
 
     it('should work with primitive data types', () => {
-      // Arrange
       const testString = 'Test String';
 
-      // Act
       const result = service.success(testString);
 
-      // Assert
       expect(result).toEqual({
         data: testString,
       });
     });
 
     it('should work with array data', () => {
-      // Arrange
       const testArray = [1, 2, 3];
 
-      // Act
       const result = service.success(testArray);
 
-      // Assert
       expect(result).toEqual({
         data: testArray,
       });
     });
 
     it('should handle null data', () => {
-      // Act
       const result = service.success(null);
 
-      // Assert
       expect(result).toEqual({
         data: null,
       });
     });
 
     it('should handle undefined data', () => {
-      // Act
       const result = service.success(undefined);
 
-      // Assert
       expect(result).toEqual({
         data: undefined,
       });

package/src/testing/factories.ts

@@ -1,6 +1,6 @@
-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';
+import { IRequestContext } from '@dismissible/nestjs-dismissible-request';
 
 /**
  * Shared factory instance for test helpers.
@@ -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,
   });
 }
@@ -28,6 +25,24 @@ export function createTestItem<TMetadata extends BaseMetadata = BaseMetadata>(
 export function createTestContext(overrides: Partial<IRequestContext> = {}): IRequestContext {
   return {
     requestId: 'test-request-id',
+    headers: {},
+    query: {},
+    params: {},
+    body: {},
+    user: {},
+    ip: '127.0.0.1',
+    method: 'GET',
+    url: '/test',
+    protocol: 'http',
+    secure: false,
+    hostname: 'localhost',
+    port: 3000,
+    path: '/test',
+    search: '',
+    searchParams: {},
+    origin: 'http://localhost:3000',
+    referer: '',
+    userAgent: 'test-agent',
     ...overrides,
   };
 }
@@ -35,9 +50,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;
-}

package/src/request/index.ts

@@ -1,2 +0,0 @@
-export * from './request-context.decorator';
-export * from './request-context.interface';

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

@@ -1,14 +0,0 @@
-import { createParamDecorator, ExecutionContext } from '@nestjs/common';
-import { v4 as uuidv4 } from 'uuid';
-import { IRequestContext } from './request-context.interface';
-
-export const RequestContext = createParamDecorator(
-  (_data: unknown, ctx: ExecutionContext): IRequestContext => {
-    const request = ctx.switchToHttp().getRequest();
-    const headers = request.headers;
-
-    return {
-      requestId: headers['x-request-id'] ?? uuidv4(),
-    };
-  },
-);

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

@@ -1,6 +0,0 @@
-/**
- * Request context passed through the dismissible operations.
- */
-export interface IRequestContext {
-  requestId: string;
-}