xcally-nest-library 0.0.35 → 0.0.37-XM3778-bae91

package/src/core/application/__tests__/cached-base.service.spec.ts

@@ -0,0 +1,367 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { Cache } from 'cache-manager';
+import { createHash } from 'crypto';
+import { CachedBaseService } from '../cached-base.service';
+import {
+  CacheConfiguration,
+  InvalidationStrategy,
+  TestMessage,
+  TestCreateMessage,
+  TestUpdateMessage,
+} from './mock-types';
+import { dataResultMock, paginatedResultMock } from './mocks/paginated-result.mock';
+import { paginatedQueryMock } from './mocks/paginated-query.mock';
+import { IBaseService } from '../base.interface';
+
+const mockLoggerService = {
+  debug: jest.fn(),
+  error: jest.fn(),
+  log: jest.fn(),
+};
+
+const mockCacheManager = {
+  get: jest.fn(),
+  set: jest.fn(),
+  mdel: jest.fn(),
+
+  stores: [
+    {
+      iterator: jest.fn(async function* (namespace: string) {
+        yield ['cachedbase:findOne:12345', '{"id":1, "name":"cached"}'];
+        yield ['cachedbase:findAll:all', '{"data":[]}'];
+        yield ['another-service:findAll:all', '{"data":[]}'];
+      }),
+    },
+  ],
+};
+
+const mockService: IBaseService<TestCreateMessage, TestUpdateMessage, TestMessage> = {
+  findOne: jest.fn(),
+  findAll: jest.fn(),
+  getMany: jest.fn(),
+  create: jest.fn(),
+  update: jest.fn(),
+  remove: jest.fn(),
+  count: jest.fn(),
+};
+
+describe('CachedBaseService', () => {
+  let cachedService: CachedBaseService<TestMessage, TestCreateMessage, TestUpdateMessage, TestMessage>;
+  let service: jest.Mocked<IBaseService<TestCreateMessage, TestUpdateMessage, TestMessage>>;
+  let cacheManager: jest.Mocked<Cache>;
+
+  const testId = 1;
+  const testMessage: TestMessage = { id: testId, name: 'Test Entity' };
+  const testCreateDTO: TestCreateMessage = { name: 'Test Entity' };
+  const testUpdateDTO: TestUpdateMessage = { id: testId, name: 'Updated Entity' };
+  const cachedData = JSON.stringify(testMessage);
+
+  const generateHash = (params: any) => createHash('md5').update(JSON.stringify(params)).digest('hex');
+
+  const cacheConfigOnChange: CacheConfiguration = { invalidationStrategy: InvalidationStrategy.OnChange };
+  const cacheConfigTTL: CacheConfiguration = { invalidationStrategy: InvalidationStrategy.TTL };
+
+  const setupModule = async (config: CacheConfiguration) => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {
+          provide: CachedBaseService,
+          useFactory: () =>
+            new CachedBaseService<TestMessage, TestCreateMessage, TestUpdateMessage, TestMessage>(
+              mockLoggerService as any,
+              mockService as unknown as jest.Mocked<IBaseService<TestCreateMessage, TestUpdateMessage, TestMessage>>,
+              mockCacheManager as unknown as jest.Mocked<Cache>,
+              config,
+            ),
+        },
+      ],
+    }).compile();
+
+    cachedService = module.get<CachedBaseService<TestMessage, TestCreateMessage, TestUpdateMessage, TestMessage>>(
+      CachedBaseService,
+    );
+    service = mockService as unknown as jest.Mocked<IBaseService<TestCreateMessage, TestUpdateMessage, TestMessage>>;
+    cacheManager = mockCacheManager as unknown as jest.Mocked<Cache>;
+
+    jest.clearAllMocks();
+  };
+
+  describe('Read operations (findOne, findAll, getMany, count)', () => {
+    beforeEach(async () => {
+      await setupModule(cacheConfigTTL);
+    });
+
+    it('should return cached data on cache hit (findOne)', async () => {
+      // Arrange
+      cacheManager.get.mockResolvedValue(cachedData);
+
+      // Act
+      const result = await cachedService.findOne(testId);
+
+      // Assert
+      expect(cacheManager.get).toHaveBeenCalledWith(
+        `cachedbase:findOne:${generateHash({ id: testId })}`,
+      );
+      expect(service.findOne).not.toHaveBeenCalled();
+      expect(cacheManager.set).not.toHaveBeenCalled();
+      expect(result).toEqual(testMessage);
+    });
+
+    it('should fetch data from service and cache it on cache miss (findOne)', async () => {
+      // Arrange
+      cacheManager.get.mockResolvedValue(undefined);
+      service.findOne.mockResolvedValue(testMessage);
+
+      // Act
+      const result = await cachedService.findOne(testId);
+
+      // Assert
+      expect(cacheManager.get).toHaveBeenCalledTimes(1);
+      expect(service.findOne).toHaveBeenCalledWith(testId);
+      expect(cacheManager.set).toHaveBeenCalledWith(
+        `cachedbase:findOne:${generateHash({ id: testId })}`,
+        cachedData,
+      );
+      expect(result).toEqual(testMessage);
+    });
+
+    it('should return cached data on cache hit (getMany)', async () => {
+      // Arrange
+      cacheManager.get.mockResolvedValue(cachedData);
+
+      // Act
+      const result = await cachedService.getMany(paginatedQueryMock);
+
+      // Assert
+      expect(cacheManager.get).toHaveBeenCalledWith(
+        `cachedbase:getMany:${generateHash(paginatedQueryMock)}`,
+      );
+      expect(service.getMany).not.toHaveBeenCalled();
+      expect(cacheManager.set).not.toHaveBeenCalled();
+      expect(result).toEqual(testMessage);
+    });
+
+    it('should fetch data from service and cache it on cache miss (getMany)', async () => {
+      // Arrange
+      cacheManager.get.mockResolvedValue(undefined);
+      service.getMany.mockResolvedValue(paginatedResultMock as any);
+
+      // Act
+      const result = await cachedService.getMany(paginatedQueryMock);
+
+      // Assert
+      expect(cacheManager.get).toHaveBeenCalledTimes(1);
+      expect(service.getMany).toHaveBeenCalledWith(paginatedQueryMock);
+      expect(cacheManager.set).toHaveBeenCalledWith(
+        `cachedbase:getMany:${generateHash(paginatedQueryMock)}`,
+        JSON.stringify(paginatedResultMock),
+      );
+      expect(result).toEqual(paginatedResultMock);
+    });
+
+    it('should return cached data on cache hit (findAll)', async () => {
+      // Arrange
+      cacheManager.get.mockResolvedValue(JSON.stringify({ data: dataResultMock }));
+
+      // Act
+      const result = await cachedService.findAll();
+
+      // Assert
+      expect(cacheManager.get).toHaveBeenCalledWith(
+        `cachedbase:findAll:all`,
+      );
+      expect(service.findAll).not.toHaveBeenCalled();
+      expect(cacheManager.set).not.toHaveBeenCalled();
+      expect(result).toEqual({ data: dataResultMock });
+    });
+
+    it('should fetch data from service and cache it on cache miss (findAll)', async () => {
+      // Arrange
+      cacheManager.get.mockResolvedValue(undefined);
+      service.findAll.mockResolvedValue({ data: dataResultMock });
+
+      // Act
+      const result = await cachedService.findAll();
+
+      // Assert
+      expect(cacheManager.get).toHaveBeenCalledTimes(1);
+      expect(service.findAll).toHaveBeenCalledWith();
+      expect(cacheManager.set).toHaveBeenCalledWith(
+        `cachedbase:findAll:all`,
+        JSON.stringify({ data: dataResultMock }),
+      );
+      expect(result).toEqual({ data: dataResultMock });
+    });
+
+    it('should fetch data from service when an error occurred retrieving data from cache', async () => {
+      // Arrange
+      cacheManager.get.mockRejectedValue(new Error('Cache not reachable'));
+      service.findAll.mockResolvedValue({ data: dataResultMock });
+
+      // Act
+      const result = await cachedService.findAll();
+
+      // Assert
+      expect(cacheManager.get).toHaveBeenCalledTimes(1);
+      expect(service.findAll).toHaveBeenCalledWith();
+      expect(cacheManager.set).not.toHaveBeenCalled();
+      expect(result).toEqual({ data: dataResultMock });
+    });
+
+    it('should handle getMany correctly (pagination and query hashing)', async () => {
+      // Arrange
+      const stringifiedResult = JSON.stringify(paginatedResultMock);
+      cacheManager.get.mockResolvedValue(undefined);
+      service.getMany.mockResolvedValue(paginatedResultMock as any);
+
+      // Act
+      await cachedService.getMany(paginatedQueryMock);
+
+      // Assert
+      const expectedKey = `cachedbase:getMany:${generateHash(paginatedQueryMock)}`;
+      expect(service.getMany).toHaveBeenCalledWith(paginatedQueryMock);
+      expect(cacheManager.set).toHaveBeenCalledWith(expectedKey, stringifiedResult);
+    });
+
+    it('should return cached data on cache hit (count)', async () => {
+      // Arrange
+      cacheManager.get.mockResolvedValue(JSON.stringify({ count: 42 }));
+
+      // Act
+      const result = await cachedService.count();
+
+      // Assert
+      expect(cacheManager.get).toHaveBeenCalledWith(
+        `cachedbase:count:all`,
+      );
+      expect(service.count).not.toHaveBeenCalled();
+      expect(cacheManager.set).not.toHaveBeenCalled();
+      expect(result).toEqual({ count: 42 });
+    });
+
+    it('should fetch data from service and cache it on cache miss (count)', async () => {
+      // Arrange
+      cacheManager.get.mockResolvedValue(undefined);
+      service.count.mockResolvedValue({ count: 42 });
+
+      // Act
+      const result = await cachedService.count();
+
+      // Assert
+      expect(cacheManager.get).toHaveBeenCalledWith(
+        `cachedbase:count:all`,
+      );
+      expect(service.count).toHaveBeenCalledTimes(1);
+      expect(cacheManager.set).toHaveBeenCalledWith(
+        `cachedbase:count:all`,
+        JSON.stringify({ count: 42 }),
+      );
+      expect(result).toEqual({ count: 42 });
+    });
+  });
+
+  describe('Write operations (create, update, remove)', () => {
+    it('should invalidate cache after create when strategy is OnChange', async () => {
+      // Arrange
+      await setupModule(cacheConfigOnChange);
+      service.create.mockResolvedValue(testMessage);
+
+      // Act
+      const result = await cachedService.create(testCreateDTO);
+
+      // Assert
+      expect(service.create).toHaveBeenCalledWith(testCreateDTO);
+      expect(cacheManager.mdel).toHaveBeenCalledWith([
+        'cachedbase:findOne:12345',
+        'cachedbase:findAll:all',
+      ]);
+      expect(result).toEqual(testMessage);
+    });
+
+    it('should invalidate cache after update when strategy is OnChange', async () => {
+      // Arrange
+      await setupModule(cacheConfigOnChange);
+      service.update.mockResolvedValue(testUpdateDTO);
+
+      // Act
+      const result = await cachedService.update(testUpdateDTO);
+
+      // Assert
+      expect(service.update).toHaveBeenCalledWith(testUpdateDTO);
+      expect(cacheManager.mdel).toHaveBeenCalledWith([
+        'cachedbase:findOne:12345',
+        'cachedbase:findAll:all',
+      ]);
+      expect(result).toEqual(testUpdateDTO);
+    });
+
+    it('should invalidate cache after remove when strategy is OnChange', async () => {
+      await setupModule(cacheConfigOnChange);
+      service.remove.mockResolvedValue();
+
+      await cachedService.remove(testId);
+
+      expect(service.remove).toHaveBeenCalledWith(testId);
+      expect(cacheManager.mdel).toHaveBeenCalledWith([
+        'cachedbase:findOne:12345',
+        'cachedbase:findAll:all',
+      ]);
+    });
+
+    it('should not invalidate cache after create when strategy is TTL', async () => {
+      // Arrange
+      await setupModule(cacheConfigTTL);
+      service.create.mockResolvedValue(testMessage);
+
+      // Act
+      const result = await cachedService.create(testCreateDTO);
+
+      // Assert
+      expect(service.create).toHaveBeenCalledWith(testCreateDTO);
+      expect(cacheManager.mdel).not.toHaveBeenCalled();
+      expect(result).toEqual(testMessage);
+    });
+
+    it('should not invalidate cache after update when strategy is TTL', async () => {
+      // Arrange
+      await setupModule(cacheConfigTTL);
+      service.update.mockResolvedValue(testUpdateDTO);
+
+      // Act
+      const result = await cachedService.update(testUpdateDTO);
+
+      // Assert
+      expect(service.update).toHaveBeenCalledWith(testUpdateDTO);
+      expect(cacheManager.mdel).not.toHaveBeenCalled();
+      expect(result).toEqual(testUpdateDTO);
+    });
+
+    it('should not invalidate cache after remove when strategy is TTL', async () => {
+      await setupModule(cacheConfigTTL);
+      service.remove.mockResolvedValue();
+
+      await cachedService.remove(testId);
+
+      expect(service.remove).toHaveBeenCalledWith(testId);
+      expect(cacheManager.mdel).not.toHaveBeenCalled();
+    });
+  });
+
+  it('should return data in case of error while invalidating cache when strategy is OnChange', async () => {
+    // Arrange
+    await setupModule(cacheConfigOnChange);
+    service.create.mockResolvedValue(testMessage);
+    cacheManager.mdel.mockRejectedValue(new Error('Cannot delete data from cache'));
+
+    // Act
+    const result = await cachedService.create(testCreateDTO);
+
+    // Assert
+    expect(service.create).toHaveBeenCalledWith(testCreateDTO);
+    expect(cacheManager.mdel).toHaveBeenCalledWith([
+      'cachedbase:findOne:12345',
+      'cachedbase:findAll:all',
+    ]);
+    expect(result).toEqual(testMessage);
+  });
+});

