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

package/src/api/use-cases/restore/restore.controller.ts

@@ -1,23 +1,22 @@
-import { Controller, Post, Param, UseFilters } from '@nestjs/common';
+import { Controller, Post, UseFilters } from '@nestjs/common';
 import { ApiTags, ApiOperation, ApiParam, ApiResponse } from '@nestjs/swagger';
 import { DismissibleService } from '../../../core/dismissible.service';
 import { DismissibleItemMapper } from '../../dismissible-item.mapper';
-import { RequestContext } from '../../../request/request-context.decorator';
-import { IRequestContext } from '../../../request/request-context.interface';
-import { BaseMetadata } from '@dismissible/nestjs-dismissible-item';
+import { RequestContext, IRequestContext } from '@dismissible/nestjs-dismissible-request';
 import { RestoreResponseDto } from './restore.response.dto';
 import { ResponseService } from '../../../response/response.service';
 import { HttpExceptionFilter } from '../../../response/http-exception-filter';
 import { API_TAG_DISMISSIBLE } from '../api-tags.constants';
+import { UserId, ItemId } from '../../validation';
 
 /**
  * Controller for restore dismissible item operations.
  */
 @ApiTags(API_TAG_DISMISSIBLE)
-@Controller('v1/user/:userId/dismissible-item')
+@Controller('v1/users/:userId/items')
 export class RestoreController {
   constructor(
-    private readonly dismissibleService: DismissibleService<BaseMetadata>,
+    private readonly dismissibleService: DismissibleService,
     private readonly mapper: DismissibleItemMapper,
     private readonly responseService: ResponseService,
   ) {}
@@ -29,12 +28,12 @@ export class RestoreController {
   })
   @ApiParam({
     name: 'userId',
-    description: 'User identifier',
+    description: 'User identifier (max length: 32 characters)',
     example: 'user-123',
   })
   @ApiParam({
     name: 'itemId',
-    description: 'Unique identifier for the dismissible item',
+    description: 'Unique identifier for the dismissible item (max length: 32 characters)',
     example: 'welcome-banner-v2',
   })
   @ApiResponse({
@@ -52,8 +51,8 @@ export class RestoreController {
   })
   @UseFilters(HttpExceptionFilter)
   async restore(
-    @Param('userId') userId: string,
-    @Param('itemId') itemId: string,
+    @UserId() userId: string,
+    @ItemId() itemId: string,
     @RequestContext() context: IRequestContext,
   ): Promise<RestoreResponseDto> {
     const result = await this.dismissibleService.restore(itemId, userId, context);

package/src/api/validation/index.ts

@@ -0,0 +1,2 @@
+export * from './param-validation.pipe';
+export * from './param.decorators';

package/src/api/validation/param-validation.pipe.spec.ts

@@ -0,0 +1,313 @@
+import { BadRequestException, ArgumentMetadata } from '@nestjs/common';
+import { ParamValidationPipe } from './param-validation.pipe';
+import { VALIDATION_CONSTANTS } from '../../validation/dismissible-input.dto';
+
+describe('ParamValidationPipe', () => {
+  let pipe: ParamValidationPipe;
+
+  beforeEach(() => {
+    pipe = new ParamValidationPipe();
+  });
+
+  describe('valid values', () => {
+    it('should pass validation for a valid alphanumeric string', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      const result = pipe.transform('user123', metadata);
+      expect(result).toBe('user123');
+    });
+
+    it('should pass validation for a string with dashes', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      const result = pipe.transform('item-123', metadata);
+      expect(result).toBe('item-123');
+    });
+
+    it('should pass validation for a string with underscores', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      const result = pipe.transform('user_123', metadata);
+      expect(result).toBe('user_123');
+    });
+
+    it('should pass validation for a string with mixed valid characters', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      const result = pipe.transform('item-123_test', metadata);
+      expect(result).toBe('item-123_test');
+    });
+
+    it('should pass validation for minimum length (1 character)', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      const result = pipe.transform('a', metadata);
+      expect(result).toBe('a');
+    });
+
+    it('should pass validation for maximum length (64 characters)', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      const validMaxLength = 'a'.repeat(VALIDATION_CONSTANTS.ID_MAX_LENGTH);
+      const result = pipe.transform(validMaxLength, metadata);
+      expect(result).toBe(validMaxLength);
+    });
+  });
+
+  describe('empty or null values', () => {
+    it('should throw BadRequestException for empty string', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      expect(() => pipe.transform('', metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform('', metadata)).toThrow('userId is required');
+    });
+
+    it('should throw BadRequestException for whitespace-only string', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      expect(() => pipe.transform('   ', metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform('   ', metadata)).toThrow('itemId is required');
+    });
+
+    it('should throw BadRequestException for null value', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      expect(() => pipe.transform(null as any, metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform(null as any, metadata)).toThrow('userId is required');
+    });
+
+    it('should throw BadRequestException for undefined value', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      expect(() => pipe.transform(undefined as any, metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform(undefined as any, metadata)).toThrow('itemId is required');
+    });
+
+    it('should use default parameter name when metadata.data is not provided', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+      };
+      expect(() => pipe.transform('', metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform('', metadata)).toThrow('parameter is required');
+    });
+  });
+
+  describe('length validation', () => {
+    it('should throw BadRequestException for value below minimum length', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      expect(() => pipe.transform('', metadata)).toThrow(BadRequestException);
+    });
+
+    it('should throw BadRequestException for value exceeding maximum length', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      const tooLong = 'a'.repeat(VALIDATION_CONSTANTS.ID_MAX_LENGTH + 1);
+      expect(() => pipe.transform(tooLong, metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform(tooLong, metadata)).toThrow(
+        `itemId must be at most ${VALIDATION_CONSTANTS.ID_MAX_LENGTH} characters`,
+      );
+    });
+  });
+
+  describe('pattern validation', () => {
+    it('should throw BadRequestException for string with spaces', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      expect(() => pipe.transform('user 123', metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform('user 123', metadata)).toThrow(
+        `userId ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`,
+      );
+    });
+
+    it('should throw BadRequestException for string with special characters', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      expect(() => pipe.transform('item@123', metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform('item@123', metadata)).toThrow(
+        `itemId ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`,
+      );
+    });
+
+    it('should throw BadRequestException for string with dots', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      expect(() => pipe.transform('user.123', metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform('user.123', metadata)).toThrow(
+        `userId ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`,
+      );
+    });
+
+    it('should throw BadRequestException for string with slashes', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      expect(() => pipe.transform('item/123', metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform('item/123', metadata)).toThrow(
+        `itemId ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`,
+      );
+    });
+
+    it('should throw BadRequestException for string with unicode characters', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      expect(() => pipe.transform('userñ123', metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform('userñ123', metadata)).toThrow(
+        `userId ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`,
+      );
+    });
+
+    it('should throw BadRequestException for string starting with invalid character', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      expect(() => pipe.transform('@item123', metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform('@item123', metadata)).toThrow(
+        `itemId ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`,
+      );
+    });
+
+    it('should throw BadRequestException for string ending with invalid character', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      expect(() => pipe.transform('user123#', metadata)).toThrow(BadRequestException);
+      expect(() => pipe.transform('user123#', metadata)).toThrow(
+        `userId ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`,
+      );
+    });
+  });
+
+  describe('error messages', () => {
+    it('should include parameter name in required error message', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'customParam',
+      };
+      try {
+        pipe.transform('', metadata);
+        fail('Should have thrown BadRequestException');
+      } catch (error) {
+        expect(error).toBeInstanceOf(BadRequestException);
+        expect((error as BadRequestException).message).toBe('customParam is required');
+      }
+    });
+
+    it('should include parameter name in length error message', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'testParam',
+      };
+      const tooLong = 'a'.repeat(VALIDATION_CONSTANTS.ID_MAX_LENGTH + 1);
+      try {
+        pipe.transform(tooLong, metadata);
+        fail('Should have thrown BadRequestException');
+      } catch (error) {
+        expect(error).toBeInstanceOf(BadRequestException);
+        expect((error as BadRequestException).message).toContain('testParam');
+        expect((error as BadRequestException).message).toContain(
+          `must be at most ${VALIDATION_CONSTANTS.ID_MAX_LENGTH} characters`,
+        );
+      }
+    });
+
+    it('should include parameter name in pattern error message', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'myParam',
+      };
+      try {
+        pipe.transform('invalid@value', metadata);
+        fail('Should have thrown BadRequestException');
+      } catch (error) {
+        expect(error).toBeInstanceOf(BadRequestException);
+        expect((error as BadRequestException).message).toContain('myParam');
+        expect((error as BadRequestException).message).toContain(
+          VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE,
+        );
+      }
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle numeric-only strings', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      const result = pipe.transform('123456', metadata);
+      expect(result).toBe('123456');
+    });
+
+    it('should handle uppercase letters', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      const result = pipe.transform('USER123', metadata);
+      expect(result).toBe('USER123');
+    });
+
+    it('should handle lowercase letters', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      const result = pipe.transform('user123', metadata);
+      expect(result).toBe('user123');
+    });
+
+    it('should handle mixed case letters', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'userId',
+      };
+      const result = pipe.transform('User123Item', metadata);
+      expect(result).toBe('User123Item');
+    });
+
+    it('should handle string with only dashes and underscores', () => {
+      const metadata: ArgumentMetadata = {
+        type: 'param',
+        data: 'itemId',
+      };
+      const result = pipe.transform('_-', metadata);
+      expect(result).toBe('_-');
+    });
+  });
+});

