@tomei/media 0.8.11-dev.1 → 0.10.1-test.1

package/src/__tests__/medias.spec.ts

@@ -0,0 +1,468 @@
+// Environment variables must be set before any module is loaded
+process.env.MEDIA_STORAGE_TYPE = 'local';
+process.env.MEDIA_LOCAL_STORAGE_PATH = '/tmp/media-test';
+process.env.MEDIA_ENCRYPT_KEY = '12345678901234567890123456789012'; // 32 bytes for AES-256
+
+jest.mock('@tomei/general', () => ({
+  ObjectBase: class ObjectBase {},
+}));
+
+jest.mock('@nestjs/swagger', () => ({
+  ApiProperty: () => () => {},
+  ApiPropertyOptional: () => () => {},
+}));
+
+jest.mock('sequelize-typescript', () => ({
+  Table: () => () => {},
+  Column: () => () => {},
+  Model: class Model {
+    static findByPk = jest.fn();
+    static findOne = jest.fn();
+    static findAll = jest.fn();
+    static findAndCountAll = jest.fn();
+    static create = jest.fn();
+    get = jest.fn();
+    update = jest.fn();
+    destroy = jest.fn();
+  },
+  DataType: {
+    STRING: 'STRING',
+    TEXT: 'TEXT',
+    DATE: 'DATE',
+    BOOLEAN: 'BOOLEAN',
+    ENUM: () => 'ENUM',
+  },
+  PrimaryKey: () => () => {},
+  ForeignKey: () => () => {},
+  BelongsTo: () => () => {},
+  HasMany: () => () => {},
+  CreatedAt: () => () => {},
+  UpdatedAt: () => () => {},
+  Default: () => () => {},
+  AllowNull: () => () => {},
+}));
+
+jest.mock('@nestjs/common', () => ({
+  BadRequestException: class BadRequestException extends Error {
+    constructor(msg: string) {
+      super(msg);
+      this.name = 'BadRequestException';
+    }
+  },
+  NotFoundException: class NotFoundException extends Error {
+    constructor(msg: string) {
+      super(msg);
+      this.name = 'NotFoundException';
+    }
+  },
+  Injectable: () => (t: any) => t,
+}));
+
+jest.mock('@tomei/activity-history', () => ({
+  Activity: jest.fn().mockImplementation(() => ({
+    create: jest.fn().mockResolvedValue(undefined),
+    createId: jest.fn().mockReturnValue('activity-id'),
+    ActivityId: '',
+    Action: '',
+    Description: '',
+    EntityType: '',
+    EntityId: '',
+    EntityValueBefore: '',
+    EntityValueAfter: '',
+  })),
+  ActionEnum: { CREATE: 'Create', UPDATE: 'Update', DELETE: 'Delete' },
+}));
+
+jest.mock('@tomei/sso', () => ({
+  LoginUser: jest.fn(),
+}));
+
+jest.mock('@paralleldrive/cuid2', () => ({
+  createId: jest.fn().mockReturnValue('test-media-id'),
+}));
+
+// Variables prefixed with "mock" are hoisted by ts-jest alongside jest.mock()
+const mockRepoMethods = {
+  create: jest.fn(),
+  findOne: jest.fn(),
+  findAll: jest.fn(),
+  findAndCountAll: jest.fn(),
+};
+
+jest.mock('../medias.repository', () => ({
+  MediasRepository: jest.fn().mockImplementation(() => mockRepoMethods),
+}));
+
+const mockUploadData = jest.fn().mockResolvedValue({});
+const mockDeleteIfExists = jest.fn().mockResolvedValue({});
+const mockDownload = jest.fn();
+const mockGetBlockBlobClient = jest.fn().mockReturnValue({
+  uploadData: mockUploadData,
+  download: mockDownload,
+  deleteIfExists: mockDeleteIfExists,
+});
+const mockGetContainerClient = jest.fn().mockReturnValue({
+  getBlockBlobClient: mockGetBlockBlobClient,
+});
+
+jest.mock('@azure/storage-blob', () => ({
+  BlobServiceClient: {
+    fromConnectionString: jest.fn().mockReturnValue({
+      getContainerClient: mockGetContainerClient,
+    }),
+  },
+}));
+
+jest.mock('sequelize', () => ({
+  Op: { substring: Symbol('Op.substring') },
+}));
+
+jest.mock('fs');
+
+import * as fs from 'fs';
+import { Medias } from '../medias';
+import { MediaType } from '../enum/medias.enum';
+import { Readable } from 'stream';
+
+const mockedFs = fs as jest.Mocked<typeof fs>;
+
+const makeLoginUser = () => ({ ObjectId: 'user-001' }) as any;
+
+const makeMediaAttr = (overrides: Partial<any> = {}) => ({
+  MediaId: 'media-001',
+  ObjectId: 'obj-001',
+  ObjectType: 'Rental',
+  Title: 'Test File',
+  Description: 'A test file',
+  Type: MediaType.Photo,
+  IsExternalYN: 'N',
+  ExternalSource: '',
+  IsEncryptedYN: 'N',
+  FileName: 'testfile',
+  FileExtension: 'jpg',
+  FilePath: '/tmp/media-test/Rental/obj-001/testfile.jpg',
+  URL: '/tmp/media-test/Rental/obj-001',
+  CreatedById: 'user-001',
+  CreatedAt: new Date('2026-01-01'),
+  UpdatedById: 'user-001',
+  UpdatedAt: new Date('2026-01-01'),
+  ...overrides,
+});
+
+const makeMockModel = (attr: any = makeMediaAttr()) => ({
+  get: jest.fn().mockReturnValue(attr),
+  update: jest.fn().mockResolvedValue({ get: jest.fn().mockReturnValue(attr) }),
+  destroy: jest.fn().mockResolvedValue(undefined),
+  CollectionId: 1,
+  ...attr,
+});
+
+describe('Medias', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockRepoMethods.create.mockResolvedValue(makeMockModel());
+    mockRepoMethods.findOne.mockResolvedValue(makeMockModel());
+    mockRepoMethods.findAll.mockResolvedValue([makeMockModel()]);
+    mockRepoMethods.findAndCountAll.mockResolvedValue({
+      count: 1,
+      rows: [makeMockModel()],
+    });
+  });
+
+  // ── Constructor ────────────────────────────────────────────────────────────
+
+  describe('constructor', () => {
+    it('creates an instance without media attributes', () => {
+      const medias = new Medias();
+      expect(medias).toBeInstanceOf(Medias);
+    });
+
+    it('creates an instance with media attributes', () => {
+      const medias = new Medias(undefined, makeMediaAttr());
+      expect(medias.Title).toBe('Test File');
+      // ObjectType class field 'Media' is applied after super()/init(), so it takes precedence
+      expect(medias.ObjectType).toBe('Media');
+    });
+
+    it('throws when storage type is azure but container is missing', () => {
+      process.env.MEDIA_STORAGE_TYPE = 'azure';
+      delete process.env.MEDIA_AZUREBLOB_CONTAINER_NAME;
+      expect(() => new Medias()).toThrow();
+      process.env.MEDIA_STORAGE_TYPE = 'local';
+    });
+  });
+
+  // ── BaseMedias: createSaveLocation ─────────────────────────────────────────
+
+  describe('createSaveLocation', () => {
+    it('returns local path when MEDIA_STORAGE_TYPE is local', () => {
+      const medias = new Medias(undefined, makeMediaAttr());
+      const location = medias.createSaveLocation();
+      // ObjectType class field overrides init(), so ObjectType is 'Media'
+      expect(location).toBe('/tmp/media-test/Media/obj-001');
+    });
+
+    it('throws when no storage path env var is set', () => {
+      const saved = process.env.MEDIA_LOCAL_STORAGE_PATH;
+      delete process.env.MEDIA_LOCAL_STORAGE_PATH;
+      const medias = new Medias();
+      medias.ObjectType = 'Test';
+      medias.ObjectId = 'id';
+      expect(() => medias.createSaveLocation()).toThrow();
+      process.env.MEDIA_LOCAL_STORAGE_PATH = saved;
+    });
+  });
+
+  // ── encrypt / decrypt ──────────────────────────────────────────────────────
+
+  describe('encrypt', () => {
+    it('returns an encrypted buffer with iv', async () => {
+      const medias = new Medias();
+      const plaintext = Buffer.from('hello world');
+      const result = await medias.encrypt(plaintext);
+      expect(result.isEncrypted).toBe(true);
+      expect(result.buffer).not.toEqual(plaintext);
+      expect(result.iv).toHaveLength(16);
+    });
+
+    it('throws when MEDIA_ENCRYPT_KEY is not set', async () => {
+      const saved = process.env.MEDIA_ENCRYPT_KEY;
+      delete process.env.MEDIA_ENCRYPT_KEY;
+      const medias = new Medias();
+      await expect(medias.encrypt(Buffer.from('test'))).rejects.toThrow();
+      process.env.MEDIA_ENCRYPT_KEY = saved;
+    });
+  });
+
+  describe('decrypt', () => {
+    it('round-trips correctly with encrypt', async () => {
+      const medias = new Medias();
+      const plaintext = Buffer.from('secret message');
+      const encrypted = await medias.encrypt(plaintext);
+      const decrypted = await medias.decrypt(encrypted);
+      expect(decrypted.buffer.toString()).toBe('secret message');
+      expect(decrypted.isEncrypted).toBe(false);
+    });
+  });
+
+  // ── getAll ─────────────────────────────────────────────────────────────────
+
+  describe('getAll', () => {
+    it('returns paginated results', async () => {
+      const medias = new Medias();
+      const result = await medias.getAll(10, 1, '');
+      expect(result).toEqual({ count: 1, rows: expect.any(Array) });
+      expect(mockRepoMethods.findAndCountAll).toHaveBeenCalled();
+    });
+
+    it('applies search filter when search string is provided', async () => {
+      const medias = new Medias();
+      await medias.getAll(10, 1, '{"Title":"test"}');
+      expect(mockRepoMethods.findAndCountAll).toHaveBeenCalledWith(
+        expect.objectContaining({ where: expect.any(Object) }),
+      );
+    });
+
+    it('throws BadRequestException for invalid search JSON', async () => {
+      const medias = new Medias();
+      await expect(medias.getAll(10, 1, '{bad json')).rejects.toThrow();
+    });
+  });
+
+  // ── getOne ─────────────────────────────────────────────────────────────────
+
+  describe('getOne', () => {
+    it('returns the media model when found', async () => {
+      const medias = new Medias();
+      const result = await medias.getOne('media-001');
+      expect(result).toBeDefined();
+    });
+
+    it('throws NotFoundException when not found', async () => {
+      mockRepoMethods.findOne.mockResolvedValue(null);
+      const medias = new Medias();
+      await expect(medias.getOne('missing-id')).rejects.toThrow();
+    });
+  });
+
+  // ── getFile ────────────────────────────────────────────────────────────────
+
+  describe('getFile', () => {
+    it('returns file buffer and response options for a local unencrypted file', async () => {
+      const fileContent = Buffer.from('file-data');
+      const stream = Readable.from([fileContent]);
+      mockedFs.createReadStream = jest.fn().mockReturnValue(stream);
+
+      const medias = new Medias();
+      const result = await medias.getFile('media-001');
+
+      expect(result).toHaveProperty('fileBuffer');
+      expect(result).toHaveProperty('resOption');
+      expect(result.resOption['Content-Type']).toBe('application/octet-stream');
+    });
+
+    it('throws NotFoundException when media record is not found', async () => {
+      mockRepoMethods.findOne.mockResolvedValue(null);
+      const medias = new Medias();
+      await expect(medias.getFile('missing-id')).rejects.toThrow();
+    });
+  });
+
+  // ── postExternal ───────────────────────────────────────────────────────────
+
+  describe('postExternal', () => {
+    it('creates an external media record', async () => {
+      const loginUser = makeLoginUser();
+      const dto = {
+        ObjectId: 'obj-001',
+        ObjectType: 'Rental',
+        Title: 'External Image',
+        Description: 'Hosted externally',
+        Type: MediaType.Photo,
+        IsEncryptedYN: 'N',
+        ExternalSource: 'http://example.com/img.jpg',
+        URL: 'http://example.com/img.jpg',
+      } as any;
+
+      const medias = new Medias();
+      const result = await medias.postExternal(dto, loginUser);
+      expect(result.IsExternalYN).toBe('Y');
+      expect(result.MediaId).toBeDefined();
+    });
+  });
+
+  // ── postInternal ───────────────────────────────────────────────────────────
+
+  describe('postInternal', () => {
+    it('creates an internal media record for local storage', async () => {
+      const loginUser = makeLoginUser();
+      const fileStream = { buffer: Buffer.from('file-bytes') } as any;
+      const dto = {
+        ObjectId: 'obj-001',
+        ObjectType: 'Rental',
+        Title: 'Internal File',
+        Description: 'Stored locally',
+        Type: MediaType.Document,
+        IsEncryptedYN: 'N',
+        FileName: 'report',
+        FileExtension: 'pdf',
+      } as any;
+
+      mockedFs.exists = jest.fn((_p, cb) => cb(null, true)) as any;
+      mockedFs.writeFile = jest.fn((_p, _d, cb) => cb(null)) as any;
+
+      const medias = new Medias();
+      const result = await medias.postInternal(fileStream, dto, loginUser);
+      expect(result).toBeDefined();
+      expect(mockRepoMethods.create).toHaveBeenCalled();
+    });
+  });
+
+  // ── remove ─────────────────────────────────────────────────────────────────
+
+  describe('remove', () => {
+    it('deletes the media and returns success message', async () => {
+      mockedFs.existsSync = jest.fn().mockReturnValue(false);
+
+      const medias = new Medias();
+      const loginUser = makeLoginUser();
+      const result = await medias.remove('media-001', loginUser);
+      expect(result).toEqual({ message: 'Media has been deleted.' });
+    });
+
+    it('throws NotFoundException when media is not found', async () => {
+      mockRepoMethods.findOne.mockResolvedValue(null);
+      const medias = new Medias();
+      await expect(medias.remove('bad-id', makeLoginUser())).rejects.toThrow();
+    });
+  });
+
+  // ── putExternal ────────────────────────────────────────────────────────────
+
+  describe('putExternal', () => {
+    it('updates an external media record', async () => {
+      // putExternal passes null loginUser to updateMedias; make model.update()
+      // return null so the activity block (which reads loginUser.ObjectId) is skipped
+      const nullUpdateModel = {
+        ...makeMockModel(),
+        update: jest.fn().mockResolvedValue(null),
+      };
+      mockRepoMethods.findOne.mockResolvedValue(nullUpdateModel);
+      const medias = new Medias();
+      const result = await medias.putExternal(
+        'media-001',
+        { Title: 'Updated Title' } as any,
+        'user-001',
+      );
+      expect(result).toBeNull();
+    });
+
+    it('throws NotFoundException when not found', async () => {
+      mockRepoMethods.findOne.mockResolvedValue(null);
+      const medias = new Medias();
+      await expect(
+        medias.putExternal('bad-id', {} as any, 'user-001'),
+      ).rejects.toThrow();
+    });
+  });
+
+  // ── putInternal ────────────────────────────────────────────────────────────
+
+  describe('putInternal', () => {
+    it('updates an internal media record for local storage', async () => {
+      const loginUser = makeLoginUser();
+      const fileStream = { buffer: Buffer.from('updated-bytes') } as any;
+
+      mockedFs.exists = jest.fn((_p, cb) => cb(null, true)) as any;
+      mockedFs.unlinkSync = jest.fn();
+      mockedFs.writeFile = jest.fn((_p, _d, cb) => cb(null)) as any;
+
+      const medias = new Medias();
+      const result = await medias.putInternal(
+        fileStream,
+        'media-001',
+        { FileName: 'newfile', FileExtension: 'pdf' } as any,
+        loginUser,
+      );
+      expect(result).toBeDefined();
+    });
+
+    it('throws NotFoundException when not found', async () => {
+      mockRepoMethods.findOne.mockResolvedValue(null);
+      const medias = new Medias();
+      await expect(
+        medias.putInternal({} as any, 'bad-id', {} as any, makeLoginUser()),
+      ).rejects.toThrow();
+    });
+  });
+
+  // ── findFile (Azure fallback) ───────────────────────────────────────────────
+
+  describe('findFile via Azure storage', () => {
+    beforeEach(() => {
+      process.env.MEDIA_STORAGE_TYPE = 'azure';
+      process.env.MEDIA_AZUREBLOB_CONTAINER_NAME = 'test-container';
+    });
+
+    afterEach(() => {
+      process.env.MEDIA_STORAGE_TYPE = 'local';
+      delete process.env.MEDIA_AZUREBLOB_CONTAINER_NAME;
+    });
+
+    it('downloads a file from Azure blob storage', async () => {
+      const fileBuffer = Buffer.from('azure-file-content');
+      const readable = Readable.from([fileBuffer]);
+      mockDownload.mockResolvedValue({ readableStreamBody: readable });
+
+      const medias = new Medias(
+        undefined,
+        makeMediaAttr({ URL: '/azure/Rental/obj-001' }),
+      );
+      medias.IsEncryptedYN = 'N';
+
+      const result = await medias.findFile();
+      expect(result).toBeInstanceOf(Buffer);
+      expect(mockGetContainerClient).toHaveBeenCalled();
+    });
+  });
+});

