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

package/src/exceptions/dismissible.exceptions.ts

@@ -0,0 +1,69 @@
+import { HttpException, HttpStatus } from '@nestjs/common';
+
+/**
+ * Error response structure for dismissible exceptions.
+ */
+interface IDismissibleErrorResponse {
+  statusCode: number;
+  error: string;
+  code: string;
+  message: string;
+  itemId?: string;
+}
+
+/**
+ * Base exception class for dismissible errors.
+ */
+abstract class DismissibleException extends HttpException {
+  constructor(message: string, code: string, statusCode: HttpStatus, itemId?: string) {
+    const response: IDismissibleErrorResponse = {
+      statusCode,
+      error: HttpStatus[statusCode].replace(/_/g, ' '),
+      code,
+      message,
+    };
+
+    if (itemId) {
+      response.itemId = itemId;
+    }
+
+    super(response, statusCode);
+  }
+}
+
+/**
+ * Exception thrown when an item is not found.
+ */
+export class ItemNotFoundException extends DismissibleException {
+  constructor(itemId: string) {
+    super(`Item with id "${itemId}" not found`, 'ITEM_NOT_FOUND', HttpStatus.BAD_REQUEST, itemId);
+  }
+}
+
+/**
+ * Exception thrown when trying to dismiss an already dismissed item.
+ */
+export class ItemAlreadyDismissedException extends DismissibleException {
+  constructor(itemId: string) {
+    super(
+      `Item with id "${itemId}" is already dismissed`,
+      'ITEM_ALREADY_DISMISSED',
+      HttpStatus.BAD_REQUEST,
+      itemId,
+    );
+  }
+}
+
+/**
+ * Exception thrown when trying to restore an item that is not dismissed.
+ */
+export class ItemNotDismissedException extends DismissibleException {
+  constructor(itemId: string) {
+    super(
+      `Item with id "${itemId}" is not dismissed`,
+      'ITEM_NOT_DISMISSED',
+      HttpStatus.BAD_REQUEST,
+      itemId,
+    );
+  }
+}

package/src/exceptions/index.ts

@@ -0,0 +1 @@
+export * from './dismissible.exceptions';

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './dismissible.module';
+export * from './request';
+export * from './core';
+export * from './api';
+export * from './utils';
+export * from './events';
+export * from './exceptions';
+export * from './testing';

package/src/request/index.ts

@@ -0,0 +1,2 @@
+export * from './request-context.decorator';
+export * from './request-context.interface';

package/src/request/request-context.decorator.ts

@@ -0,0 +1,14 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { v4 as uuidv4 } from 'uuid';
+import { IRequestContext } from './request-context.interface';
+
+export const RequestContext = createParamDecorator(
+  (_data: unknown, ctx: ExecutionContext): IRequestContext => {
+    const request = ctx.switchToHttp().getRequest();
+    const headers = request.headers;
+
+    return {
+      requestId: headers['x-request-id'] ?? uuidv4(),
+    };
+  },
+);

package/src/request/request-context.interface.ts

@@ -0,0 +1,6 @@
+/**
+ * Request context passed through the dismissible operations.
+ */
+export interface IRequestContext {
+  requestId: string;
+}

package/src/response/dtos/base-response.dto.ts

@@ -0,0 +1,11 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+/**
+ * Base response DTO that wraps all successful API responses
+ */
+export class BaseResponseDto<T> {
+  @ApiProperty({
+    description: 'Response data',
+  })
+  data: T;
+}

package/src/response/dtos/error-response.dto.ts

@@ -0,0 +1,36 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export type IErrorResponseDto = {
+  error: {
+    message: string;
+    code: number;
+  };
+};
+
+/**
+ * DTO representing error details in API responses
+ */
+export class ErrorDetailsDto {
+  @ApiProperty({
+    description: 'Error message',
+    example: 'Item not found',
+  })
+  message: string;
+
+  @ApiProperty({
+    description: 'HTTP status code',
+    example: 404,
+  })
+  code: number;
+}
+
+/**
+ * DTO for error responses
+ */
+export class ErrorResponseDto implements IErrorResponseDto {
+  @ApiProperty({
+    description: 'Error details',
+    type: ErrorDetailsDto,
+  })
+  error: ErrorDetailsDto;
+}

package/src/response/dtos/index.ts

@@ -0,0 +1,3 @@
+export * from './base-response.dto';
+export * from './error-response.dto';
+export * from './success-response.dto';

package/src/response/dtos/success-response.dto.ts

@@ -0,0 +1,34 @@
+import { Type } from '@nestjs/common';
+import { ApiProperty } from '@nestjs/swagger';
+
+export type ISuccessResponseDto<T> = {
+  data: T;
+};
+
+/**
+ * Factory function to create a success response DTO wrapper.
+ *
+ * This allows wrapping any data class in a consistent `{ data: T }` structure
+ * with proper Swagger documentation.
+ *
+ * @example
+ * ```ts
+ * class UserDto {
+ *   @ApiProperty()
+ *   id: string;
+ *
+ *   @ApiProperty()
+ *   name: string;
+ * }
+ *
+ * export class GetUserResponseDto extends SuccessResponseDto(UserDto) {}
+ * ```
+ */
+export function SuccessResponseDto<T extends Type>(dataClass: T) {
+  class SuccessResponse implements ISuccessResponseDto<T> {
+    @ApiProperty({ type: dataClass })
+    data!: InstanceType<T>;
+  }
+
+  return SuccessResponse;
+}

