@flusys/nestjs-iam 7.1.0 → 8.0.0

package/cjs/controllers/role-permission.controller.spec.js

@@ -1,140 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _common = require("@nestjs/common");
-const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
-const _rolepermissioncontroller = require("./role-permission.controller");
-describe('RolePermissionController', ()=>{
-    let controller;
-    let mockPermissionService;
-    let mockConfig;
-    beforeEach(()=>{
-        mockPermissionService = {
-            assignRoleActions: jest.fn(),
-            getRoleActions: jest.fn(),
-            assignUserRoles: jest.fn(),
-            getUserRoles: jest.fn()
-        };
-        mockConfig = {
-            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
-        };
-        controller = new _rolepermissioncontroller.RolePermissionController(mockPermissionService, mockConfig);
-    });
-    describe('assignRoleActions', ()=>{
-        it('assigns actions to a role and returns the operation summary', async ()=>{
-            mockPermissionService.assignRoleActions.mockResolvedValue({
-                added: 2,
-                removed: 1,
-                total: 3
-            });
-            const result = await controller.assignRoleActions({
-                roleId: 'role-1',
-                actionIds: [
-                    'action-1',
-                    'action-2'
-                ]
-            });
-            expect(mockPermissionService.assignRoleActions).toHaveBeenCalledWith({
-                roleId: 'role-1',
-                actionIds: [
-                    'action-1',
-                    'action-2'
-                ]
-            });
-            expect(result.success).toBe(true);
-            expect(result.data).toEqual({
-                added: 2,
-                removed: 1,
-                total: 3
-            });
-        });
-    });
-    describe('getRoleActions', ()=>{
-        it('returns actions assigned to the role', async ()=>{
-            mockPermissionService.getRoleActions.mockResolvedValue([
-                {
-                    actionId: 'action-1'
-                }
-            ]);
-            const result = await controller.getRoleActions({
-                roleId: 'role-1'
-            });
-            expect(mockPermissionService.getRoleActions).toHaveBeenCalledWith('role-1');
-            expect(result.data).toEqual([
-                {
-                    actionId: 'action-1'
-                }
-            ]);
-        });
-    });
-    describe('assignUserRoles', ()=>{
-        it('assigns roles to a user when the caller has access to the target company', async ()=>{
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const user = (0, _loggedusermock.buildMockUser)({
-                companyId: 'company-1'
-            });
-            mockPermissionService.assignUserRoles.mockResolvedValue({
-                added: 1,
-                removed: 0,
-                total: 1
-            });
-            const result = await controller.assignUserRoles({
-                userId: 'user-2',
-                roleIds: [
-                    'role-1'
-                ],
-                companyId: 'company-1'
-            }, user);
-            expect(mockPermissionService.assignUserRoles).toHaveBeenCalledWith({
-                userId: 'user-2',
-                roleIds: [
-                    'role-1'
-                ],
-                companyId: 'company-1'
-            });
-            expect(result.data).toEqual({
-                added: 1,
-                removed: 0,
-                total: 1
-            });
-        });
-        it('rejects assignment when the caller has no access to the target company', async ()=>{
-            mockConfig.isCompanyFeatureEnabled.mockReturnValue(true);
-            const user = (0, _loggedusermock.buildMockUser)({
-                companyId: 'company-1'
-            });
-            await expect(controller.assignUserRoles({
-                userId: 'user-2',
-                roleIds: [
-                    'role-1'
-                ],
-                companyId: 'company-2'
-            }, user)).rejects.toThrow(_common.ForbiddenException);
-            expect(mockPermissionService.assignUserRoles).not.toHaveBeenCalled();
-        });
-    });
-    describe('getUserRoles', ()=>{
-        it('returns roles assigned to the user scoped by branch and company', async ()=>{
-            const user = (0, _loggedusermock.buildMockUser)({
-                companyId: 'company-1'
-            });
-            mockPermissionService.getUserRoles.mockResolvedValue([
-                {
-                    roleId: 'role-1'
-                }
-            ]);
-            const result = await controller.getUserRoles({
-                userId: 'user-2',
-                branchId: 'branch-1',
-                companyId: 'company-1'
-            }, user);
-            expect(mockPermissionService.getUserRoles).toHaveBeenCalledWith('user-2', 'branch-1', 'company-1');
-            expect(result.data).toEqual([
-                {
-                    roleId: 'role-1'
-                }
-            ]);
-        });
-    });
-});

