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

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

@@ -1,63 +0,0 @@
-import { Controller, Post, Param, 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 { 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';
-
-/**
- * Controller for restore dismissible item operations.
- */
-@ApiTags(API_TAG_DISMISSIBLE)
-@Controller('v1/user/:userId/dismissible-item')
-export class RestoreController {
-  constructor(
-    private readonly dismissibleService: DismissibleService<BaseMetadata>,
-    private readonly mapper: DismissibleItemMapper,
-    private readonly responseService: ResponseService,
-  ) {}
-
-  @Post(':itemId')
-  @ApiOperation({
-    summary: 'Restore a dismissed item',
-    description: 'Restores a previously dismissed item.',
-  })
-  @ApiParam({
-    name: 'userId',
-    description: 'User identifier',
-    example: 'user-123',
-  })
-  @ApiParam({
-    name: 'itemId',
-    description: 'Unique identifier for the dismissible item',
-    example: 'welcome-banner-v2',
-  })
-  @ApiResponse({
-    status: 200,
-    description: 'The restored item',
-    type: RestoreResponseDto,
-  })
-  @ApiResponse({
-    status: 400,
-    description: 'Item not found or not dismissed',
-  })
-  @ApiResponse({
-    status: 403,
-    description: 'Operation blocked by lifecycle hook',
-  })
-  @UseFilters(HttpExceptionFilter)
-  async restore(
-    @Param('userId') userId: string,
-    @Param('itemId') itemId: string,
-    @RequestContext() context: IRequestContext,
-  ): Promise<RestoreResponseDto> {
-    const result = await this.dismissibleService.restore(itemId, userId, context);
-
-    return this.responseService.success(this.mapper.toResponseDto(result.item));
-  }
-}

package/src/api/use-cases/restore/restore.response.dto.ts

@@ -1,7 +0,0 @@
-import { SuccessResponseDto } from '../../../response/dtos/success-response.dto';
-import { DismissibleItemResponseDto } from '../../dismissible-item-response.dto';
-
-/**
- * Response DTO for the restore operation.
- */
-export class RestoreResponseDto extends SuccessResponseDto(DismissibleItemResponseDto) {}

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/core/dismissible-core.service.spec.ts

@@ -1,357 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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,
-    };
-  }
-}