package/src/response/http-exception-filter.ts

@@ -0,0 +1,21 @@
+import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
+import { Response } from 'express';
+import { IErrorResponseDto } from './dtos';
+
+@Catch(HttpException)
+export class HttpExceptionFilter implements ExceptionFilter {
+  catch(exception: HttpException, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const status = exception.getStatus();
+
+    const errorResponse: IErrorResponseDto = {
+      error: {
+        message: exception.message,
+        code: status,
+      },
+    };
+
+    response.status(status).json(errorResponse);
+  }
+}

package/src/response/index.ts

@@ -0,0 +1,4 @@
+export * from './response.module';
+export * from './response.service';
+export * from './http-exception-filter';
+export * from './dtos';

package/src/response/response.module.ts

@@ -0,0 +1,9 @@
+import { Global, Module } from '@nestjs/common';
+import { ResponseService } from './response.service';
+
+@Global()
+@Module({
+  providers: [ResponseService],
+  exports: [ResponseService],
+})
+export class ResponseModule {}

package/src/response/response.service.spec.ts

@@ -0,0 +1,86 @@
+import { ResponseService } from './response.service';
+import { NotFoundException } from '@nestjs/common';
+
+describe('ResponseService', () => {
+  let service: ResponseService;
+
+  beforeEach(() => {
+    // Manually create the service with no dependencies
+    service = new ResponseService();
+  });
+
+  describe('success', () => {
+    it('should return a success response with the provided data', () => {
+      // Arrange
+      const testData = { id: '123', name: 'Test Item' };
+
+      // Act
+      const result = service.success(testData);
+
+      // Assert
+      expect(result).toEqual({
+        data: testData,
+      });
+    });
+
+    it('should work with primitive data types', () => {
+      // Arrange
+      const testString = 'Test String';
+
+      // Act
+      const result = service.success(testString);
+
+      // Assert
+      expect(result).toEqual({
+        data: testString,
+      });
+    });
+
+    it('should work with array data', () => {
+      // Arrange
+      const testArray = [1, 2, 3];
+
+      // Act
+      const result = service.success(testArray);
+
+      // Assert
+      expect(result).toEqual({
+        data: testArray,
+      });
+    });
+
+    it('should handle null data', () => {
+      // Act
+      const result = service.success(null);
+
+      // Assert
+      expect(result).toEqual({
+        data: null,
+      });
+    });
+
+    it('should handle undefined data', () => {
+      // Act
+      const result = service.success(undefined);
+
+      // Assert
+      expect(result).toEqual({
+        data: undefined,
+      });
+    });
+  });
+
+  describe('error', () => {
+    it('should return an error response with the provided message', () => {
+      const errorMessage = new NotFoundException('Not found');
+      const result = service.error(errorMessage);
+
+      expect(result).toEqual({
+        error: {
+          message: 'Not found',
+          code: 404,
+        },
+      });
+    });
+  });
+});

package/src/response/response.service.ts

@@ -0,0 +1,20 @@
+import { HttpException, Injectable } from '@nestjs/common';
+import { IErrorResponseDto, ISuccessResponseDto } from './dtos';
+
+@Injectable()
+export class ResponseService {
+  success<T>(data: T): ISuccessResponseDto<T> {
+    return {
+      data,
+    };
+  }
+
+  error(error: HttpException): IErrorResponseDto {
+    return {
+      error: {
+        message: error.message,
+        code: error.getStatus(),
+      },
+    };
+  }
+}

package/src/testing/factories.ts

