@dismissible/nestjs-dismissible 0.0.2-canary.738340d.0

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

@@ -0,0 +1,357 @@
+import { Mock, mock } from 'ts-jest-mocker';
+import { DismissibleCoreService } from './dismissible-core.service';
+import { IDismissibleStorage } from '@dismissible/nestjs-storage';
+import { createTestItem, createDismissedTestItem } from '../testing/factories';
+import {
+  ItemNotFoundException,
+  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';
+import { BadRequestException } from '@nestjs/common';
+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 mockDateService: Mock<DateService>;
+  let mockLogger: Mock<IDismissibleLogger>;
+  let itemFactory: Mock<DismissibleItemFactory>;
+  let validationService: Mock<ValidationService>;
+  let dismissibleHelper: Mock<DismissibleHelper>;
+
+  beforeEach(() => {
+    mockDateService = mock(DateService);
+    mockDateService.getNow.mockReturnValue(new Date('2024-01-15T10:00:00.000Z'));
+    mockLogger = mock<IDismissibleLogger>({
+      failIfMockNotProvided: false,
+    });
+    storage = mock<IDismissibleStorage<BaseMetadata>>({
+      failIfMockNotProvided: false,
+    });
+    dismissibleHelper = mock(DismissibleHelper, { failIfMockNotProvided: false });
+    itemFactory = mock(DismissibleItemFactory);
+    validationService = mock(ValidationService, { failIfMockNotProvided: false });
+    validationService.validateInstance.mockResolvedValue(undefined);
+    service = new DismissibleCoreService(
+      storage,
+      mockDateService,
+      mockLogger,
+      itemFactory,
+      validationService,
+      dismissibleHelper,
+    );
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getOrCreate', () => {
+    it('should create a new item when it does not exist', 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.get.mockResolvedValue(null);
+      storage.create.mockResolvedValue(newItem);
+      mockDateService.getNow.mockReturnValue(testDate);
+      itemFactory.create.mockReturnValue(newItem);
+
+      const result = await service.getOrCreate('new-item', userId);
+
+      expect(result.created).toBe(true);
+      expect(result.item.id).toBe('new-item');
+      expect(result.item.userId).toBe(userId);
+      expect(result.item.createdAt).toBeInstanceOf(Date);
+      expect(result.item.dismissedAt).toBeUndefined();
+      expect(storage.create).toHaveBeenCalledWith(newItem);
+    });
+
+    it('should return existing item when it exists', async () => {
+      const userId = 'user-123';
+      const existingItem = createTestItem({ id: 'existing-item', userId });
+      storage.get.mockResolvedValue(existingItem);
+
+      const result = await service.getOrCreate('existing-item', userId);
+
+      expect(result.created).toBe(false);
+      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', () => {
+    it('should dismiss an existing item', async () => {
+      const userId = 'user-123';
+      const item = createTestItem({ id: 'test-item', userId });
+      const previousItem = createTestItem({ id: 'test-item', userId });
+      const dismissedItem = createDismissedTestItem({ id: 'test-item', userId });
+      const testDate = new Date('2024-01-15T12:00:00.000Z');
+
+      storage.get.mockResolvedValue(item);
+      storage.update.mockResolvedValue(dismissedItem);
+      itemFactory.clone.mockReturnValue(previousItem);
+      mockDateService.getNow.mockReturnValue(testDate);
+      itemFactory.createDismissed.mockReturnValue(dismissedItem);
+      dismissibleHelper.isDismissed.mockReturnValue(false);
+
+      const result = await service.dismiss('test-item', userId);
+
+      expect(result.item.dismissedAt).toBeDefined();
+      expect(result.previousItem.dismissedAt).toBeUndefined();
+      expect(storage.update).toHaveBeenCalledWith(dismissedItem);
+      expect(storage.get).toHaveBeenCalledWith(userId, 'test-item');
+    });
+
+    it('should throw ItemNotFoundException for non-existent item', async () => {
+      const userId = 'user-123';
+      storage.get.mockResolvedValue(null);
+
+      await expect(service.dismiss('non-existent', userId)).rejects.toThrow(ItemNotFoundException);
+    });
+
+    it('should throw ItemAlreadyDismissedException for already dismissed item', async () => {
+      const userId = 'user-123';
+      const dismissedItem = createDismissedTestItem({ id: 'dismissed-item', userId });
+      storage.get.mockResolvedValue(dismissedItem);
+      dismissibleHelper.isDismissed.mockReturnValue(true);
+
+      await expect(service.dismiss('dismissed-item', userId)).rejects.toThrow(
+        ItemAlreadyDismissedException,
+      );
+    });
+
+    it('should return the previous item state', async () => {
+      const userId = 'user-123';
+      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');
+
+      storage.get.mockResolvedValue(item);
+      storage.update.mockResolvedValue(dismissedItem);
+      itemFactory.clone.mockReturnValue(previousItem);
+      mockDateService.getNow.mockReturnValue(testDate);
+      itemFactory.createDismissed.mockReturnValue(dismissedItem);
+      dismissibleHelper.isDismissed.mockReturnValue(false);
+
+      const result = await service.dismiss('test-item', userId);
+
+      expect(result.previousItem.id).toBe(item.id);
+      expect(result.previousItem.dismissedAt).toBeUndefined();
+      expect(result.previousItem.metadata).toEqual({ key: 'value' });
+    });
+  });
+
+  describe('restore', () => {
+    it('should restore a dismissed item', async () => {
+      const userId = 'user-123';
+      const dismissedItem = createDismissedTestItem({ id: 'dismissed-item', userId });
+      const previousItem = createDismissedTestItem({ id: 'dismissed-item', userId });
+      const restoredItem = createTestItem({ id: 'dismissed-item', userId });
+
+      storage.get.mockResolvedValue(dismissedItem);
+      storage.update.mockResolvedValue(restoredItem);
+      itemFactory.clone.mockReturnValue(previousItem);
+      itemFactory.createRestored.mockReturnValue(restoredItem);
+      dismissibleHelper.isDismissed.mockReturnValue(true);
+
+      const result = await service.restore('dismissed-item', userId);
+
+      expect(result.item.dismissedAt).toBeUndefined();
+      expect(result.previousItem.dismissedAt).toBeDefined();
+      expect(storage.update).toHaveBeenCalledWith(restoredItem);
+      expect(storage.get).toHaveBeenCalledWith(userId, 'dismissed-item');
+    });
+
+    it('should throw ItemNotFoundException for non-existent item', async () => {
+      const userId = 'user-123';
+      storage.get.mockResolvedValue(null);
+
+      await expect(service.restore('non-existent', userId)).rejects.toThrow(ItemNotFoundException);
+    });
+
+    it('should throw ItemNotDismissedException for non-dismissed item', async () => {
+      const userId = 'user-123';
+      const item = createTestItem({ id: 'active-item', userId });
+      storage.get.mockResolvedValue(item);
+      dismissibleHelper.isDismissed.mockReturnValue(false);
+
+      await expect(service.restore('active-item', userId)).rejects.toThrow(
+        ItemNotDismissedException,
+      );
+    });
+
+    it('should return the previous item state', async () => {
+      const userId = 'user-123';
+      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);
+      storage.update.mockResolvedValue(restoredItem);
+      itemFactory.clone.mockReturnValue(previousItem);
+      itemFactory.createRestored.mockReturnValue(restoredItem);
+      dismissibleHelper.isDismissed.mockReturnValue(true);
+
+      const result = await service.restore('dismissed-item', userId);
+
+      expect(result.previousItem.id).toBe(dismissedItem.id);
+      expect(result.previousItem.dismissedAt).toBeDefined();
+      expect(result.previousItem.metadata).toEqual({ key: 'value' });
+    });
+  });
+
+  describe('validation', () => {
+    it('should throw BadRequestException when validation fails on create', 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.get.mockResolvedValue(null);
+      mockDateService.getNow.mockReturnValue(testDate);
+      itemFactory.create.mockReturnValue(newItem);
+      validationService.validateInstance.mockRejectedValue(
+        new BadRequestException('id must be a string'),
+      );
+
+      await expect(service.getOrCreate('new-item', userId)).rejects.toThrow(BadRequestException);
+      expect(storage.create).not.toHaveBeenCalled();
+    });
+
+    it('should throw BadRequestException when validation fails on dismiss', async () => {
+      const userId = 'user-123';
+      const item = createTestItem({ id: 'test-item', userId });
+      const previousItem = createTestItem({ id: 'test-item', userId });
+      const dismissedItem = createDismissedTestItem({ id: 'test-item', userId });
+      const testDate = new Date('2024-01-15T12:00:00.000Z');
+
+      storage.get.mockResolvedValue(item);
+      itemFactory.clone.mockReturnValue(previousItem);
+      mockDateService.getNow.mockReturnValue(testDate);
+      itemFactory.createDismissed.mockReturnValue(dismissedItem);
+      dismissibleHelper.isDismissed.mockReturnValue(false);
+      validationService.validateInstance.mockRejectedValue(
+        new BadRequestException('dismissedAt must be a date'),
+      );
+
+      await expect(service.dismiss('test-item', userId)).rejects.toThrow(BadRequestException);
+      expect(storage.update).not.toHaveBeenCalled();
+    });
+
+    it('should throw BadRequestException when validation fails on restore', async () => {
+      const userId = 'user-123';
+      const dismissedItem = createDismissedTestItem({ id: 'dismissed-item', userId });
+      const previousItem = createDismissedTestItem({ id: 'dismissed-item', userId });
+      const restoredItem = createTestItem({ id: 'dismissed-item', userId });
+
+      storage.get.mockResolvedValue(dismissedItem);
+      itemFactory.clone.mockReturnValue(previousItem);
+      itemFactory.createRestored.mockReturnValue(restoredItem);
+      dismissibleHelper.isDismissed.mockReturnValue(true);
+      validationService.validateInstance.mockRejectedValue(
+        new BadRequestException('id must be a string'),
+      );
+
+      await expect(service.restore('dismissed-item', userId)).rejects.toThrow(BadRequestException);
+      expect(storage.update).not.toHaveBeenCalled();
+    });
+
+    it('should validate item when creating', 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.get.mockResolvedValue(null);
+      storage.create.mockResolvedValue(newItem);
+      mockDateService.getNow.mockReturnValue(testDate);
+      itemFactory.create.mockReturnValue(newItem);
+
+      await service.getOrCreate('new-item', userId);
+
+      expect(validationService.validateInstance).toHaveBeenCalledWith(newItem);
+    });
+
+    it('should validate item when dismissing', async () => {
+      const userId = 'user-123';
+      const item = createTestItem({ id: 'test-item', userId });
+      const previousItem = createTestItem({ id: 'test-item', userId });
+      const dismissedItem = createDismissedTestItem({ id: 'test-item', userId });
+      const testDate = new Date('2024-01-15T12:00:00.000Z');
+
+      storage.get.mockResolvedValue(item);
+      storage.update.mockResolvedValue(dismissedItem);
+      itemFactory.clone.mockReturnValue(previousItem);
+      mockDateService.getNow.mockReturnValue(testDate);
+      itemFactory.createDismissed.mockReturnValue(dismissedItem);
+      dismissibleHelper.isDismissed.mockReturnValue(false);
+
+      await service.dismiss('test-item', userId);
+
+      expect(validationService.validateInstance).toHaveBeenCalledWith(dismissedItem);
+    });
+
+    it('should validate item when restoring', async () => {
+      const userId = 'user-123';
+      const dismissedItem = createDismissedTestItem({ id: 'dismissed-item', userId });
+      const previousItem = createDismissedTestItem({ id: 'dismissed-item', userId });
+      const restoredItem = createTestItem({ id: 'dismissed-item', userId });
+
+      storage.get.mockResolvedValue(dismissedItem);
+      storage.update.mockResolvedValue(restoredItem);
+      itemFactory.clone.mockReturnValue(previousItem);
+      itemFactory.createRestored.mockReturnValue(restoredItem);
+      dismissibleHelper.isDismissed.mockReturnValue(true);
+
+      await service.restore('dismissed-item', userId);
+
+      expect(validationService.validateInstance).toHaveBeenCalledWith(restoredItem);
+    });
+  });
+});

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

