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

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

@@ -0,0 +1,317 @@
+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',
+      };
+      // Empty string is already handled, but we test with a value that would pass empty check
+      // but fail length check (though in practice, empty string is caught first)
+      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',
+      };
+      // This should pass pattern validation but might fail length if too short
+      // Since min length is 1, a single dash or underscore should pass
+      const result = pipe.transform('_-', metadata);
+      expect(result).toBe('_-');
+    });
+  });
+});

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

@@ -0,0 +1,42 @@
+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';
+
+    // Check if value exists
+    if (!value || value.trim() === '') {
+      throw new BadRequestException(`${paramName} is required`);
+    }
+
+    // Check minimum length
+    if (value.length < VALIDATION_CONSTANTS.ID_MIN_LENGTH) {
+      throw new BadRequestException(
+        `${paramName} must be at least ${VALIDATION_CONSTANTS.ID_MIN_LENGTH} character`,
+      );
+    }
+
+    // Check maximum length
+    if (value.length > VALIDATION_CONSTANTS.ID_MAX_LENGTH) {
+      throw new BadRequestException(
+        `${paramName} must be at most ${VALIDATION_CONSTANTS.ID_MAX_LENGTH} characters`,
+      );
+    }
+
+    // Check pattern
+    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' });
     });
   });
 

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

@@ -14,17 +14,16 @@ import {
   ItemNotDismissedException,
 } from '../exceptions';
 import { ValidationService } from '@dismissible/nestjs-validation';
-import { BaseMetadata, DismissibleItemFactory } from '@dismissible/nestjs-dismissible-item';
-import { ICreateItemOptions } from './create-options';
+import { DismissibleItemDto, DismissibleItemFactory } from '@dismissible/nestjs-dismissible-item';
 
 /**
  * Core business logic service for dismissible operations.
  * Handles pure CRUD operations without side effects (hooks, events).
  */
 @Injectable()
-export class DismissibleCoreService<TMetadata extends BaseMetadata = BaseMetadata> {
+export class DismissibleCoreService {
   constructor(
-    @Inject(DISMISSIBLE_STORAGE_ADAPTER) private readonly storage: IDismissibleStorage<TMetadata>,
+    @Inject(DISMISSIBLE_STORAGE_ADAPTER) private readonly storage: IDismissibleStorage,
     private readonly dateService: DateService,
     @Inject(DISMISSIBLE_LOGGER) private readonly logger: IDismissibleLogger,
     private readonly itemFactory: DismissibleItemFactory,
@@ -33,41 +32,38 @@ export class DismissibleCoreService<TMetadata extends BaseMetadata = BaseMetadat
   ) {}
 
   /**
-   * Get an existing item or create a new one.
+   * Get an existing item by user ID and item ID.
    * @param itemId The item identifier
    * @param userId The user identifier (required)
-   * @param options Optional creation options (metadata)
+   * @returns The item or null if not found
    */
-  async getOrCreate(
-    itemId: string,
-    userId: string,
-    options?: ICreateItemOptions<TMetadata>,
-  ): Promise<IGetOrCreateServiceResponse<TMetadata>> {
+  async get(itemId: string, userId: string): Promise<DismissibleItemDto | null> {
     this.logger.debug(`Looking up item in storage`, { itemId, userId });
-
-    const existingItem = await this.storage.get(userId, itemId);
-
-    if (existingItem) {
+    const item = await this.storage.get(userId, itemId);
+    if (item) {
       this.logger.debug(`Found existing item`, { itemId, userId });
-      return {
-        item: existingItem,
-        created: false,
-      };
     }
+    return item;
+  }
 
+  /**
+   * Create a new item.
+   * @param itemId The item identifier
+   * @param userId The user identifier (required)
+   * @returns The created item
+   */
+  async create(itemId: string, userId: string): Promise<DismissibleItemDto> {
     this.logger.debug(`Creating new item`, {
       itemId,
       userId,
-      hasMetadata: !!options?.metadata,
     });
 
     // Create new item
     const now = this.dateService.getNow();
-    const newItem = this.itemFactory.create<TMetadata>({
+    const newItem = this.itemFactory.create({
       id: itemId,
       createdAt: now,
       userId,
-      metadata: options?.metadata,
     });
 
     // Validate the item before storage
@@ -77,6 +73,26 @@ export class DismissibleCoreService<TMetadata extends BaseMetadata = BaseMetadat
 
     this.logger.info(`Created new dismissible item`, { itemId, userId });
 
+    return createdItem;
+  }
+
+  /**
+   * Get an existing item or create a new one.
+   * @param itemId The item identifier
+   * @param userId The user identifier (required)
+   */
+  async getOrCreate(itemId: string, userId: string): Promise<IGetOrCreateServiceResponse> {
+    const existingItem = await this.get(itemId, userId);
+
+    if (existingItem) {
+      return {
+        item: existingItem,
+        created: false,
+      };
+    }
+
+    const createdItem = await this.create(itemId, userId);
+
     return {
       item: createdItem,
       created: true,
@@ -90,7 +106,7 @@ export class DismissibleCoreService<TMetadata extends BaseMetadata = BaseMetadat
    * @throws ItemNotFoundException if item doesn't exist
    * @throws ItemAlreadyDismissedException if item is already dismissed
    */
-  async dismiss(itemId: string, userId: string): Promise<IDismissServiceResponse<TMetadata>> {
+  async dismiss(itemId: string, userId: string): Promise<IDismissServiceResponse> {
     this.logger.debug(`Attempting to dismiss item`, { itemId, userId });
 
     const existingItem = await this.storage.get(userId, itemId);
@@ -128,7 +144,7 @@ export class DismissibleCoreService<TMetadata extends BaseMetadata = BaseMetadat
    * @throws ItemNotFoundException if item doesn't exist
    * @throws ItemNotDismissedException if item is not dismissed
    */
-  async restore(itemId: string, userId: string): Promise<IRestoreServiceResponse<TMetadata>> {
+  async restore(itemId: string, userId: string): Promise<IRestoreServiceResponse> {
     this.logger.debug(`Attempting to restore item`, { itemId, userId });
 
     const existingItem = await this.storage.get(userId, itemId);