@flusys/nestjs-localization 7.0.2 → 8.0.0-beta.1

package/fesm/controllers/language.controller.js

@@ -1,178 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { createApiController, LANGUAGE_PERMISSIONS } from '@flusys/nestjs-shared/classes';
-import { CurrentUser, RequirePermission } from '@flusys/nestjs-shared/decorators';
-import { JwtAuthGuard, PermissionGuard } from '@flusys/nestjs-shared/guards';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { Body, Controller, Inject, Post, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { LANGUAGE_MESSAGES } from '../config';
-import { CreateLanguageDto, LanguageResponseDto, UpdateLanguageDto } from '../dtos';
-import { LanguageService } from '../services';
-export class LanguageController extends createApiController(CreateLanguageDto, UpdateLanguageDto, LanguageResponseDto, {
-    entityName: 'language',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                LANGUAGE_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                LANGUAGE_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                LANGUAGE_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                LANGUAGE_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                LANGUAGE_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                LANGUAGE_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                LANGUAGE_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    async getActive() {
-        const data = await this.service.getActiveLanguages();
-        return {
-            success: true,
-            message: 'Active languages retrieved successfully',
-            messageKey: LANGUAGE_MESSAGES.ACTIVE_SUCCESS,
-            data,
-            meta: {
-                total: data.length,
-                page: 0,
-                pageSize: data.length,
-                count: data.length
-            }
-        };
-    }
-    async getDefault() {
-        const data = await this.service.getDefaultLanguage();
-        return {
-            success: true,
-            message: 'Default language retrieved successfully',
-            messageKey: LANGUAGE_MESSAGES.GET_DEFAULT_SUCCESS,
-            data: data ?? undefined
-        };
-    }
-    async setDefault(body, _user) {
-        const data = await this.service.setAsDefault(body.id);
-        return {
-            success: true,
-            message: 'Default language updated successfully',
-            messageKey: LANGUAGE_MESSAGES.SET_DEFAULT_SUCCESS,
-            data: data ?? undefined
-        };
-    }
-    constructor(service){
-        super(service), _define_property(this, "service", void 0), this.service = service;
-    }
-}
-_ts_decorate([
-    Post('get-active'),
-    ApiOperation({
-        summary: 'Get all active languages'
-    }),
-    ApiResponse({
-        status: 200,
-        type: [
-            LanguageResponseDto
-        ]
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", []),
-    _ts_metadata("design:returntype", Promise)
-], LanguageController.prototype, "getActive", null);
-_ts_decorate([
-    Post('get-default'),
-    ApiOperation({
-        summary: 'Get default language'
-    }),
-    ApiResponse({
-        status: 200,
-        type: LanguageResponseDto
-    }),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", []),
-    _ts_metadata("design:returntype", Promise)
-], LanguageController.prototype, "getDefault", null);
-_ts_decorate([
-    Post('set-default'),
-    UseGuards(JwtAuthGuard, PermissionGuard),
-    ApiBearerAuth(),
-    RequirePermission(LANGUAGE_PERMISSIONS.UPDATE),
-    ApiOperation({
-        summary: 'Set a language as default'
-    }),
-    ApiResponse({
-        status: 200,
-        type: LanguageResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_param(1, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        Object,
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], LanguageController.prototype, "setDefault", null);
-LanguageController = _ts_decorate([
-    ApiTags('Localization - Language'),
-    Controller('localization/language'),
-    _ts_param(0, Inject(LanguageService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof LanguageService === "undefined" ? Object : LanguageService
-    ])
-], LanguageController);

package/fesm/controllers/language.controller.spec.js

@@ -1,150 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { LanguageController } from './language.controller';
-import { LanguageService } from '../services';
-function buildLanguage(overrides = {}) {
-    return {
-        id: 'lang-en',
-        code: 'en',
-        name: 'English',
-        nativeName: 'English',
-        direction: 'ltr',
-        isActive: true,
-        isDefault: false,
-        serial: 1,
-        isReadonly: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-describe('LanguageController', ()=>{
-    let controller;
-    let mockService;
-    beforeEach(async ()=>{
-        mockService = {
-            insert: jest.fn(),
-            findById: jest.fn(),
-            getAll: jest.fn(),
-            update: jest.fn(),
-            delete: jest.fn(),
-            getActiveLanguages: jest.fn(),
-            getDefaultLanguage: jest.fn(),
-            setAsDefault: jest.fn()
-        };
-        const module = await Test.createTestingModule({
-            controllers: [
-                LanguageController
-            ],
-            providers: [
-                {
-                    provide: LanguageService,
-                    useValue: mockService
-                },
-                // The base ApiController wires the Slug interceptor (needs UtilsService) on several
-                // inherited endpoints, so it must be resolvable even though these tests only hit custom routes.
-                {
-                    provide: UtilsService,
-                    useValue: {}
-                }
-            ]
-        }).compile();
-        controller = module.get(LanguageController);
-    });
-    describe('getActive', ()=>{
-        it('returns all active languages with a full-length meta block', async ()=>{
-            const languages = [
-                buildLanguage({
-                    code: 'en'
-                }),
-                buildLanguage({
-                    id: 'lang-bn',
-                    code: 'bn'
-                })
-            ];
-            mockService.getActiveLanguages.mockResolvedValue(languages);
-            const result = await controller.getActive();
-            expect(result).toEqual({
-                success: true,
-                message: 'Active languages retrieved successfully',
-                messageKey: 'language.active.success',
-                data: languages,
-                meta: {
-                    total: 2,
-                    page: 0,
-                    pageSize: 2,
-                    count: 2
-                }
-            });
-        });
-        it('returns an empty list with zeroed meta when no languages are active', async ()=>{
-            mockService.getActiveLanguages.mockResolvedValue([]);
-            const result = await controller.getActive();
-            expect(result.data).toEqual([]);
-            expect(result.meta).toEqual({
-                total: 0,
-                page: 0,
-                pageSize: 0,
-                count: 0
-            });
-        });
-    });
-    describe('getDefault', ()=>{
-        it('returns the default language', async ()=>{
-            const defaultLanguage = buildLanguage({
-                isDefault: true
-            });
-            mockService.getDefaultLanguage.mockResolvedValue(defaultLanguage);
-            const result = await controller.getDefault();
-            expect(result).toEqual({
-                success: true,
-                message: 'Default language retrieved successfully',
-                messageKey: 'language.get.default.success',
-                data: defaultLanguage
-            });
-        });
-        it('falls back to undefined data when no default language is configured', async ()=>{
-            mockService.getDefaultLanguage.mockResolvedValue(null);
-            const result = await controller.getDefault();
-            expect(result.data).toBeUndefined();
-            expect(result.success).toBe(true);
-        });
-    });
-    describe('setDefault', ()=>{
-        it('sets the given language id as default and returns it', async ()=>{
-            const updated = buildLanguage({
-                id: 'lang-bn',
-                isDefault: true
-            });
-            mockService.setAsDefault.mockResolvedValue(updated);
-            const result = await controller.setDefault({
-                id: 'lang-bn'
-            }, buildMockUser());
-            expect(mockService.setAsDefault).toHaveBeenCalledWith('lang-bn');
-            expect(result).toEqual({
-                success: true,
-                message: 'Default language updated successfully',
-                messageKey: 'language.set.default.success',
-                data: updated
-            });
-        });
-        it('returns undefined data when the id does not match any language', async ()=>{
-            mockService.setAsDefault.mockResolvedValue(null);
-            const result = await controller.setDefault({
-                id: 'unknown-id'
-            }, buildMockUser());
-            expect(result.data).toBeUndefined();
-        });
-        it('propagates errors raised by the service unchanged', async ()=>{
-            mockService.setAsDefault.mockRejectedValue(new Error('database unavailable'));
-            await expect(controller.setDefault({
-                id: 'lang-en'
-            }, buildMockUser())).rejects.toThrow('database unavailable');
-        });
-    });
-});

package/fesm/controllers/translation-key.controller.js

@@ -1,125 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { createApiController, TRANSLATION_KEY_PERMISSIONS } from '@flusys/nestjs-shared/classes';
-import { CurrentUser } from '@flusys/nestjs-shared/decorators';
-import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
-import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { Controller, Inject, Post, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { TRANSLATION_KEY_MESSAGES } from '../config';
-import { CreateTranslationKeyDto, TranslationKeyResponseDto, UpdateTranslationKeyDto } from '../dtos';
-import { TranslationKeyService } from '../services';
-export class TranslationKeyController extends createApiController(CreateTranslationKeyDto, UpdateTranslationKeyDto, TranslationKeyResponseDto, {
-    entityName: 'translation.key',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                TRANSLATION_KEY_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                TRANSLATION_KEY_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                TRANSLATION_KEY_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                TRANSLATION_KEY_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                TRANSLATION_KEY_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                TRANSLATION_KEY_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                TRANSLATION_KEY_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    async getModules(_user) {
-        const data = await this.service.getModules();
-        return {
-            success: true,
-            message: 'Modules retrieved successfully',
-            messageKey: TRANSLATION_KEY_MESSAGES.MODULES_SUCCESS,
-            data
-        };
-    }
-    constructor(service){
-        super(service), _define_property(this, "service", void 0), this.service = service;
-    }
-}
-_ts_decorate([
-    Post('get-modules'),
-    UseGuards(JwtAuthGuard),
-    ApiBearerAuth(),
-    ApiOperation({
-        summary: 'Get all distinct module names'
-    }),
-    ApiResponse({
-        status: 200,
-        type: [
-            String
-        ]
-    }),
-    _ts_param(0, CurrentUser()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof ILoggedUserInfo === "undefined" ? Object : ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], TranslationKeyController.prototype, "getModules", null);
-TranslationKeyController = _ts_decorate([
-    ApiTags('Localization - Translation Key'),
-    Controller('localization/translation-key'),
-    _ts_param(0, Inject(TranslationKeyService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof TranslationKeyService === "undefined" ? Object : TranslationKeyService
-    ])
-], TranslationKeyController);

package/fesm/controllers/translation-key.controller.spec.js

@@ -1,66 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { TranslationKeyController } from './translation-key.controller';
-import { TranslationKeyService } from '../services';
-describe('TranslationKeyController', ()=>{
-    let controller;
-    let mockService;
-    beforeEach(async ()=>{
-        mockService = {
-            insert: jest.fn(),
-            findById: jest.fn(),
-            getAll: jest.fn(),
-            update: jest.fn(),
-            delete: jest.fn(),
-            getModules: jest.fn(),
-            findByModule: jest.fn()
-        };
-        const module = await Test.createTestingModule({
-            controllers: [
-                TranslationKeyController
-            ],
-            providers: [
-                {
-                    provide: TranslationKeyService,
-                    useValue: mockService
-                },
-                {
-                    provide: UtilsService,
-                    useValue: {}
-                }
-            ]
-        }).compile();
-        controller = module.get(TranslationKeyController);
-    });
-    describe('getModules', ()=>{
-        it('returns the distinct module names from the service', async ()=>{
-            mockService.getModules.mockResolvedValue([
-                'auth',
-                'shared',
-                'storage'
-            ]);
-            const result = await controller.getModules(buildMockUser());
-            expect(result).toEqual({
-                success: true,
-                message: 'Modules retrieved successfully',
-                messageKey: 'translation.key.modules.success',
-                data: [
-                    'auth',
-                    'shared',
-                    'storage'
-                ]
-            });
-        });
-        it('returns an empty array when no translation keys have been created yet', async ()=>{
-            mockService.getModules.mockResolvedValue([]);
-            const result = await controller.getModules(buildMockUser());
-            expect(result.data).toEqual([]);
-            expect(result.success).toBe(true);
-        });
-        it('propagates unexpected errors from the service', async ()=>{
-            mockService.getModules.mockRejectedValue(new Error('query failed'));
-            await expect(controller.getModules(buildMockUser())).rejects.toThrow('query failed');
-        });
-    });
-});