@@ -0,0 +1,161 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { DISMISSIBLE_STORAGE_ADAPTER, IDismissibleStorage } from '@dismissible/nestjs-storage';
+import {
+  IGetOrCreateServiceResponse,
+  IDismissServiceResponse,
+  IRestoreServiceResponse,
+} from './service-responses.interface';
+import { DismissibleHelper } from '../utils/dismissible.helper';
+import { DateService } from '../utils/date/date.service';
+import { DISMISSIBLE_LOGGER, IDismissibleLogger } from '@dismissible/nestjs-logger';
+import {
+  ItemNotFoundException,
+  ItemAlreadyDismissedException,
+  ItemNotDismissedException,
+} from '../exceptions';
+import { ValidationService } from '@dismissible/nestjs-validation';
+import { BaseMetadata, DismissibleItemFactory } from '@dismissible/nestjs-dismissible-item';
+import { ICreateItemOptions } from './create-options';
+
+/**
+ * Core business logic service for dismissible operations.
+ * Handles pure CRUD operations without side effects (hooks, events).
+ */
+@Injectable()
+export class DismissibleCoreService<TMetadata extends BaseMetadata = BaseMetadata> {
+  constructor(
+    @Inject(DISMISSIBLE_STORAGE_ADAPTER) private readonly storage: IDismissibleStorage<TMetadata>,
+    private readonly dateService: DateService,
+    @Inject(DISMISSIBLE_LOGGER) private readonly logger: IDismissibleLogger,
+    private readonly itemFactory: DismissibleItemFactory,
+    private readonly validationService: ValidationService,
+    private readonly dismissibleHelper: DismissibleHelper,
+  ) {}
+
+  /**
+   * 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)
+   */
+  async getOrCreate(
+    itemId: string,
+    userId: string,
+    options?: ICreateItemOptions<TMetadata>,
+  ): Promise<IGetOrCreateServiceResponse<TMetadata>> {
+    this.logger.debug(`Looking up item in storage`, { itemId, userId });
+
+    const existingItem = await this.storage.get(userId, itemId);
+
+    if (existingItem) {
+      this.logger.debug(`Found existing item`, { itemId, userId });
+      return {
+        item: existingItem,
+        created: false,
+      };
+    }
+
+    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>({
+      id: itemId,
+      createdAt: now,
+      userId,
+      metadata: options?.metadata,
+    });
+
+    // Validate the item before storage
+    await this.validationService.validateInstance(newItem);
+
+    const createdItem = await this.storage.create(newItem);
+
+    this.logger.info(`Created new dismissible item`, { itemId, userId });
+
+    return {
+      item: createdItem,
+      created: true,
+    };
+  }
+
+  /**
+   * Dismiss an item.
+   * @param itemId The item identifier
+   * @param userId The user identifier (required)
+   * @throws ItemNotFoundException if item doesn't exist
+   * @throws ItemAlreadyDismissedException if item is already dismissed
+   */
+  async dismiss(itemId: string, userId: string): Promise<IDismissServiceResponse<TMetadata>> {
+    this.logger.debug(`Attempting to dismiss item`, { itemId, userId });
+
+    const existingItem = await this.storage.get(userId, itemId);
+
+    if (!existingItem) {
+      this.logger.warn(`Cannot dismiss: item not found`, { itemId, userId });
+      throw new ItemNotFoundException(itemId);
+    }
+
+    if (this.dismissibleHelper.isDismissed(existingItem)) {
+      this.logger.warn(`Cannot dismiss: item already dismissed`, { itemId, userId });
+      throw new ItemAlreadyDismissedException(itemId);
+    }
+
+    const previousItem = this.itemFactory.clone(existingItem);
+    const dismissedItem = this.itemFactory.createDismissed(existingItem, this.dateService.getNow());
+
+    // Validate the item before storage
+    await this.validationService.validateInstance(dismissedItem);
+
+    const updatedItem = await this.storage.update(dismissedItem);
+
+    this.logger.info(`Item dismissed`, { itemId, userId });
+
+    return {
+      item: updatedItem,
+      previousItem,
+    };
+  }
+
+  /**
+   * Restore a dismissed item.
+   * @param itemId The item identifier
+   * @param userId The user identifier (required)
+   * @throws ItemNotFoundException if item doesn't exist
+   * @throws ItemNotDismissedException if item is not dismissed
+   */
+  async restore(itemId: string, userId: string): Promise<IRestoreServiceResponse<TMetadata>> {
+    this.logger.debug(`Attempting to restore item`, { itemId, userId });
+
+    const existingItem = await this.storage.get(userId, itemId);
+
+    if (!existingItem) {
+      this.logger.warn(`Cannot restore: item not found`, { itemId, userId });
+      throw new ItemNotFoundException(itemId);
+    }
+
+    if (!this.dismissibleHelper.isDismissed(existingItem)) {
+      this.logger.warn(`Cannot restore: item not dismissed`, { itemId, userId });
+      throw new ItemNotDismissedException(itemId);
+    }
+
+    const previousItem = this.itemFactory.clone(existingItem);
+    const restoredItem = this.itemFactory.createRestored(existingItem);
+
+    // Validate the item before storage
+    await this.validationService.validateInstance(restoredItem);
+
+    const updatedItem = await this.storage.update(restoredItem);
+
+    this.logger.info(`Item restored`, { itemId, userId });
+
+    return {
+      item: updatedItem,
+      previousItem,
+    };
+  }
+}

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