@@ -0,0 +1,45 @@
+import { BaseMetadata, DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
+import { DismissibleItemFactory } from '@dismissible/nestjs-dismissible-item';
+import { IRequestContext } from '../request/request-context.interface';
+
+/**
+ * Shared factory instance for test helpers.
+ */
+const testItemFactory = new DismissibleItemFactory();
+
+/**
+ * Create a test dismissible item.
+ */
+export function createTestItem<TMetadata extends BaseMetadata = BaseMetadata>(
+  overrides: Partial<DismissibleItemDto<TMetadata>> = {},
+): DismissibleItemDto<TMetadata> {
+  return testItemFactory.create({
+    id: overrides.id ?? 'test-item-id',
+    createdAt: overrides.createdAt ?? new Date('2024-01-15T10:00:00.000Z'),
+    userId: overrides.userId ?? 'test-user-id',
+    metadata: overrides.metadata,
+    dismissedAt: overrides.dismissedAt,
+  });
+}
+
+/**
+ * Create a test request context.
+ */
+export function createTestContext(overrides: Partial<IRequestContext> = {}): IRequestContext {
+  return {
+    requestId: 'test-request-id',
+    ...overrides,
+  };
+}
+
+/**
+ * Create a dismissed test item.
+ */
+export function createDismissedTestItem<TMetadata extends BaseMetadata = BaseMetadata>(
+  overrides: Partial<DismissibleItemDto<TMetadata>> = {},
+): DismissibleItemDto<TMetadata> {
+  return createTestItem({
+    dismissedAt: new Date('2024-01-15T12:00:00.000Z'),
+    ...overrides,
+  });
+}

package/src/testing/index.ts

@@ -0,0 +1 @@
+export * from './factories';

package/src/utils/date/date.service.spec.ts

@@ -0,0 +1,104 @@
+import { DateService } from './date.service';
+
+describe('DateService', () => {
+  let service: DateService;
+
+  beforeEach(() => {
+    service = new DateService();
+  });
+
+  describe('getNow', () => {
+    it('should return current date', () => {
+      const before = new Date();
+      const result = service.getNow();
+      const after = new Date();
+
+      expect(result).toBeInstanceOf(Date);
+      expect(result.getTime()).toBeGreaterThanOrEqual(before.getTime());
+      expect(result.getTime()).toBeLessThanOrEqual(after.getTime());
+    });
+
+    it('should return a new date instance each time', () => {
+      const date1 = service.getNow();
+      const date2 = service.getNow();
+
+      expect(date1).not.toBe(date2);
+    });
+  });
+
+  describe('parseIso', () => {
+    it('should parse ISO 8601 string to Date', () => {
+      const isoString = '2024-01-15T10:30:00.000Z';
+      const result = service.parseIso(isoString);
+
+      expect(result).toBeInstanceOf(Date);
+      expect(result.toISOString()).toBe(isoString);
+    });
+
+    it('should parse date-only ISO string', () => {
+      const isoString = '2024-01-15';
+      const result = service.parseIso(isoString);
+
+      expect(result).toBeInstanceOf(Date);
+      expect(result.getFullYear()).toBe(2024);
+      expect(result.getMonth()).toBe(0); // January is 0
+      expect(result.getDate()).toBe(15);
+    });
+
+    it('should parse ISO string with timezone offset', () => {
+      const isoString = '2024-01-15T10:30:00+05:00';
+      const result = service.parseIso(isoString);
+
+      expect(result).toBeInstanceOf(Date);
+    });
+
+    it('should handle various ISO formats', () => {
+      const testCases = ['2024-01-15T10:30:00.000Z', '2024-01-15T10:30:00Z', '2024-01-15'];
+
+      testCases.forEach((isoString) => {
+        const result = service.parseIso(isoString);
+        expect(result).toBeInstanceOf(Date);
+        expect(isNaN(result.getTime())).toBe(false);
+      });
+    });
+  });
+
+  describe('toIso', () => {
+    it('should convert Date to ISO 8601 string', () => {
+      const date = new Date('2024-01-15T10:30:00.000Z');
+      const result = service.toIso(date);
+
+      expect(result).toBe('2024-01-15T10:30:00.000Z');
+    });
+
+    it('should produce valid ISO string format', () => {
+      const date = new Date('2024-12-25T23:59:59.999Z');
+      const result = service.toIso(date);
+
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
+      expect(result).toBe('2024-12-25T23:59:59.999Z');
+    });
+
+    it('should handle dates at start of epoch', () => {
+      const date = new Date('1970-01-01T00:00:00.000Z');
+      const result = service.toIso(date);
+
+      expect(result).toBe('1970-01-01T00:00:00.000Z');
+    });
+
+    it('should handle dates in the future', () => {
+      const date = new Date('2099-12-31T23:59:59.999Z');
+      const result = service.toIso(date);
+
+      expect(result).toBe('2099-12-31T23:59:59.999Z');
+    });
+
+    it('should round-trip through parseIso and toIso', () => {
+      const originalIso = '2024-01-15T10:30:00.000Z';
+      const date = service.parseIso(originalIso);
+      const result = service.toIso(date);
+
+      expect(result).toBe(originalIso);
+    });
+  });
+});

package/src/utils/date/date.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+
+/**
+ * Service for date operations.
+ */
+@Injectable()
+export class DateService {
+  getNow(): Date {
+    return new Date();
+  }
+
+  parseIso(isoString: string): Date {
+    return new Date(isoString);
+  }
+
+  toIso(date: Date): string {
+    return date.toISOString();
+  }
+}

package/src/utils/date/index.ts

@@ -0,0 +1 @@
+export * from './date.service';

package/src/utils/dismissible.helper.ts

@@ -0,0 +1,9 @@
+import { Injectable } from '@nestjs/common';
+import { BaseMetadata, DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
+
+@Injectable()
+export class DismissibleHelper {
+  isDismissed<TMetadata extends BaseMetadata>(item: DismissibleItemDto<TMetadata>): boolean {
+    return item.dismissedAt !== undefined && item.dismissedAt !== null;
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './date';
+export * from '../response';
+export * from './dismissible.helper';

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ],
+  "compilerOptions": {
+    "esModuleInterop": true
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "module": "commonjs",
+    "types": ["node", "jest"],
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "ES2021"
+  },
+  "exclude": ["node_modules"],
+  "include": ["src/**/*.ts"]
+}