package/src/api/validation/param-validation.pipe.ts

@@ -0,0 +1,38 @@
+import { PipeTransform, Injectable, BadRequestException, ArgumentMetadata } from '@nestjs/common';
+import { VALIDATION_CONSTANTS } from '../../validation/dismissible-input.dto';
+
+/**
+ * Validation pipe for userId and itemId route parameters.
+ * Validates:
+ * - Required (non-empty)
+ * - Length between 1-64 characters
+ * - Contains only alphanumeric characters, dashes, and underscores
+ */
+@Injectable()
+export class ParamValidationPipe implements PipeTransform<string, string> {
+  transform(value: string, metadata: ArgumentMetadata): string {
+    const paramName = metadata.data || 'parameter';
+
+    if (!value || value.trim() === '') {
+      throw new BadRequestException(`${paramName} is required`);
+    }
+
+    if (value.length < VALIDATION_CONSTANTS.ID_MIN_LENGTH) {
+      throw new BadRequestException(
+        `${paramName} must be at least ${VALIDATION_CONSTANTS.ID_MIN_LENGTH} character`,
+      );
+    }
+
+    if (value.length > VALIDATION_CONSTANTS.ID_MAX_LENGTH) {
+      throw new BadRequestException(
+        `${paramName} must be at most ${VALIDATION_CONSTANTS.ID_MAX_LENGTH} characters`,
+      );
+    }
+
+    if (!VALIDATION_CONSTANTS.ID_PATTERN.test(value)) {
+      throw new BadRequestException(`${paramName} ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`);
+    }
+
+    return value;
+  }
+}

