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

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

@@ -1,223 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "UserPermissionController", {
-    enumerable: true,
-    get: function() {
-        return UserPermissionController;
-    }
-});
-const _nestjsshared = require("@flusys/nestjs-shared");
-const _common = require("@nestjs/common");
-const _swagger = require("@nestjs/swagger");
-const _config = require("../config");
-const _userpermissiondto = require("../dtos/user-permission.dto");
-const _usercompanypermissionentity = require("../entities/user-company-permission.entity");
-const _userpermissionservice = require("../services/user-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 UserPermissionController = class UserPermissionController {
-    async assignUserCompany(dto) {
-        return this.processBatchPermissions(dto.userId, dto.items, _usercompanypermissionentity.PermissionType.COMPANY);
-    }
-    async getUserCompanies(userId) {
-        const permissions = await this.permissionService.findUserCompanies(userId);
-        return {
-            success: true,
-            message: 'User companies retrieved successfully',
-            messageKey: _config.USER_PERMISSION_MESSAGES.COMPANY_LIST_SUCCESS,
-            data: permissions.map((p)=>({
-                    id: p.id,
-                    userId: p.userId,
-                    companyId: p.company?.id || p.targetId,
-                    companyName: p.company?.name || '',
-                    companySlug: p.company?.slug || ''
-                }))
-        };
-    }
-    async assignUserBranch(dto) {
-        return this.processBatchPermissions(dto.userId, dto.items, _usercompanypermissionentity.PermissionType.BRANCH);
-    }
-    async getUserBranches(userId, companyId) {
-        const permissions = await this.permissionService.findUserBranches(userId, companyId);
-        return {
-            success: true,
-            message: 'User branches retrieved successfully',
-            messageKey: _config.USER_PERMISSION_MESSAGES.BRANCH_LIST_SUCCESS,
-            data: permissions.map((p)=>({
-                    id: p.id,
-                    userId: p.userId,
-                    branchId: p.branch?.id || p.targetId,
-                    branchName: p.branch?.name || '',
-                    branchSlug: p.branch?.slug || '',
-                    companyId: p.branch?.companyId || ''
-                }))
-        };
-    }
-    /** Process batch permission assignments/revocations */ async processBatchPermissions(userId, items, type) {
-        let added = 0, removed = 0;
-        for (const item of items){
-            if (item.isAdd) {
-                await this.permissionService.assignPermission(userId, item.targetId, type);
-                added++;
-            } else {
-                await this.permissionService.revokePermission(userId, item.targetId, type);
-                removed++;
-            }
-        }
-        return {
-            success: true,
-            message: `Processed ${added} additions and ${removed} removals`,
-            messageKey: _config.USER_PERMISSION_MESSAGES.BATCH_SUCCESS,
-            messageVariables: {
-                added,
-                removed
-            }
-        };
-    }
-    constructor(permissionService){
-        _define_property(this, "permissionService", void 0);
-        this.permissionService = permissionService;
-    }
-};
-_ts_decorate([
-    (0, _common.Post)('user-company/assign'),
-    (0, _nestjsshared.RequirePermission)(_nestjsshared.USER_PERMISSIONS.UPDATE),
-    (0, _swagger.ApiOperation)({
-        summary: 'Batch assign/revoke user-company permissions'
-    }),
-    (0, _swagger.ApiResponse)({
-        status: 200,
-        description: 'Company permissions updated successfully'
-    }),
-    (0, _swagger.ApiBody)({
-        type: _userpermissiondto.AssignUserCompanyDto
-    }),
-    _ts_param(0, (0, _common.Body)()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _userpermissiondto.AssignUserCompanyDto === "undefined" ? Object : _userpermissiondto.AssignUserCompanyDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserPermissionController.prototype, "assignUserCompany", null);
-_ts_decorate([
-    (0, _common.Post)('get-user-company'),
-    (0, _nestjsshared.RequirePermission)(_nestjsshared.USER_PERMISSIONS.READ),
-    (0, _swagger.ApiOperation)({
-        summary: 'Get user companies'
-    }),
-    (0, _swagger.ApiBody)({
-        schema: {
-            properties: {
-                userId: {
-                    type: 'string'
-                }
-            },
-            required: [
-                'userId'
-            ]
-        }
-    }),
-    (0, _swagger.ApiResponse)({
-        status: 200,
-        type: _userpermissiondto.UserCompaniesResponseDto
-    }),
-    _ts_param(0, (0, _common.Body)('userId')),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserPermissionController.prototype, "getUserCompanies", null);
-_ts_decorate([
-    (0, _common.Post)('user-branch/assign'),
-    (0, _nestjsshared.RequirePermission)(_nestjsshared.USER_PERMISSIONS.UPDATE),
-    (0, _swagger.ApiOperation)({
-        summary: 'Batch assign/revoke user-branch permissions'
-    }),
-    (0, _swagger.ApiResponse)({
-        status: 200,
-        description: 'Branch permissions updated successfully'
-    }),
-    (0, _swagger.ApiBody)({
-        type: _userpermissiondto.AssignUserBranchDto
-    }),
-    _ts_param(0, (0, _common.Body)()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _userpermissiondto.AssignUserBranchDto === "undefined" ? Object : _userpermissiondto.AssignUserBranchDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserPermissionController.prototype, "assignUserBranch", null);
-_ts_decorate([
-    (0, _common.Post)('get-user-branch'),
-    (0, _nestjsshared.RequirePermission)(_nestjsshared.USER_PERMISSIONS.READ),
-    (0, _swagger.ApiOperation)({
-        summary: 'Get user branches'
-    }),
-    (0, _swagger.ApiBody)({
-        schema: {
-            properties: {
-                userId: {
-                    type: 'string'
-                },
-                companyId: {
-                    type: 'string',
-                    description: 'Optional company ID to filter branches'
-                }
-            },
-            required: [
-                'userId'
-            ]
-        }
-    }),
-    (0, _swagger.ApiResponse)({
-        status: 200,
-        type: _userpermissiondto.UserBranchesResponseDto
-    }),
-    _ts_param(0, (0, _common.Body)('userId')),
-    _ts_param(1, (0, _common.Body)('companyId')),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserPermissionController.prototype, "getUserBranches", null);
-UserPermissionController = _ts_decorate([
-    (0, _swagger.ApiTags)('User Permissions'),
-    (0, _swagger.ApiBearerAuth)(),
-    (0, _common.Controller)('administration/permissions'),
-    (0, _common.UseGuards)(_nestjsshared.JwtAuthGuard, _nestjsshared.PermissionGuard),
-    _ts_param(0, (0, _common.Inject)(_userpermissionservice.UserPermissionService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _userpermissionservice.UserPermissionService === "undefined" ? Object : _userpermissionservice.UserPermissionService
-    ])
-], UserPermissionController);

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

@@ -1,138 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _userpermissioncontroller = require("./user-permission.controller");
-const _usercompanypermissionentity = require("../entities/user-company-permission.entity");
-describe('UserPermissionController', ()=>{
-    let controller;
-    let mockPermissionService;
-    beforeEach(()=>{
-        mockPermissionService = {
-            findUserCompanies: jest.fn(),
-            findUserBranches: jest.fn(),
-            assignPermission: jest.fn(),
-            revokePermission: jest.fn()
-        };
-        controller = new _userpermissioncontroller.UserPermissionController(mockPermissionService);
-    });
-    describe('assignUserCompany', ()=>{
-        it('assigns and revokes company permissions in a single batch', async ()=>{
-            const result = await controller.assignUserCompany({
-                userId: 'user-1',
-                items: [
-                    {
-                        targetId: 'company-1',
-                        isAdd: true
-                    },
-                    {
-                        targetId: 'company-2',
-                        isAdd: false
-                    }
-                ]
-            });
-            expect(mockPermissionService.assignPermission).toHaveBeenCalledWith('user-1', 'company-1', _usercompanypermissionentity.PermissionType.COMPANY);
-            expect(mockPermissionService.revokePermission).toHaveBeenCalledWith('user-1', 'company-2', _usercompanypermissionentity.PermissionType.COMPANY);
-            expect(result.messageVariables).toEqual({
-                added: 1,
-                removed: 1
-            });
-        });
-    });
-    describe('getUserCompanies', ()=>{
-        it('maps permission entities to the response DTO shape', async ()=>{
-            mockPermissionService.findUserCompanies.mockResolvedValue([
-                {
-                    id: 'perm-1',
-                    userId: 'user-1',
-                    targetId: 'company-1',
-                    company: {
-                        id: 'company-1',
-                        name: 'Acme',
-                        slug: 'acme'
-                    }
-                }
-            ]);
-            const result = await controller.getUserCompanies('user-1');
-            expect(result.data).toEqual([
-                {
-                    id: 'perm-1',
-                    userId: 'user-1',
-                    companyId: 'company-1',
-                    companyName: 'Acme',
-                    companySlug: 'acme'
-                }
-            ]);
-        });
-        it('falls back to targetId and empty strings when the company relation is missing', async ()=>{
-            mockPermissionService.findUserCompanies.mockResolvedValue([
-                {
-                    id: 'perm-1',
-                    userId: 'user-1',
-                    targetId: 'company-1',
-                    company: undefined
-                }
-            ]);
-            const result = await controller.getUserCompanies('user-1');
-            expect(result.data[0]).toEqual({
-                id: 'perm-1',
-                userId: 'user-1',
-                companyId: 'company-1',
-                companyName: '',
-                companySlug: ''
-            });
-        });
-    });
-    describe('assignUserBranch', ()=>{
-        it('assigns and revokes branch permissions in a single batch', async ()=>{
-            const result = await controller.assignUserBranch({
-                userId: 'user-1',
-                items: [
-                    {
-                        targetId: 'branch-1',
-                        isAdd: true
-                    }
-                ]
-            });
-            expect(mockPermissionService.assignPermission).toHaveBeenCalledWith('user-1', 'branch-1', _usercompanypermissionentity.PermissionType.BRANCH);
-            expect(result.messageVariables).toEqual({
-                added: 1,
-                removed: 0
-            });
-        });
-    });
-    describe('getUserBranches', ()=>{
-        it('maps permission entities to the response DTO shape', async ()=>{
-            mockPermissionService.findUserBranches.mockResolvedValue([
-                {
-                    id: 'perm-1',
-                    userId: 'user-1',
-                    targetId: 'branch-1',
-                    branch: {
-                        id: 'branch-1',
-                        name: 'Main',
-                        slug: 'main',
-                        companyId: 'company-1'
-                    }
-                }
-            ]);
-            const result = await controller.getUserBranches('user-1', 'company-1');
-            expect(mockPermissionService.findUserBranches).toHaveBeenCalledWith('user-1', 'company-1');
-            expect(result.data).toEqual([
-                {
-                    id: 'perm-1',
-                    userId: 'user-1',
-                    branchId: 'branch-1',
-                    branchName: 'Main',
-                    branchSlug: 'main',
-                    companyId: 'company-1'
-                }
-            ]);
-        });
-        it('supports an optional companyId filter', async ()=>{
-            mockPermissionService.findUserBranches.mockResolvedValue([]);
-            await controller.getUserBranches('user-1');
-            expect(mockPermissionService.findUserBranches).toHaveBeenCalledWith('user-1', undefined);
-        });
-    });
-});