package/src/__tests__/pipes.spec.ts

@@ -0,0 +1,154 @@
+jest.mock('@nestjs/common', () => ({
+  BadRequestException: class BadRequestException extends Error {
+    constructor(message: string) {
+      super(message);
+      this.name = 'BadRequestException';
+    }
+  },
+  Injectable: () => (target: any) => target,
+  PipeTransform: class {},
+}));
+
+jest.mock('class-validator', () => ({
+  isDefined: (v: any) => v !== undefined && v !== null,
+  isEnum: (value: any, entity: any) => Object.values(entity).includes(value),
+}));
+
+jest.mock('@paralleldrive/cuid2', () => ({
+  createId: jest.fn().mockReturnValue('generated-cuid'),
+  isCuid: jest.fn((v: string) => v === 'valid-cuid-value'),
+}));
+
+import { AppendIdPipe } from '../pipe/append-id.pipe';
+import { ValidateEnumPipe } from '../pipe/validate-enum.pipe';
+import { ValidateIdPipe } from '../pipe/validate-id.pipe';
+import { ValidateSearchPipe } from '../pipe/validate-search.pipe';
+
+enum TestEnum {
+  Photo = 'Photo',
+  Video = 'Video',
+  Document = 'Document',
+}
+
+describe('AppendIdPipe', () => {
+  let pipe: AppendIdPipe;
+
+  beforeEach(() => {
+    pipe = new AppendIdPipe('MediaId');
+  });
+
+  it('appends the named id field to the value', () => {
+    const result = pipe.transform({ Title: 'Test' });
+    expect(result).toEqual({ Title: 'Test', MediaId: 'generated-cuid' });
+  });
+
+  it('preserves existing fields', () => {
+    const result = pipe.transform({ a: 1, b: 2 });
+    expect(result.a).toBe(1);
+    expect(result.b).toBe(2);
+    expect(result.MediaId).toBe('generated-cuid');
+  });
+
+  it('works with an empty object', () => {
+    const result = pipe.transform({});
+    expect(result).toHaveProperty('MediaId', 'generated-cuid');
+  });
+});
+
+describe('ValidateEnumPipe', () => {
+  let pipe: ValidateEnumPipe;
+
+  beforeEach(() => {
+    pipe = new ValidateEnumPipe(TestEnum);
+  });
+
+  it('returns the enum value when valid', () => {
+    const result = pipe.transform('Photo');
+    expect(result).toBe('Photo');
+  });
+
+  it('throws BadRequestException for an invalid enum value', () => {
+    expect(() => pipe.transform('Invalid')).toThrow();
+  });
+
+  it('returns the original value when undefined', () => {
+    const result = pipe.transform(undefined as any);
+    expect(result).toBeUndefined();
+  });
+
+  it('validates each item when value is an array', () => {
+    const result = pipe.transform(['Photo', 'Video'] as any);
+    expect(result).toEqual(['Photo', 'Video']);
+  });
+
+  it('throws when an array contains an invalid value', () => {
+    expect(() => pipe.transform(['Photo', 'Bad'] as any)).toThrow();
+  });
+});
+
+describe('ValidateIdPipe', () => {
+  let pipe: ValidateIdPipe;
+
+  beforeEach(() => {
+    pipe = new ValidateIdPipe();
+  });
+
+  it('passes through a valid cuid', () => {
+    const result = pipe.transform('valid-cuid-value');
+    expect(result).toBe('valid-cuid-value');
+  });
+
+  it('throws BadRequestException for an invalid id', () => {
+    expect(() => pipe.transform('not-a-cuid')).toThrow();
+  });
+
+  it('passes through when value is falsy (optional id)', () => {
+    const result = pipe.transform(undefined as any);
+    expect(result).toBeUndefined();
+  });
+
+  it('uses a custom error message', () => {
+    const customPipe = new ValidateIdPipe('Custom error');
+    try {
+      customPipe.transform('not-a-cuid');
+    } catch (e: any) {
+      expect(e.message).toBe('Custom error');
+    }
+  });
+});
+
+describe('ValidateSearchPipe', () => {
+  const mockModel = {
+    tableAttributes: { MediaId: {}, Title: {}, Type: {} },
+  };
+
+  let pipe: ValidateSearchPipe;
+
+  beforeEach(() => {
+    pipe = new ValidateSearchPipe(mockModel);
+  });
+
+  it('returns value when search is valid JSON with valid keys', () => {
+    const search = JSON.stringify({ Title: 'test' });
+    expect(pipe.transform(search)).toBe(search);
+  });
+
+  it('returns undefined when value is falsy', () => {
+    expect(pipe.transform(undefined as any)).toBeUndefined();
+  });
+
+  it('throws BadRequestException for invalid JSON', () => {
+    expect(() => pipe.transform('{bad json')).toThrow();
+  });
+
+  it('throws BadRequestException for unknown search key', () => {
+    const search = JSON.stringify({ UnknownField: 'value' });
+    expect(() => pipe.transform(search)).toThrow();
+  });
+
+  it('allows additionalAttributes alongside model attributes', () => {
+    const pipeWithExtra = new ValidateSearchPipe(mockModel, ['ExtraField']);
+    const search = JSON.stringify({ ExtraField: 'value' });
+    expect(pipeWithExtra.transform(search)).toBe(search);
+  });
+});