package/src/api/validation/param.decorators.ts

@@ -0,0 +1,32 @@
+import { Param } from '@nestjs/common';
+import { ParamValidationPipe } from './param-validation.pipe';
+
+/**
+ * Custom parameter decorator for userId.
+ * Combines @Param('userId') with ParamValidationPipe for validation.
+ *
+ * @example
+ * ```typescript
+ * @Get(':itemId')
+ * async getOrCreate(
+ *   @UserId() userId: string,
+ *   @ItemId() itemId: string,
+ * )
+ * ```
+ */
+export const UserId = () => Param('userId', ParamValidationPipe);
+
+/**
+ * Custom parameter decorator for itemId.
+ * Combines @Param('itemId') with ParamValidationPipe for validation.
+ *
+ * @example
+ * ```typescript
+ * @Get(':itemId')
+ * async getOrCreate(
+ *   @UserId() userId: string,
+ *   @ItemId() itemId: string,
+ * )
+ * ```
+ */
+export const ItemId = () => Param('itemId', ParamValidationPipe);

package/src/core/dismissible-core.service.spec.ts

@@ -7,7 +7,6 @@ import {
   ItemAlreadyDismissedException,
   ItemNotDismissedException,
 } from '../exceptions';
-import { BaseMetadata } from '@dismissible/nestjs-dismissible-item';
 import { DismissibleItemFactory } from '@dismissible/nestjs-dismissible-item';
 import { IDismissibleLogger } from '@dismissible/nestjs-logger';
 import { ValidationService } from '@dismissible/nestjs-validation';