package/src/core/application/__tests__/mock-types.ts

@@ -0,0 +1,73 @@
+import { Paginated } from 'nestjs-paginate';
+
+/** Definizioni di tipi mock */
+
+// Mock semplice per la paginazione di nestjs-paginate
+export type MockPaginateQuery = PaginateQuery;
+export type MockPaginated<T> = Paginated<T>;
+
+// Interfaccia del servizio base (sotto il caching)
+export interface IBaseService<CreateMessage, UpdateMessage extends { id: number | string }, Message> {
+  findOne(id: number | string): Promise<Message>;
+  findAll(): Promise<{ data: Message[] }>;
+  getMany(query?: MockPaginateQuery): Promise<PaginatedServiceMessage | Promise<PaginatedServiceMessage>>;
+  create(createDTO: CreateMessage): Promise<Message>;
+  update(updateDTO: UpdateMessage): Promise<Message>;
+  remove(id: number | string): Promise<void>;
+  count(options?: any): Promise<{ count: number }>;
+}
+
+// Configurazione della cache
+export enum InvalidationStrategy {
+  OnChange = 'OnChange',
+  TTL = 'TTL',
+  // Potresti aggiungere altri metodi (es. TTL)
+}
+
+export interface CacheConfiguration {
+  invalidationStrategy: InvalidationStrategy;
+}
+
+// Struttura dei messaggi
+export interface TestMessage {
+  id: number;
+  name: string;
+}
+
+export interface TestCreateMessage {
+  name: string;
+}
+
+export interface TestUpdateMessage extends TestCreateMessage {
+  id: number;
+}
+
+export interface ServiceMessage {
+  id: number;
+  name?: string | undefined;
+  description?: string | undefined;
+  createdAt?: string | undefined;
+  updatedAt?: string | undefined;
+}
+
+export interface PaginatedServiceMessage {
+  data: ServiceMessage[];
+  meta: { [key: string]: any } | undefined;
+  links: { [key: string]: any } | undefined;
+}
+
+export interface PaginateQuery {
+    page?: number;
+    limit?: number;
+    sortBy?: [string, string][];
+    searchBy?: string[];
+    search?: string;
+    filter?: {
+        [column: string]: string | string[];
+    };
+    select?: string[];
+    cursor?: string;
+    cursorColumn?: string;
+    cursorDirection?: 'before' | 'after';
+    path: string;
+}

