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

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

@@ -0,0 +1,72 @@
+import { ResponseService } from './response.service';
+import { NotFoundException } from '@nestjs/common';
+
+describe('ResponseService', () => {
+  let service: ResponseService;
+
+  beforeEach(() => {
+    service = new ResponseService();
+  });
+
+  describe('success', () => {
+    it('should return a success response with the provided data', () => {
+      const testData = { id: '123', name: 'Test Item' };
+
+      const result = service.success(testData);
+
+      expect(result).toEqual({
+        data: testData,
+      });
+    });
+
+    it('should work with primitive data types', () => {
+      const testString = 'Test String';
+
+      const result = service.success(testString);
+
+      expect(result).toEqual({
+        data: testString,
+      });
+    });
+
+    it('should work with array data', () => {
+      const testArray = [1, 2, 3];
+
+      const result = service.success(testArray);
+
+      expect(result).toEqual({
+        data: testArray,
+      });
+    });
+
+    it('should handle null data', () => {
+      const result = service.success(null);
+
+      expect(result).toEqual({
+        data: null,
+      });
+    });
+
+    it('should handle undefined data', () => {
+      const result = service.success(undefined);
+
+      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,60 @@
+import { DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
+import { DismissibleItemFactory } from '@dismissible/nestjs-dismissible-item';
+import { IRequestContext } from '@dismissible/nestjs-dismissible-request';
+
+/**
+ * Shared factory instance for test helpers.
+ */
+const testItemFactory = new DismissibleItemFactory();
+
+/**
+ * Create a test dismissible item.
+ */
+export function createTestItem(overrides: Partial<DismissibleItemDto> = {}): DismissibleItemDto {
+  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',
+    dismissedAt: overrides.dismissedAt,
+  });
+}
+
+/**
+ * Create a test request context.
+ */
+export function createTestContext(overrides: Partial<IRequestContext> = {}): IRequestContext {
+  return {
+    requestId: 'test-request-id',
+    headers: {},
+    query: {},
+    params: {},
+    body: {},
+    user: {},
+    ip: '127.0.0.1',
+    method: 'GET',
+    url: '/test',
+    protocol: 'http',
+    secure: false,
+    hostname: 'localhost',
+    port: 3000,
+    path: '/test',
+    search: '',
+    searchParams: {},
+    origin: 'http://localhost:3000',
+    referer: '',
+    userAgent: 'test-agent',
+    ...overrides,
+  };
+}
+
+/**
+ * Create a dismissed test item.
+ */
+export function createDismissedTestItem(
+  overrides: Partial<DismissibleItemDto> = {},
+): DismissibleItemDto {
+  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 { DismissibleItemDto } from '@dismissible/nestjs-dismissible-item';
+
+@Injectable()
+export class DismissibleHelper {
+  isDismissed(item: DismissibleItemDto): 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/src/validation/dismissible-input.dto.ts

@@ -0,0 +1,47 @@
+import { IsNotEmpty, IsString, Matches, MaxLength, MinLength } from 'class-validator';
+
+/**
+ * Validation constants for dismissible input fields.
+ */
+export const VALIDATION_CONSTANTS = {
+  /** Maximum length for userId and itemId */
+  ID_MAX_LENGTH: 64,
+  /** Minimum length for userId and itemId */
+  ID_MIN_LENGTH: 1,
+  /** Pattern for valid userId and itemId (alphanumeric, dash, underscore) */
+  ID_PATTERN: /^[a-zA-Z0-9_-]+$/,
+  /** Human-readable description of the ID pattern */
+  ID_PATTERN_MESSAGE: 'must contain only alphanumeric characters, dashes, and underscores',
+} as const;
+
+/**
+ * DTO for validating dismissible input parameters (userId and itemId).
+ * Used at both controller and service layers for defense in depth.
+ */
+export class DismissibleInputDto {
+  @IsString()
+  @IsNotEmpty({ message: 'itemId is required' })
+  @MinLength(VALIDATION_CONSTANTS.ID_MIN_LENGTH, {
+    message: `itemId must be at least ${VALIDATION_CONSTANTS.ID_MIN_LENGTH} character`,
+  })
+  @MaxLength(VALIDATION_CONSTANTS.ID_MAX_LENGTH, {
+    message: `itemId must be at most ${VALIDATION_CONSTANTS.ID_MAX_LENGTH} characters`,
+  })
+  @Matches(VALIDATION_CONSTANTS.ID_PATTERN, {
+    message: `itemId ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`,
+  })
+  itemId: string;
+
+  @IsString()
+  @IsNotEmpty({ message: 'userId is required' })
+  @MinLength(VALIDATION_CONSTANTS.ID_MIN_LENGTH, {
+    message: `userId must be at least ${VALIDATION_CONSTANTS.ID_MIN_LENGTH} character`,
+  })
+  @MaxLength(VALIDATION_CONSTANTS.ID_MAX_LENGTH, {
+    message: `userId must be at most ${VALIDATION_CONSTANTS.ID_MAX_LENGTH} characters`,
+  })
+  @Matches(VALIDATION_CONSTANTS.ID_PATTERN, {
+    message: `userId ${VALIDATION_CONSTANTS.ID_PATTERN_MESSAGE}`,
+  })
+  userId: string;
+}

package/src/validation/index.ts

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

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.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"]
+}

package/tsconfig.spec.json

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