@@ -0,0 +1,144 @@
+import { mock } from 'ts-jest-mocker';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+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 { 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 mockEventEmitter: jest.Mocked<EventEmitter2>;
+  let mockLogger: jest.Mocked<IDismissibleLogger>;
+
+  const testUserId = 'test-user-id';
+
+  const createHookResult = (id: string, userId = testUserId): IHookRunResult => ({
+    proceed: true,
+    id,
+    userId,
+    context: createTestContext(),
+  });
+
+  beforeEach(() => {
+    mockCoreService = mock(DismissibleCoreService, { failIfMockNotProvided: false });
+    mockHookRunner = mock(HookRunner, { failIfMockNotProvided: false });
+    mockEventEmitter = mock(EventEmitter2, { failIfMockNotProvided: false });
+    mockLogger = mock<IDismissibleLogger>({ failIfMockNotProvided: false });
+
+    service = new DismissibleService(mockCoreService, mockHookRunner, mockEventEmitter, mockLogger);
+  });
+
+  describe('getOrCreate', () => {
+    it('should run hooks, call core service, and emit ITEM_RETRIEVED event for existing item', async () => {
+      const item = createTestItem({ id: 'existing-item' });
+      const context = createTestContext();
+
+      mockHookRunner.runPreGetOrCreate.mockResolvedValue(createHookResult('existing-item'));
+      mockCoreService.getOrCreate.mockResolvedValue({ item, created: false });
+
+      const result = await service.getOrCreate('existing-item', testUserId, undefined, context);
+
+      expect(mockHookRunner.runPreGetOrCreate).toHaveBeenCalled();
+      expect(mockCoreService.getOrCreate).toHaveBeenCalledWith(
+        'existing-item',
+        testUserId,
+        undefined,
+      );
+      expect(mockHookRunner.runPostGetOrCreate).toHaveBeenCalled();
+      expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+        DismissibleEvents.ITEM_RETRIEVED,
+        expect.anything(),
+      );
+      expect(result.created).toBe(false);
+    });
+
+    it('should run create hooks and emit ITEM_CREATED event for new item', async () => {
+      const item = createTestItem({ id: 'new-item' });
+      const context = createTestContext();
+
+      mockHookRunner.runPreGetOrCreate.mockResolvedValue(createHookResult('new-item'));
+      mockHookRunner.runPreCreate.mockResolvedValue(createHookResult('new-item'));
+      mockCoreService.getOrCreate.mockResolvedValue({ item, created: true });
+
+      const result = await service.getOrCreate('new-item', testUserId, undefined, context);
+
+      expect(mockHookRunner.runPreCreate).toHaveBeenCalled();
+      expect(mockHookRunner.runPostCreate).toHaveBeenCalled();
+      expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+        DismissibleEvents.ITEM_CREATED,
+        expect.anything(),
+      );
+      expect(result.created).toBe(true);
+    });
+  });
+
+  describe('dismiss', () => {
+    it('should run hooks, call core service, and emit ITEM_DISMISSED event', async () => {
+      const item = createTestItem({ id: 'test-item' });
+      const previousItem = createTestItem({ id: 'test-item' });
+      const context = createTestContext();
+
+      mockHookRunner.runPreDismiss.mockResolvedValue(createHookResult('test-item'));
+      mockCoreService.dismiss.mockResolvedValue({ item, previousItem });
+
+      const result = await service.dismiss('test-item', testUserId, context);
+
+      expect(mockHookRunner.runPreDismiss).toHaveBeenCalled();
+      expect(mockCoreService.dismiss).toHaveBeenCalledWith('test-item', testUserId);
+      expect(mockHookRunner.runPostDismiss).toHaveBeenCalled();
+      expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+        DismissibleEvents.ITEM_DISMISSED,
+        expect.anything(),
+      );
+      expect(result.item).toEqual(item);
+    });
+  });
+
+  describe('restore', () => {
+    it('should run hooks, call core service, and emit ITEM_RESTORED event', async () => {
+      const item = createTestItem({ id: 'test-item' });
+      const previousItem = createTestItem({ id: 'test-item' });
+      const context = createTestContext();
+
+      mockHookRunner.runPreRestore.mockResolvedValue(createHookResult('test-item'));
+      mockCoreService.restore.mockResolvedValue({ item, previousItem });
+
+      const result = await service.restore('test-item', testUserId, context);
+
+      expect(mockHookRunner.runPreRestore).toHaveBeenCalled();
+      expect(mockCoreService.restore).toHaveBeenCalledWith('test-item', testUserId);
+      expect(mockHookRunner.runPostRestore).toHaveBeenCalled();
+      expect(mockEventEmitter.emit).toHaveBeenCalledWith(
+        DismissibleEvents.ITEM_RESTORED,
+        expect.anything(),
+      );
+      expect(result.item).toEqual(item);
+    });
+  });
+
+  describe('logging', () => {
+    it('should log debug messages for operations', async () => {
+      const item = createTestItem({ id: 'test-item' });
+      const context = createTestContext();
+
+      mockHookRunner.runPreGetOrCreate.mockResolvedValue(createHookResult('test-item'));
+      mockCoreService.getOrCreate.mockResolvedValue({ item, created: false });
+
+      await service.getOrCreate('test-item', testUserId, undefined, context);
+
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        expect.stringContaining('getOrCreate called'),
+        expect.any(Object),
+      );
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        expect.stringContaining('getOrCreate completed'),
+        expect.any(Object),
+      );
+    });
+  });
+});