package/src/core/application/__tests__/mocks/paginated-query.mock.ts

@@ -0,0 +1,10 @@
+import { PaginateQuery } from "../mock-types";
+
+export const paginatedQueryMock: PaginateQuery = {
+  limit: 20,
+  page: 1,
+  sortBy: [
+    ['id', 'ASC'],
+  ],
+  path: '',
+};

package/src/core/application/__tests__/mocks/paginated-result.mock.ts

@@ -0,0 +1,166 @@
+export const dataResultMock = [
+    {
+        "id": 1,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "CHOICE",
+        "description": "variable for menu auto generated"
+    },
+    {
+        "id": 2,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "ORDERNUM",
+        "description": "variable for order auto generated"
+    },
+    {
+        "id": 3,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "DBRESULT",
+        "description": "variable for db query result auto generated"
+    },
+    {
+        "id": 4,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "RATE",
+        "description": "variable for rate call auto generated"
+    },
+    {
+        "id": 5,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "CALLERID(dnid)",
+        "description": "variable dialed number identifier auto generated"
+    },
+    {
+        "id": 6,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "CALLERID(name)",
+        "description": "variable name of the caller auto generated"
+    },
+    {
+        "id": 7,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "CALLERID(num)",
+        "description": "variable number of the caller auto generated"
+    },
+    {
+        "id": 8,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "CHANNEL(language)",
+        "description": "variable select a natural language file when available auto generated"
+    },
+    {
+        "id": 9,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "COUNTER",
+        "description": "variable auto generated"
+    },
+    {
+        "id": 10,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "EMAIL",
+        "description": "variable auto generated"
+    },
+    {
+        "id": 11,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "EXTRAVAR",
+        "description": "variable useful for agent popup auto generated"
+    },
+    {
+        "id": 12,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "FIRSTNAME",
+        "description": "variable auto generated"
+    },
+    {
+        "id": 13,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "LASTNAME",
+        "description": "variable auto generated"
+    },
+    {
+        "id": 14,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "INPUT",
+        "description": "variable auto generated"
+    },
+    {
+        "id": 15,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "OPTION",
+        "description": "variable auto generated"
+    },
+    {
+        "id": 16,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "ORDER",
+        "description": "variable auto generated"
+    },
+    {
+        "id": 17,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "PHONE",
+        "description": "variable auto generated"
+    },
+    {
+        "id": 18,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "RESULT",
+        "description": "variable auto generated"
+    },
+    {
+        "id": 19,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "UNIQUEID",
+        "description": "variable current call unique identifier auto generated"
+    },
+    {
+        "id": 20,
+        "createdAt": "2023-02-06T10:57:24.000Z",
+        "updatedAt": "2023-02-06T10:57:24.000Z",
+        "name": "VAR1",
+        "description": "generic variable auto generated"
+    }
+  ];
+
+export const paginatedResultMock = {
+  "meta": {
+      "itemsPerPage": 20,
+      "totalItems": 25,
+      "currentPage": 1,
+      "totalPages": 2,
+      "sortBy": [
+          [
+              "id",
+              "ASC"
+          ]
+      ],
+      "searchBy": "",
+      "search": "",
+      "select": "",
+  },
+  "links": {
+      "current": "/api/v2/variables?page=1&limit=20&sortBy=id:ASC",
+      "next": "/api/v2/variables?page=2&limit=20&sortBy=id:ASC",
+      "last": "/api/v2/variables?page=2&limit=20&sortBy=id:ASC"
+  },
+  "data": dataResultMock,
+};