package/src/base/base.medias.ts

@@ -1,5 +1,5 @@
 import { MediaType } from '../enum/medias.enum';
-import * as cuid from 'cuid';
+import { createId } from '@paralleldrive/cuid2';
 import { BadRequestException } from '@nestjs/common';
 import { MediasModel } from '../entities/medias.entity';
 import { IBaseMediasAttr } from '../interfaces/base.medias-attr.interface';
@@ -36,7 +36,7 @@ export abstract class BaseMedias extends ObjectBase {
   }
 
   init(media: IBaseMediasAttr) {
-    this.MediaId = media.MediaId ? media.MediaId : cuid();
+    this.MediaId = media.MediaId ? media.MediaId : createId();
     this.ObjectId = media.ObjectId;
     this.ObjectType = media.ObjectType;
     this.Title = media.Title;

package/src/common/common.service.ts

@@ -5,7 +5,7 @@ import {
 } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import axios from 'axios';
-import * as cuid from 'cuid';
+import { createId } from '@paralleldrive/cuid2';
 import { omit, omitBy, keys, pick } from 'lodash';
 import { AddFieldTranslationDto } from './dto/add-field-translation.dto';
 import { GetMediaDto } from './dto/get-media.dto';
@@ -61,7 +61,7 @@ export class CommonService {
       EntityValueAfter: JSON.stringify(filteredRecord),
       PerformedById: record.PerformedById,
       PerformedAt: record.PerformedAt || Date.now(),
-      EntityId: record.EntityId ? record.EntityId : cuid(),
+      EntityId: record.EntityId ? record.EntityId : createId(),
     };
 
     try {

package/src/medias.repository.ts

@@ -21,7 +21,9 @@ export class MediasRepository
       const result = await MediasModel.findOne(options);
       return result;
     } catch (error) {
-      throw new Error(`An Error occured when fetching : ${error.message}`);
+      throw new Error(
+        `An Error occured when fetching : ${(error as Error).message}`,
+      );
     }
   }
 
@@ -35,7 +37,9 @@ export class MediasRepository
       };
       await MediasModel.destroy(options);
     } catch (error) {
-      throw new Error(`An Error occured when delete : ${error.message}`);
+      throw new Error(
+        `An Error occured when delete : ${(error as Error).message}`,
+      );
     }
   }
 
@@ -49,7 +53,9 @@ export class MediasRepository
       }
       return medias;
     } catch (error) {
-      throw new Error(`An Error occured when retriving : ${error.message}`);
+      throw new Error(
+        `An Error occured when retriving : ${(error as Error).message}`,
+      );
     }
   }
 }