@dismissible/nestjs-dismissible 0.0.2-canary.585db17.0

package/src/api/dismissible-item.mapper.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common';
+import { DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
+import { DismissibleItemResponseDto } from './dismissible-item-response.dto';
+
+/**
+ * Mapper for converting domain objects to DTOs.
+ */
+@Injectable()
+export class DismissibleItemMapper {
+  /**
+   * Convert a dismissible item to a response DTO.
+   * Converts Date objects to ISO 8601 strings.
+   */
+  toResponseDto(item: DismissibleItemDto): DismissibleItemResponseDto {
+    const dto = new DismissibleItemResponseDto();
+
+    dto.itemId = item.id;
+    dto.userId = item.userId;
+    dto.createdAt = item.createdAt.toISOString();
+
+    if (item.dismissedAt) {
+      dto.dismissedAt = item.dismissedAt.toISOString();
+    }
+
+    return dto;
+  }
+}

package/src/api/index.ts

@@ -0,0 +1,6 @@
+export * from './use-cases';
+
+export * from './validation';
+
+export * from './dismissible-item.mapper';
+export * from './dismissible-item-response.dto';

package/src/api/use-cases/api-tags.constants.ts

@@ -0,0 +1,4 @@
+/**
+ * API tag constants for Swagger/OpenAPI documentation.
+ */
+export const API_TAG_DISMISSIBLE = 'Dismissible';

package/src/api/use-cases/dismiss/dismiss.controller.spec.ts

@@ -0,0 +1,41 @@
+import { mock } from 'ts-jest-mocker';
+import { DismissController } from './dismiss.controller';
+import { DismissibleService } from '../../../core/dismissible.service';
+import { DismissibleItemMapper } from '../../dismissible-item.mapper';
+import { createTestItem, createTestContext } from '../../../testing/factories';
+import { ResponseService } from '../../../response';
+
+describe('DismissController', () => {
+  let controller: DismissController;
+  let mockService: jest.Mocked<DismissibleService>;
+  let mockResponseService: jest.Mocked<ResponseService>;
+  let mapper: DismissibleItemMapper;
+
+  beforeEach(() => {
+    mockService = mock(DismissibleService);
+    mockResponseService = mock(ResponseService, { failIfMockNotProvided: false });
+    mockResponseService.success.mockImplementation((data) => ({ data }));
+    mapper = new DismissibleItemMapper();
+
+    controller = new DismissController(mockService, mapper, mockResponseService);
+  });
+
+  describe('dismiss', () => {
+    it('should return dismissed item wrapped in data', async () => {
+      const item = createTestItem({
+        id: 'test-item',
+        dismissedAt: new Date(),
+      });
+      const previousItem = createTestItem({ id: 'test-item' });
+      const context = createTestContext();
+
+      mockService.dismiss.mockResolvedValue({ item, previousItem });
+
+      const result = await controller.dismiss('test-user-id', 'test-item', context);
+
+      expect(result.data.itemId).toBe('test-item');
+      expect(mockService.dismiss).toHaveBeenCalledWith('test-item', 'test-user-id', context);
+      expect(mockResponseService.success).toHaveBeenCalled();
+    });
+  });
+});

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

@@ -0,0 +1,62 @@
+import { Controller, Delete, 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, IRequestContext } from '@dismissible/nestjs-dismissible-request';
+import { DismissResponseDto } from './dismiss.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 dismiss dismissible item operations.
+ */
+@ApiTags(API_TAG_DISMISSIBLE)
+@Controller('v1/users/:userId/items')
+export class DismissController {
+  constructor(
+    private readonly dismissibleService: DismissibleService,
+    private readonly mapper: DismissibleItemMapper,
+    private readonly responseService: ResponseService,
+  ) {}
+
+  @Delete(':itemId')
+  @ApiOperation({
+    summary: 'Dismiss an item',
+    description: 'Marks a dismissible item as dismissed.',
+  })
+  @ApiParam({
+    name: 'userId',
+    description: 'User identifier (max length: 32 characters)',
+    example: 'user-123',
+  })
+  @ApiParam({
+    name: 'itemId',
+    description: 'Unique identifier for the dismissible item (max length: 32 characters)',
+    example: 'welcome-banner-v2',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'The dismissed item',
+    type: DismissResponseDto,
+  })
+  @ApiResponse({
+    status: 400,
+    description: 'Item not found or already dismissed',
+  })
+  @ApiResponse({
+    status: 403,
+    description: 'Operation blocked by lifecycle hook',
+  })
+  @UseFilters(HttpExceptionFilter)
+  async dismiss(
+    @UserId() userId: string,
+    @ItemId() itemId: string,
+    @RequestContext() context: IRequestContext,
+  ): Promise<DismissResponseDto> {
+    const result = await this.dismissibleService.dismiss(itemId, userId, context);
+
+    return this.responseService.success(this.mapper.toResponseDto(result.item));
+  }
+}

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

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

package/src/api/use-cases/dismiss/index.ts

@@ -0,0 +1,2 @@
+export * from './dismiss.response.dto';
+export * from './dismiss.controller';

package/src/api/use-cases/get-or-create/get-or-create.controller.spec.ts

@@ -0,0 +1,36 @@
+import { mock } from 'ts-jest-mocker';
+import { GetOrCreateController } from './get-or-create.controller';
+import { DismissibleService } from '../../../core/dismissible.service';
+import { DismissibleItemMapper } from '../../dismissible-item.mapper';
+import { createTestItem, createTestContext } from '../../../testing/factories';
+import { ResponseService } from '../../../response';
+
+describe('GetOrCreateController', () => {
+  let controller: GetOrCreateController;
+  let mockService: jest.Mocked<DismissibleService>;
+  let mockResponseService: jest.Mocked<ResponseService>;
+  let mapper: DismissibleItemMapper;
+
+  beforeEach(() => {
+    mockService = mock(DismissibleService);
+    mockResponseService = mock(ResponseService, { failIfMockNotProvided: false });
+    mockResponseService.success.mockImplementation((data) => ({ data }));
+    mapper = new DismissibleItemMapper();
+
+    controller = new GetOrCreateController(mockService, mapper, mockResponseService);
+  });
+
+  describe('getOrCreate', () => {
+    it('should return item with created flag wrapped in data', async () => {
+      const item = createTestItem({ id: 'test-item' });
+      const context = createTestContext();
+
+      mockService.getOrCreate.mockResolvedValue({ item, created: true });
+
+      const result = await controller.getOrCreate('test-user-id', 'test-item', context);
+
+      expect(result.data.itemId).toBe('test-item');
+      expect(mockResponseService.success).toHaveBeenCalled();
+    });
+  });
+});

package/src/api/use-cases/get-or-create/get-or-create.controller.ts

@@ -0,0 +1,59 @@
+import { Controller, Get, 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, IRequestContext } from '@dismissible/nestjs-dismissible-request';
+import { GetOrCreateResponseDto } from './get-or-create.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 get-or-create dismissible item operations.
+ */
+@ApiTags(API_TAG_DISMISSIBLE)
+@Controller('v1/users/:userId/items')
+export class GetOrCreateController {
+  constructor(
+    private readonly dismissibleService: DismissibleService,
+    private readonly mapper: DismissibleItemMapper,
+    private readonly responseService: ResponseService,
+  ) {}
+
+  @Get(':itemId')
+  @ApiOperation({
+    summary: 'Get or create a dismissible item',
+    description:
+      'Retrieves an existing dismissible item by ID, or creates a new one if it does not exist.',
+  })
+  @ApiParam({
+    name: 'userId',
+    description: 'User identifier (max length: 32 characters)',
+    example: 'user-123',
+  })
+  @ApiParam({
+    name: 'itemId',
+    description: 'Unique identifier for the dismissible item (max length: 32 characters)',
+    example: 'welcome-banner-v2',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'The dismissible item (retrieved or created)',
+    type: GetOrCreateResponseDto,
+  })
+  @ApiResponse({
+    status: 403,
+    description: 'Operation blocked by lifecycle hook',
+  })
+  @UseFilters(HttpExceptionFilter)
+  async getOrCreate(
+    @UserId() userId: string,
+    @ItemId() itemId: string,
+    @RequestContext() context: IRequestContext,
+  ): Promise<GetOrCreateResponseDto> {
+    const result = await this.dismissibleService.getOrCreate(itemId, userId, context);
+
+    return this.responseService.success(this.mapper.toResponseDto(result.item));
+  }
+}

package/src/api/use-cases/get-or-create/get-or-create.response.dto.ts

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

package/src/api/use-cases/get-or-create/index.ts

@@ -0,0 +1,2 @@
+export * from './get-or-create.response.dto';
+export * from './get-or-create.controller';

package/src/api/use-cases/index.ts

@@ -0,0 +1,3 @@
+export * from './get-or-create';
+export * from './dismiss';
+export * from './restore';

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

@@ -0,0 +1,2 @@
+export * from './restore.response.dto';
+export * from './restore.controller';

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

@@ -0,0 +1,41 @@
+import { mock } from 'ts-jest-mocker';
+import { RestoreController } from './restore.controller';
+import { DismissibleService } from '../../../core/dismissible.service';
+import { DismissibleItemMapper } from '../../dismissible-item.mapper';
+import { createTestItem, createTestContext } from '../../../testing/factories';
+import { ResponseService } from '../../../response';
+
+describe('RestoreController', () => {
+  let controller: RestoreController;
+  let mockService: jest.Mocked<DismissibleService>;
+  let mockResponseService: jest.Mocked<ResponseService>;
+  let mapper: DismissibleItemMapper;
+
+  beforeEach(() => {
+    mockService = mock(DismissibleService);
+    mockResponseService = mock(ResponseService, { failIfMockNotProvided: false });
+    mockResponseService.success.mockImplementation((data) => ({ data }));
+    mapper = new DismissibleItemMapper();
+
+    controller = new RestoreController(mockService, mapper, mockResponseService);
+  });
+
+  describe('restore', () => {
+    it('should return restored item wrapped in data', async () => {
+      const item = createTestItem({ id: 'test-item' });
+      const previousItem = createTestItem({
+        id: 'test-item',
+        dismissedAt: new Date(),
+      });
+      const context = createTestContext();
+
+      mockService.restore.mockResolvedValue({ item, previousItem });
+
+      const result = await controller.restore('test-user-id', 'test-item', context);
+
+      expect(result.data.itemId).toBe('test-item');
+      expect(mockService.restore).toHaveBeenCalledWith('test-item', 'test-user-id', context);
+      expect(mockResponseService.success).toHaveBeenCalled();
+    });
+  });
+});

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

@@ -0,0 +1,62 @@
+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, 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/users/:userId/items')
+export class RestoreController {
+  constructor(
+    private readonly dismissibleService: DismissibleService,
+    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 (max length: 32 characters)',
+    example: 'user-123',
+  })
+  @ApiParam({
+    name: 'itemId',
+    description: 'Unique identifier for the dismissible item (max length: 32 characters)',
+    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(
+    @UserId() userId: string,
+    @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

@@ -0,0 +1,7 @@
+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/api/validation/index.ts

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