@@ -16,8 +15,8 @@ import { DismissibleHelper } from '../utils/dismissible.helper';
 import { DateService } from '../utils/date/date.service';
 
 describe('DismissibleCoreService', () => {
-  let service: DismissibleCoreService<BaseMetadata>;
-  let storage: Mock<IDismissibleStorage<BaseMetadata>>;
+  let service: DismissibleCoreService;
+  let storage: Mock<IDismissibleStorage>;
   let mockDateService: Mock<DateService>;
   let mockLogger: Mock<IDismissibleLogger>;
   let itemFactory: Mock<DismissibleItemFactory>;
@@ -30,7 +29,7 @@ describe('DismissibleCoreService', () => {
     mockLogger = mock<IDismissibleLogger>({
       failIfMockNotProvided: false,
     });
-    storage = mock<IDismissibleStorage<BaseMetadata>>({
+    storage = mock<IDismissibleStorage>({
       failIfMockNotProvided: false,
     });
     dismissibleHelper = mock(DismissibleHelper, { failIfMockNotProvided: false });
@@ -51,6 +50,78 @@ describe('DismissibleCoreService', () => {
     jest.clearAllMocks();
   });
 
+  describe('get', () => {
+    it('should return item when it exists', async () => {
+      const userId = 'user-123';
+      const existingItem = createTestItem({ id: 'existing-item', userId });
+      storage.get.mockResolvedValue(existingItem);
+
+      const result = await service.get('existing-item', userId);
+
+      expect(result).toEqual(existingItem);
+      expect(storage.get).toHaveBeenCalledWith(userId, 'existing-item');
+    });
+
+    it('should return null when item does not exist', async () => {
+      const userId = 'user-123';
+      storage.get.mockResolvedValue(null);
+
+      const result = await service.get('non-existent', userId);
+
+      expect(result).toBeNull();
+      expect(storage.get).toHaveBeenCalledWith(userId, 'non-existent');
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new item', async () => {
+      const testDate = new Date('2024-01-15T10:00:00.000Z');
+      const userId = 'user-123';
+      const newItem = createTestItem({ id: 'new-item', userId, createdAt: testDate });
+
+      storage.create.mockResolvedValue(newItem);
+      mockDateService.getNow.mockReturnValue(testDate);
+      itemFactory.create.mockReturnValue(newItem);
+
+      const result = await service.create('new-item', userId);
+
+      expect(result.id).toBe('new-item');
+      expect(result.userId).toBe(userId);
+      expect(result.createdAt).toBeInstanceOf(Date);
+      expect(result.dismissedAt).toBeUndefined();
+      expect(storage.create).toHaveBeenCalledWith(newItem);
+    });
+
+    it('should validate item before storage', async () => {
+      const userId = 'user-123';
+      const testDate = new Date('2024-01-15T10:00:00.000Z');
+      const newItem = createTestItem({ id: 'new-item', userId, createdAt: testDate });
+
+      storage.create.mockResolvedValue(newItem);
+      mockDateService.getNow.mockReturnValue(testDate);
+      itemFactory.create.mockReturnValue(newItem);
+
+      await service.create('new-item', userId);
+
+      expect(validationService.validateInstance).toHaveBeenCalledWith(newItem);
+    });
+
+    it('should throw BadRequestException when validation fails', async () => {
+      const userId = 'user-123';
+      const testDate = new Date('2024-01-15T10:00:00.000Z');
+      const newItem = createTestItem({ id: 'new-item', userId, createdAt: testDate });
+
+      mockDateService.getNow.mockReturnValue(testDate);
+      itemFactory.create.mockReturnValue(newItem);
+      validationService.validateInstance.mockRejectedValue(
+        new BadRequestException('id must be a string'),
+      );
+
+      await expect(service.create('new-item', userId)).rejects.toThrow(BadRequestException);
+      expect(storage.create).not.toHaveBeenCalled();
+    });
+  });
+
   describe('getOrCreate', () => {
     it('should create a new item when it does not exist', async () => {
       const testDate = new Date('2024-01-15T10:00:00.000Z');
@@ -83,23 +154,6 @@ describe('DismissibleCoreService', () => {
       expect(result.item).toEqual(existingItem);
       expect(storage.get).toHaveBeenCalledWith(userId, 'existing-item');
     });
-
-    it('should create item with metadata when provided', async () => {
-      const userId = 'user-123';
-      const metadata = { version: 2, category: 'test' };
-      const testDate = new Date('2024-01-15T10:00:00.000Z');
-      const newItem = createTestItem({ id: 'new-item', userId, metadata, createdAt: testDate });
-
-      storage.get.mockResolvedValue(null);
-      storage.create.mockResolvedValue(newItem);
-      mockDateService.getNow.mockReturnValue(testDate);
-      itemFactory.create.mockReturnValue(newItem);
-
-      const result = await service.getOrCreate('new-item', userId, { metadata });
-
-      expect(result.item.metadata).toEqual(metadata);
-      expect(storage.create).toHaveBeenCalledWith(newItem);
-    });
   });
 
   describe('dismiss', () => {
@@ -148,17 +202,14 @@ describe('DismissibleCoreService', () => {
       const item = createTestItem({
         id: 'test-item',
         userId,
-        metadata: { key: 'value' },
       });
       const previousItem = createTestItem({
         id: 'test-item',
         userId,
-        metadata: { key: 'value' },
       });
       const dismissedItem = createDismissedTestItem({
         id: 'test-item',
         userId,
-        metadata: { key: 'value' },
       });
       const testDate = new Date('2024-01-15T12:00:00.000Z');
 
@@ -173,7 +224,6 @@ describe('DismissibleCoreService', () => {
 
       expect(result.previousItem.id).toBe(item.id);
       expect(result.previousItem.dismissedAt).toBeUndefined();
-      expect(result.previousItem.metadata).toEqual({ key: 'value' });
     });
   });
 
@@ -221,17 +271,14 @@ describe('DismissibleCoreService', () => {
       const dismissedItem = createDismissedTestItem({
         id: 'dismissed-item',
         userId,
-        metadata: { key: 'value' },
       });
       const previousItem = createDismissedTestItem({
         id: 'dismissed-item',
         userId,
-        metadata: { key: 'value' },
       });
       const restoredItem = createTestItem({
         id: 'dismissed-item',
         userId,
-        metadata: { key: 'value' },
       });
 
       storage.get.mockResolvedValue(dismissedItem);
@@ -244,7 +291,6 @@ describe('DismissibleCoreService', () => {
 
       expect(result.previousItem.id).toBe(dismissedItem.id);
       expect(result.previousItem.dismissedAt).toBeDefined();
-      expect(result.previousItem.metadata).toEqual({ key: 'value' });
     });
   });