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

package/jest.config.js

@@ -0,0 +1,26 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.spec.ts'],
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/index.ts',
+    '!src/database.ts',
+    '!src/**/*.entity.ts',
+    '!src/**/*.interface.ts',
+    '!src/**/*.dto.ts',
+    '!src/**/*.enum.ts',
+    '!src/**/*.response.ts',
+    '!src/**/*.module.ts',
+    '!src/base/base.repository.abstract.ts',
+    '!src/helpers/**',
+  ],
+  coverageThreshold: {
+    global: {
+      lines: 80,
+    },
+  },
+};

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@tomei/media",
-  "version": "0.8.11-dev.1",
+  "version": "0.10.1-test.1",
   "description": "NestJS package for media module",
   "main": "dist/index.js",
   "scripts": {
     "start:dev": "tsc -w",
     "build": "tsc",
-    "prepare": "husky install",
+    "prepare": "husky install || true",
     "format": "prettier --write \"src/**/*.ts\"",
-    "lint": "npx eslint . --fix"
+    "lint": "npx eslint . --fix",
+    "test": "jest",
+    "test:coverage": "jest --coverage"
   },
   "keywords": [
     "nestjs",
@@ -22,47 +24,49 @@
     "url": "https://gitlab.com/tomei-package/media.git"
   },
   "peerDependencies": {
-    "@azure/storage-blob": "^12.26.0",
-    "@nestjs/common": "^10.4.15",
+    "@azure/storage-blob": "^12.28.0",
+    "@nestjs/common": "^10.4.20",
     "@nestjs/config": "^3.3.0",
-    "@nestjs/core": "^10.4.15",
-    "@nestjs/platform-express": "^10.4.15",
+    "@nestjs/core": "^10.4.20",
+    "@nestjs/platform-express": "^10.4.20",
     "@nestjs/sequelize": "^10.0.1",
-    "@nestjs/swagger": "^8.1.0",
-    "@tomei/activity-history": "^0.4.1",
-    "@tomei/config": "^0.3.21",
-    "@tomei/general": "^0.21.7",
-    "@tomei/mailer": "^0.5.21",
-    "@tomei/sso": "^0.60.4",
-    "axios": "^1.7.9",
+    "@nestjs/swagger": "^8.1.1",
+    "@tomei/activity-history": "^0.4.4",
+    "@tomei/config": "^0.3.22",
+    "@tomei/general": "^0.21.10",
+    "@tomei/mailer": "^0.6.2",
+    "@tomei/sso": "^0.65.0",
+    "axios": "^1.12.2",
     "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.1",
-    "cuid": "^3.0.0",
-    "multer": "^1.4.5-lts.1",
-    "sequelize": "^6.37.5",
+    "class-validator": "^0.14.2",
+    "multer": "^1.4.5-lts.2",
+    "sequelize": "^6.37.7",
     "sequelize-typescript": "^2.1.6"
   },
   "devDependencies": {
-    "@commitlint/config-conventional": "^19.6.0",
-    "@eslint/js": "^9.17.0",
-    "@types/express": "^5.0.0",
-    "@types/multer": "^1.4.12",
-    "@types/node": "^22.10.5",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/js": "^9.36.0",
+    "@types/express": "^5.0.3",
+    "@types/jest": "^30.0.0",
+    "@types/multer": "^1.4.13",
+    "@types/node": "^22.18.8",
     "@types/sequelize": "^4.28.20",
-    "@typescript-eslint/eslint-plugin": "^8.19.0",
-    "eslint": "^9.17.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-prettier": "^5.2.1",
-    "globals": "^15.14.0",
+    "@typescript-eslint/eslint-plugin": "^8.45.0",
+    "eslint": "^9.36.0",
+    "eslint-config-prettier": "^9.1.2",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^15.15.0",
     "husky": "^9.1.7",
-    "lint-staged": "^15.3.0",
-    "prettier": "^3.4.2",
+    "jest": "^30.4.2",
+    "lint-staged": "^15.5.2",
+    "prettier": "^3.6.2",
+    "ts-jest": "^29.4.9",
     "ts-node": "^10.9.2",
-    "tsc-watch": "^6.2.1",
+    "tsc-watch": "^6.3.1",
     "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^8.19.0"
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.45.0"
   },
   "publishConfig": {
     "access": "public"

package/src/__tests__/common.service.spec.ts

@@ -0,0 +1,203 @@
+jest.mock('@nestjs/config', () => ({
+  ConfigService: jest.fn().mockImplementation(() => ({
+    get: jest.fn().mockReturnValue('http://localhost:3000'),
+  })),
+}));
+
+jest.mock('@nestjs/common', () => ({
+  Injectable: () => (target: any) => target,
+  HttpException: class HttpException extends Error {
+    constructor(
+      public response: any,
+      public status: number,
+    ) {
+      super(typeof response === 'string' ? response : JSON.stringify(response));
+    }
+  },
+  InternalServerErrorException: class InternalServerErrorException extends Error {
+    constructor(message: string) {
+      super(message);
+    }
+  },
+}));
+
+jest.mock('axios');
+jest.mock('lodash', () => ({
+  omit: jest.fn((obj, keys) => {
+    const result = { ...obj };
+    keys.forEach((k: string) => delete result[k]);
+    return result;
+  }),
+  omitBy: jest.fn((obj, fn) => obj),
+  keys: jest.fn((obj) => Object.keys(obj)),
+  pick: jest.fn((obj, keys) => {
+    const result: any = {};
+    keys.forEach((k: string) => {
+      if (k in obj) result[k] = obj[k];
+    });
+    return result;
+  }),
+}));
+
+jest.mock('@paralleldrive/cuid2', () => ({
+  createId: jest.fn().mockReturnValue('new-cuid'),
+}));
+
+import axios from 'axios';
+import { CommonService } from '../common/common.service';
+
+const mockAxios = axios as jest.Mocked<typeof axios>;
+
+const mockConfigService = {
+  get: jest.fn().mockReturnValue('http://localhost:3000'),
+} as any;
+
+describe('CommonService', () => {
+  let service: CommonService;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    service = new CommonService(mockConfigService);
+  });
+
+  describe('handleAxiosError', () => {
+    it('throws HttpException when error has a response', () => {
+      const err = { response: { data: 'Bad Request', status: 400 } };
+      expect(() => service.handleAxiosError(err)).toThrow();
+    });
+
+    it('throws HttpException when error has a request but no response', () => {
+      const err = { request: 'timeout' };
+      expect(() => service.handleAxiosError(err)).toThrow();
+    });
+
+    it('throws InternalServerErrorException for generic errors', () => {
+      const err = { message: 'Something went wrong' };
+      expect(() => service.handleAxiosError(err)).toThrow();
+    });
+  });
+
+  describe('addActivityHistory', () => {
+    it('posts activity and returns EntityId', async () => {
+      mockAxios.post = jest
+        .fn()
+        .mockResolvedValue({ data: { EntityId: 'entity-123' } });
+
+      const record = {
+        Action: 'Insert',
+        EntityValueBefore: {},
+        EntityValueAfter: {
+          Title: 'Test',
+          CreatedById: 'u1',
+          CreatedAt: new Date(),
+        },
+        PerformedById: 'user-001',
+        EntityId: 'entity-001',
+      };
+
+      const result = await service.addActivityHistory(
+        record,
+        'Media',
+        'create',
+      );
+      expect(result).toBe('entity-123');
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        'http://localhost:3000/activity-histories',
+        expect.objectContaining({ EntityId: 'entity-001' }),
+      );
+    });
+
+    it('uses update activity label for update method', async () => {
+      mockAxios.post = jest
+        .fn()
+        .mockResolvedValue({ data: { EntityId: 'e2' } });
+
+      const record = {
+        EntityValueBefore: { Title: 'Old' },
+        EntityValueAfter: { Title: 'New' },
+        PerformedById: 'user-001',
+        EntityId: 'entity-002',
+      };
+
+      await service.addActivityHistory(record, 'Media', 'update');
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({ Action: 'Update' }),
+      );
+    });
+
+    it('calls handleAxiosError when axios throws', async () => {
+      const axiosError = { response: { data: 'Error', status: 500 } };
+      mockAxios.post = jest.fn().mockRejectedValue(axiosError);
+
+      const record = {
+        EntityValueBefore: {},
+        EntityValueAfter: {},
+        PerformedById: 'u1',
+        EntityId: 'e1',
+      };
+
+      await expect(
+        service.addActivityHistory(record, 'Media', 'create'),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('getList', () => {
+    it('returns rows from the response', async () => {
+      mockAxios.get = jest
+        .fn()
+        .mockResolvedValue({ data: { rows: ['item1', 'item2'] } });
+
+      const result = await service.getList('MediaTypes');
+      expect(result).toEqual(['item1', 'item2']);
+      expect(mockAxios.get).toHaveBeenCalledWith(
+        'http://localhost:3000/lists/items',
+        expect.objectContaining({ params: { ListName: 'MediaTypes' } }),
+      );
+    });
+
+    it('calls handleAxiosError when axios throws', async () => {
+      mockAxios.get = jest
+        .fn()
+        .mockRejectedValue({ response: { data: 'err', status: 500 } });
+      await expect(service.getList('Any')).rejects.toThrow();
+    });
+  });
+
+  describe('addFieldTranslation', () => {
+    it('posts field translation', async () => {
+      mockAxios.post = jest.fn().mockResolvedValue({});
+      const payload = { field: 'Title', value: 'Tajuk' } as any;
+
+      await service.addFieldTranslation(payload);
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        'http://localhost:3000/field-translations',
+        payload,
+      );
+    });
+
+    it('calls handleAxiosError when axios throws', async () => {
+      mockAxios.post = jest.fn().mockRejectedValue({ message: 'fail' });
+      await expect(service.addFieldTranslation({} as any)).rejects.toThrow();
+    });
+  });
+
+  describe('getMedia', () => {
+    it('returns rows from the response', async () => {
+      mockAxios.get = jest
+        .fn()
+        .mockResolvedValue({ data: { rows: [{ MediaId: 'm1' }] } });
+      const result = await service.getMedia({
+        ObjectId: 'obj1',
+        ObjectType: 'Rental',
+      } as any);
+      expect(result).toEqual([{ MediaId: 'm1' }]);
+    });
+
+    it('calls handleAxiosError when axios throws', async () => {
+      mockAxios.get = jest.fn().mockRejectedValue({ message: 'fail' });
+      await expect(service.getMedia({} as any)).rejects.toThrow();
+    });
+  });
+});

package/src/__tests__/medias.repository.spec.ts

@@ -0,0 +1,158 @@
+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('sequelize', () => ({
+  Op: { substring: Symbol('Op.substring') },
+  DataTypes: {},
+}));
+
+jest.mock('@tomei/general', () => ({
+  RepositoryBase: class RepositoryBase {
+    constructor(_model: any) {}
+  },
+  IRepositoryBase: {},
+}));
+
+import { MediasRepository } from '../medias.repository';
+import { MediasModel } from '../entities/medias.entity';
+
+const mockModel = {
+  MediaId: 'media-001',
+  get: jest.fn().mockReturnValue({}),
+  update: jest.fn(),
+  destroy: jest.fn(),
+};
+
+describe('MediasRepository', () => {
+  let repo: MediasRepository;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    repo = new MediasRepository();
+  });
+
+  describe('findByPk', () => {
+    it('returns a MediasModel when found', async () => {
+      (MediasModel.findOne as jest.Mock).mockResolvedValue(mockModel);
+      const result = await repo.findByPk('media-001', undefined);
+      expect(result).toBe(mockModel);
+      expect(MediasModel.findOne).toHaveBeenCalledWith({
+        where: { MediaId: 'media-001' },
+        transaction: undefined,
+      });
+    });
+
+    it('passes the transaction option', async () => {
+      const tx = { id: 'tx-1' };
+      (MediasModel.findOne as jest.Mock).mockResolvedValue(mockModel);
+      await repo.findByPk('media-001', tx);
+      expect(MediasModel.findOne).toHaveBeenCalledWith({
+        where: { MediaId: 'media-001' },
+        transaction: tx,
+      });
+    });
+
+    it('returns null when record is not found', async () => {
+      (MediasModel.findOne as jest.Mock).mockResolvedValue(null);
+      const result = await repo.findByPk('missing-id', undefined);
+      expect(result).toBeNull();
+    });
+
+    it('throws when the database call fails', async () => {
+      (MediasModel.findOne as jest.Mock).mockRejectedValue(
+        new Error('DB error'),
+      );
+      await expect(repo.findByPk('media-001', undefined)).rejects.toThrow(
+        'DB error',
+      );
+    });
+  });
+
+  describe('delete', () => {
+    it('destroys the record by MediaId', async () => {
+      (MediasModel as any).destroy = jest.fn().mockResolvedValue(1);
+      await repo.delete('media-001');
+      expect((MediasModel as any).destroy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({ MediaId: 'media-001' }),
+        }),
+      );
+    });
+
+    it('passes the transaction option', async () => {
+      const tx = { id: 'tx-2' };
+      (MediasModel as any).destroy = jest.fn().mockResolvedValue(1);
+      await repo.delete('media-001', tx);
+      expect((MediasModel as any).destroy).toHaveBeenCalledWith(
+        expect.objectContaining({ transaction: tx }),
+      );
+    });
+
+    it('throws when the database call fails', async () => {
+      (MediasModel as any).destroy = jest
+        .fn()
+        .mockRejectedValue(new Error('Delete failed'));
+      await expect(repo.delete('media-001')).rejects.toThrow('Delete failed');
+    });
+  });
+
+  describe('findAndCountAll', () => {
+    it('returns count and rows with options', async () => {
+      const mockResult = { count: 2, rows: [mockModel, mockModel] };
+      (MediasModel.findAndCountAll as jest.Mock).mockResolvedValue(mockResult);
+      const result = await repo.findAndCountAll({ limit: 10, offset: 0 });
+      expect(result).toEqual(mockResult);
+      expect(MediasModel.findAndCountAll).toHaveBeenCalledWith({
+        limit: 10,
+        offset: 0,
+      });
+    });
+
+    it('returns all records when no options are given', async () => {
+      const mockResult = { count: 1, rows: [mockModel] };
+      (MediasModel.findAndCountAll as jest.Mock).mockResolvedValue(mockResult);
+      const result = await repo.findAndCountAll(undefined);
+      expect(result).toEqual(mockResult);
+      expect(MediasModel.findAndCountAll).toHaveBeenCalledWith();
+    });
+
+    it('throws when the database call fails', async () => {
+      (MediasModel.findAndCountAll as jest.Mock).mockRejectedValue(
+        new Error('Query failed'),
+      );
+      await expect(repo.findAndCountAll({ limit: 5 })).rejects.toThrow();
+    });
+  });
+});