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

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

@@ -4,16 +4,17 @@ import { DismissibleService } from './dismissible.service';
 import { DismissibleCoreService } from './dismissible-core.service';
 import { HookRunner, IHookRunResult } from './hook-runner.service';
 import { IDismissibleLogger } from '@dismissible/nestjs-logger';
+import { ValidationService } from '@dismissible/nestjs-validation';
 import { DismissibleEvents } from '../events';
-import { BaseMetadata } from '@dismissible/nestjs-dismissible-item';
 import { createTestItem, createTestContext } from '../testing/factories';
 
 describe('DismissibleService', () => {
-  let service: DismissibleService<BaseMetadata>;
-  let mockCoreService: jest.Mocked<DismissibleCoreService<BaseMetadata>>;
-  let mockHookRunner: jest.Mocked<HookRunner<BaseMetadata>>;
+  let service: DismissibleService;
+  let mockCoreService: jest.Mocked<DismissibleCoreService>;
+  let mockHookRunner: jest.Mocked<HookRunner>;
   let mockEventEmitter: jest.Mocked<EventEmitter2>;
   let mockLogger: jest.Mocked<IDismissibleLogger>;
+  let mockValidationService: jest.Mocked<ValidationService>;
 
   const testUserId = 'test-user-id';
 
@@ -29,8 +30,18 @@ describe('DismissibleService', () => {
     mockHookRunner = mock(HookRunner, { failIfMockNotProvided: false });
     mockEventEmitter = mock(EventEmitter2, { failIfMockNotProvided: false });
     mockLogger = mock<IDismissibleLogger>({ failIfMockNotProvided: false });
-
-    service = new DismissibleService(mockCoreService, mockHookRunner, mockEventEmitter, mockLogger);
+    mockValidationService = mock(ValidationService, { failIfMockNotProvided: false });
+
+    // Mock validateDto to resolve successfully by default
+    mockValidationService.validateDto.mockResolvedValue({} as never);
+
+    service = new DismissibleService(
+      mockCoreService,
+      mockHookRunner,
+      mockEventEmitter,
+      mockLogger,
+      mockValidationService,
+    );
   });
 
   describe('getOrCreate', () => {
@@ -42,7 +53,7 @@ describe('DismissibleService', () => {
       mockHookRunner.runPreGet.mockResolvedValue(createHookResult('existing-item'));
       mockCoreService.get.mockResolvedValue(item);
 
-      const result = await service.getOrCreate('existing-item', testUserId, undefined, context);
+      const result = await service.getOrCreate('existing-item', testUserId, context);
 
       expect(mockHookRunner.runPreRequest).toHaveBeenCalled();
       expect(mockCoreService.get).toHaveBeenCalledWith('existing-item', testUserId);
@@ -79,13 +90,13 @@ describe('DismissibleService', () => {
         return item;
       });
 
-      const result = await service.getOrCreate('new-item', testUserId, undefined, context);
+      const result = await service.getOrCreate('new-item', testUserId, context);
 
       // Verify pre-create hooks run BEFORE create
       expect(callOrder).toEqual(['runPreCreate', 'create']);
       expect(mockHookRunner.runPreRequest).toHaveBeenCalled();
       expect(mockHookRunner.runPreCreate).toHaveBeenCalled();
-      expect(mockCoreService.create).toHaveBeenCalledWith('new-item', testUserId, undefined);
+      expect(mockCoreService.create).toHaveBeenCalledWith('new-item', testUserId);
       expect(mockHookRunner.runPostCreate).toHaveBeenCalled();
       expect(mockHookRunner.runPostRequest).toHaveBeenCalled();
       expect(mockEventEmitter.emit).toHaveBeenCalledWith(
@@ -108,9 +119,7 @@ describe('DismissibleService', () => {
         context: createTestContext(),
       });
 
-      await expect(
-        service.getOrCreate('new-item', testUserId, undefined, context),
-      ).rejects.toThrow();
+      await expect(service.getOrCreate('new-item', testUserId, context)).rejects.toThrow();
 
       // Verify create was NOT called because pre-create hook blocked it
       expect(mockCoreService.create).not.toHaveBeenCalled();
@@ -135,9 +144,7 @@ describe('DismissibleService', () => {
         context: createTestContext(),
       });
 
-      await expect(
-        service.getOrCreate('existing-item', testUserId, undefined, context),
-      ).rejects.toThrow();
+      await expect(service.getOrCreate('existing-item', testUserId, context)).rejects.toThrow();
 
       // Verify post-get hooks were NOT called because pre-get hook blocked
       expect(mockHookRunner.runPostGet).not.toHaveBeenCalled();
@@ -208,7 +215,7 @@ describe('DismissibleService', () => {
       mockHookRunner.runPreGet.mockResolvedValue(createHookResult('test-item'));
       mockCoreService.get.mockResolvedValue(item);
 
-      await service.getOrCreate('test-item', testUserId, undefined, context);
+      await service.getOrCreate('test-item', testUserId, context);
 
       expect(mockLogger.debug).toHaveBeenCalledWith(
         expect.stringContaining('getOrCreate called'),

package/src/core/dismissible.service.ts

@@ -8,8 +8,6 @@ import {
   IDismissServiceResponse,
   IRestoreServiceResponse,
 } from './service-responses.interface';
-import { BaseMetadata } from '@dismissible/nestjs-dismissible-item';
-import { ICreateItemOptions } from './create-options';
 import { IRequestContext } from '../request/request-context.interface';
 import { DismissibleEvents } from '../events';
 import {
@@ -18,36 +16,49 @@ import {
   ItemDismissedEvent,
   ItemRestoredEvent,
 } from '../events';
+import { ValidationService } from '@dismissible/nestjs-validation';
+import { DismissibleInputDto } from '../validation';
 
 /**
  * Main orchestration service for dismissible operations.
  * Coordinates core logic, hooks, and events.
  */
 @Injectable()
-export class DismissibleService<TMetadata extends BaseMetadata = BaseMetadata> {
+export class DismissibleService {
   constructor(
-    private readonly coreService: DismissibleCoreService<TMetadata>,
-    private readonly hookRunner: HookRunner<TMetadata>,
+    private readonly coreService: DismissibleCoreService,
+    private readonly hookRunner: HookRunner,
     private readonly eventEmitter: EventEmitter2,
     @Inject(DISMISSIBLE_LOGGER)
     private readonly logger: IDismissibleLogger,
+    private readonly validationService: ValidationService,
   ) {}
 
+  /**
+   * Validates input parameters for all service methods.
+   * Provides defense in depth when the service is used directly without controllers.
+   */
+  private async validateInput(itemId: string, userId: string): Promise<void> {
+    // Validate itemId and userId
+    await this.validationService.validateDto(DismissibleInputDto, { itemId, userId });
+  }
+
   /**
    * Get an existing item or create a new one.
    * @param itemId The item identifier
    * @param userId The user identifier (required)
-   * @param options Optional creation options (metadata)
    * @param context Optional request context for tracing
    */
   async getOrCreate(
     itemId: string,
     userId: string,
-    options?: ICreateItemOptions<TMetadata>,
     context?: IRequestContext,
-  ): Promise<IGetOrCreateServiceResponse<TMetadata>> {
+  ): Promise<IGetOrCreateServiceResponse> {
     this.logger.debug(`getOrCreate called`, { itemId, userId });
 
+    // Validate input parameters
+    await this.validateInput(itemId, userId);
+
     // Run global pre-request hooks (auth, rate limiting, validation)
     const preResult = await this.hookRunner.runPreRequest(itemId, userId, context);
     HookRunner.throwIfBlocked(preResult);
@@ -103,7 +114,7 @@ export class DismissibleService<TMetadata extends BaseMetadata = BaseMetadata> {
     HookRunner.throwIfBlocked(preCreateResult);
 
     // Now create the item
-    const createdItem = await this.coreService.create(resolvedId, resolvedUserId, options);
+    const createdItem = await this.coreService.create(resolvedId, resolvedUserId);
 
     // Run post-create hooks
     await this.hookRunner.runPostCreate(resolvedId, createdItem, resolvedUserId, resolvedContext);
@@ -135,9 +146,12 @@ export class DismissibleService<TMetadata extends BaseMetadata = BaseMetadata> {
     itemId: string,
     userId: string,
     context?: IRequestContext,
-  ): Promise<IDismissServiceResponse<TMetadata>> {
+  ): Promise<IDismissServiceResponse> {
     this.logger.debug(`dismiss called`, { itemId, userId });
 
+    // Validate input parameters
+    await this.validateInput(itemId, userId);
+
     // Run global pre-request hooks (auth, rate limiting, validation)
     const preRequestResult = await this.hookRunner.runPreRequest(itemId, userId, context);
     HookRunner.throwIfBlocked(preRequestResult);
@@ -190,9 +204,12 @@ export class DismissibleService<TMetadata extends BaseMetadata = BaseMetadata> {
     itemId: string,
     userId: string,
     context?: IRequestContext,
-  ): Promise<IRestoreServiceResponse<TMetadata>> {
+  ): Promise<IRestoreServiceResponse> {
     this.logger.debug(`restore called`, { itemId, userId });
 
+    // Validate input parameters
+    await this.validateInput(itemId, userId);
+
     // Run global pre-request hooks (auth, rate limiting, validation)
     const preRequestResult = await this.hookRunner.runPreRequest(itemId, userId, context);
     HookRunner.throwIfBlocked(preRequestResult);