package/src/core/application/base.interface.ts

@@ -1,16 +1,15 @@
 import { Paginated, PaginateQuery } from 'nestjs-paginate';
 
 export interface IBaseService<
-  Entity,
-  CreateMessage extends Partial<Entity>,
-  UpdateMessage extends Partial<Entity> & { id: number },
+  CreateMessage,
+  UpdateMessage extends { id: number | string },
   Message,
 > {
-  findOne(id: number): Promise<Message>;
+  findOne(id: number | string): Promise<Message>;
   findAll(): Promise<{ data: Message[] }>;
   getMany(query?: PaginateQuery): Promise<Paginated<Message>>;
   create(createDTO: CreateMessage): Promise<Message>;
   update(updateDTO: UpdateMessage): Promise<Message>;
-  remove(id: number): Promise<void>;
+  remove(id: number | string): Promise<void>;
   count(options?: any): Promise<{ count: number }>;
 }

package/src/core/application/base.mongo.interface.ts

@@ -0,0 +1,15 @@
+import { Paginated, PaginateQuery } from 'nestjs-paginate';
+
+export interface IBaseMongoService<
+  CreateMessage,
+  UpdateMessage extends { id: string },
+  Message,
+> {
+  findOne(id: string): Promise<Message>;
+  findAll(): Promise<{ data: Message[] }>;
+  getMany(query?: PaginateQuery): Promise<Paginated<Message>>;
+  create(createDTO: CreateMessage): Promise<Message>;
+  update(updateDTO: UpdateMessage): Promise<Message>;
+  remove(id: string): Promise<void>;
+  count(options?: any): Promise<{ count: number }>;
+}