package/cjs/controllers/role.controller.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "RoleController", {
-    enumerable: true,
-    get: function() {
-        return RoleController;
-    }
-});
-const _nestjsshared = require("@flusys/nestjs-shared");
-const _common = require("@nestjs/common");
-const _swagger = require("@nestjs/swagger");
-const _roledto = require("../dtos/role.dto");
-const _roleservice = require("../services/role.service");
-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);
-    };
-}
-let RoleController = class RoleController extends (0, _nestjsshared.createApiController)(_roledto.CreateRoleDto, _roledto.UpdateRoleDto, _roledto.RoleResponseDto, {
-    entityName: 'role',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                _nestjsshared.ROLE_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                _nestjsshared.ROLE_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                _nestjsshared.ROLE_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                _nestjsshared.ROLE_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                _nestjsshared.ROLE_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                _nestjsshared.ROLE_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                _nestjsshared.ROLE_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    constructor(roleService){
-        super(roleService), _define_property(this, "roleService", void 0), this.roleService = roleService;
-    }
-};
-RoleController = _ts_decorate([
-    (0, _swagger.ApiTags)('IAM - Roles'),
-    (0, _common.Controller)('iam/roles'),
-    _ts_param(0, (0, _common.Inject)(_roleservice.RoleService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _roleservice.RoleService === "undefined" ? Object : _roleservice.RoleService
-    ])
-], RoleController);

package/cjs/controllers/role.controller.spec.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
-const _rolecontroller = require("./role.controller");
-function buildRole(overrides = {}) {
-    return {
-        id: 'role-1',
-        name: 'Admin',
-        description: null,
-        isActive: true,
-        readOnly: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides
-    };
-}
-describe('RoleController', ()=>{
-    let controller;
-    let mockRoleService;
-    beforeEach(()=>{
-        mockRoleService = {
-            insert: jest.fn(),
-            findById: jest.fn(),
-            getAll: jest.fn(),
-            update: jest.fn(),
-            delete: jest.fn()
-        };
-        controller = new _rolecontroller.RoleController(mockRoleService);
-    });
-    it('wires the injected service onto the generated controller base', ()=>{
-        expect(controller.roleService).toBe(mockRoleService);
-        expect(controller.service).toBe(mockRoleService);
-    });
-    describe('insert', ()=>{
-        it('creates a role and returns the mapped response', async ()=>{
-            const user = (0, _loggedusermock.buildMockUser)();
-            mockRoleService.insert.mockResolvedValue(buildRole());
-            const result = await controller.insert({
-                name: 'Admin'
-            }, user);
-            expect(mockRoleService.insert).toHaveBeenCalledWith({
-                name: 'Admin'
-            }, user);
-            expect(result.success).toBe(true);
-            expect(result.data).toEqual(expect.objectContaining({
-                id: 'role-1',
-                name: 'Admin'
-            }));
-        });
-    });
-    describe('getAll', ()=>{
-        it('paginates roles and maps the response list', async ()=>{
-            mockRoleService.getAll.mockResolvedValue({
-                data: [
-                    buildRole()
-                ],
-                total: 1
-            });
-            const result = await controller.getAll({}, (0, _loggedusermock.buildMockUser)(), '');
-            expect(mockRoleService.getAll).toHaveBeenCalledWith('', {}, (0, _loggedusermock.buildMockUser)());
-            expect(result.data).toHaveLength(1);
-        });
-    });
-    describe('delete', ()=>{
-        it('delegates soft-delete to the service', async ()=>{
-            mockRoleService.delete.mockResolvedValue({
-                count: 1
-            });
-            const result = await controller.delete({
-                id: [
-                    'role-1'
-                ],
-                type: 'delete'
-            }, (0, _loggedusermock.buildMockUser)());
-            expect(mockRoleService.delete).toHaveBeenCalledWith({
-                id: [
-                    'role-1'
-                ],
-                type: 'delete'
-            }, (0, _loggedusermock.buildMockUser)());
-            expect(result.success).toBe(true);
-        });
-    });
-});

package/cjs/controllers/user-action-permission.controller.js

@@ -1,129 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "UserActionPermissionController", {
-    enumerable: true,
-    get: function() {
-        return UserActionPermissionController;
-    }
-});
-const _nestjsshared = require("@flusys/nestjs-shared");
-const _common = require("@nestjs/common");
-const _swagger = require("@nestjs/swagger");
-const _config = require("../config");
-const _permissiondto = require("../dtos/permission.dto");
-const _iamconfigservice = require("../services/iam-config.service");
-const _permissionservice = require("../services/permission.service");
-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);
-    };
-}
-let UserActionPermissionController = class UserActionPermissionController {
-    async assignUserActions(dto, user) {
-        const result = await this.permissionService.assignUserActions(dto);
-        return {
-            success: true,
-            message: 'User actions updated successfully',
-            messageKey: _config.PERMISSION_OPERATION_MESSAGES.PROCESS_SUCCESS,
-            messageVariables: {
-                added: result.added,
-                removed: result.removed,
-                total: result.total
-            },
-            data: result
-        };
-    }
-    async getUserActions(dto, user) {
-        const actions = await this.permissionService.getUserActions(dto.userId, dto.companyId, dto.branchId);
-        return {
-            success: true,
-            message: 'User actions retrieved successfully',
-            messageKey: _config.USER_ACTION_PERMISSION_MESSAGES.GET_SUCCESS,
-            data: actions
-        };
-    }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
-    constructor(permissionService, config){
-        _define_property(this, "permissionService", void 0);
-        _define_property(this, "config", void 0);
-        this.permissionService = permissionService;
-        this.config = config;
-    }
-};
-_ts_decorate([
-    (0, _common.Post)('user-actions/assign'),
-    (0, _nestjsshared.RequirePermission)(_nestjsshared.USER_ACTION_PERMISSIONS.ASSIGN),
-    (0, _swagger.ApiOperation)({
-        summary: 'Assign/remove actions to/from user',
-        description: 'Direct permissions. If company feature enabled, branchId is required.'
-    }),
-    (0, _nestjsshared.ApiResponseDto)(_permissiondto.PermissionOperationResultDto),
-    (0, _swagger.ApiBody)({
-        type: _permissiondto.AssignUserActionsDto
-    }),
-    _ts_param(0, (0, _common.Body)()),
-    _ts_param(1, (0, _nestjsshared.CurrentUser)()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _permissiondto.AssignUserActionsDto === "undefined" ? Object : _permissiondto.AssignUserActionsDto,
-        typeof _nestjsshared.ILoggedUserInfo === "undefined" ? Object : _nestjsshared.ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserActionPermissionController.prototype, "assignUserActions", null);
-_ts_decorate([
-    (0, _common.Post)('get-user-actions'),
-    (0, _nestjsshared.RequirePermission)(_nestjsshared.USER_ACTION_PERMISSIONS.READ),
-    (0, _swagger.ApiOperation)({
-        summary: 'Get user direct actions',
-        description: 'Returns direct action permissions for user. Filter by companyId and branchId.'
-    }),
-    (0, _nestjsshared.ApiResponseDto)(_permissiondto.UserActionResponseDto, true, 'single'),
-    (0, _swagger.ApiBody)({
-        type: _permissiondto.GetUserActionsDto
-    }),
-    _ts_param(0, (0, _common.Body)()),
-    _ts_param(1, (0, _nestjsshared.CurrentUser)()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _permissiondto.GetUserActionsDto === "undefined" ? Object : _permissiondto.GetUserActionsDto,
-        typeof _nestjsshared.ILoggedUserInfo === "undefined" ? Object : _nestjsshared.ILoggedUserInfo
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserActionPermissionController.prototype, "getUserActions", null);
-UserActionPermissionController = _ts_decorate([
-    (0, _swagger.ApiTags)('IAM - User Action Permissions'),
-    (0, _common.Controller)('iam/permissions'),
-    (0, _common.UseGuards)(_nestjsshared.JwtAuthGuard, _nestjsshared.PermissionGuard),
-    (0, _swagger.ApiBearerAuth)(),
-    _ts_param(0, (0, _common.Inject)(_permissionservice.PermissionService)),
-    _ts_param(1, (0, _common.Inject)(_iamconfigservice.IAMConfigService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _permissionservice.PermissionService === "undefined" ? Object : _permissionservice.PermissionService,
-        typeof _iamconfigservice.IAMConfigService === "undefined" ? Object : _iamconfigservice.IAMConfigService
-    ])
-], UserActionPermissionController);

package/cjs/controllers/user-action-permission.controller.spec.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _loggedusermock = require("@test-utils/mocks/logged-user.mock");
-const _useractionpermissioncontroller = require("./user-action-permission.controller");
-describe('UserActionPermissionController', ()=>{
-    let controller;
-    let mockPermissionService;
-    let mockConfig;
-    beforeEach(()=>{
-        mockPermissionService = {
-            assignUserActions: jest.fn(),
-            getUserActions: jest.fn()
-        };
-        mockConfig = {};
-        controller = new _useractionpermissioncontroller.UserActionPermissionController(mockPermissionService, mockConfig);
-    });
-    describe('assignUserActions', ()=>{
-        it('assigns direct action permissions to a user', async ()=>{
-            const user = (0, _loggedusermock.buildMockUser)();
-            mockPermissionService.assignUserActions.mockResolvedValue({
-                added: 1,
-                removed: 0,
-                total: 1
-            });
-            const result = await controller.assignUserActions({
-                userId: 'user-2',
-                actionIds: [
-                    'action-1'
-                ]
-            }, user);
-            expect(mockPermissionService.assignUserActions).toHaveBeenCalledWith({
-                userId: 'user-2',
-                actionIds: [
-                    'action-1'
-                ]
-            });
-            expect(result.success).toBe(true);
-            expect(result.data).toEqual({
-                added: 1,
-                removed: 0,
-                total: 1
-            });
-        });
-    });
-    describe('getUserActions', ()=>{
-        it('returns direct action permissions for a user scoped by branch/company', async ()=>{
-            const user = (0, _loggedusermock.buildMockUser)();
-            mockPermissionService.getUserActions.mockResolvedValue([
-                {
-                    actionId: 'action-1'
-                }
-            ]);
-            const result = await controller.getUserActions({
-                userId: 'user-2',
-                branchId: 'branch-1',
-                companyId: 'company-1'
-            }, user);
-            expect(mockPermissionService.getUserActions).toHaveBeenCalledWith('user-2', 'company-1', 'branch-1');
-            expect(result.data).toEqual([
-                {
-                    actionId: 'action-1'
-                }
-            ]);
-        });
-    });
-});