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

package/fesm/controllers/branch.controller.js

@@ -1,92 +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, BRANCH_PERMISSIONS } from '@flusys/nestjs-shared/classes';
-import { Controller, Inject } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
-import { CompanyBranchResponseDto, CreateCompanyBranchDto, UpdateCompanyBranchDto } from '../dtos/company-branch.dto';
-import { BranchService } from '../services/branch.service';
-export class BranchController extends createApiController(CreateCompanyBranchDto, UpdateCompanyBranchDto, CompanyBranchResponseDto, {
-    entityName: 'branch',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                BRANCH_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                BRANCH_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                BRANCH_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                BRANCH_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                BRANCH_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                BRANCH_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                BRANCH_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    constructor(branchService){
-        super(branchService), _define_property(this, "branchService", void 0), this.branchService = branchService;
-    }
-}
-BranchController = _ts_decorate([
-    ApiTags('Branches'),
-    Controller('administration/branch'),
-    _ts_param(0, Inject(BranchService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof BranchService === "undefined" ? Object : BranchService
-    ])
-], BranchController);

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

@@ -1,130 +0,0 @@
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { BranchController } from './branch.controller';
-function buildBranch(overrides = {}) {
-    return {
-        id: 'branch-1',
-        name: 'Main Branch',
-        slug: 'main-branch',
-        companyId: 'company-1',
-        parentId: null,
-        logoId: null,
-        address: null,
-        phone: null,
-        email: null,
-        serial: null,
-        isActive: true,
-        readOnly: false,
-        additionalFields: null,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...overrides
-    };
-}
-describe('BranchController', ()=>{
-    let controller;
-    let mockBranchService;
-    beforeEach(()=>{
-        mockBranchService = {
-            insert: jest.fn(),
-            insertMany: jest.fn(),
-            findById: jest.fn(),
-            findByIds: jest.fn(),
-            update: jest.fn(),
-            updateMany: jest.fn(),
-            bulkUpsert: jest.fn(),
-            getAll: jest.fn(),
-            delete: jest.fn()
-        };
-        controller = new BranchController(mockBranchService);
-    });
-    it('wires the injected service onto the generated controller base', ()=>{
-        expect(controller.branchService).toBe(mockBranchService);
-        expect(controller.service).toBe(mockBranchService);
-    });
-    describe('insert', ()=>{
-        it('creates a branch and returns the mapped response', async ()=>{
-            const user = buildMockUser();
-            const branch = buildBranch();
-            mockBranchService.insert.mockResolvedValue(branch);
-            const result = await controller.insert({
-                name: 'Main Branch',
-                slug: 'main-branch',
-                companyId: 'company-1'
-            }, user);
-            expect(mockBranchService.insert).toHaveBeenCalledWith({
-                name: 'Main Branch',
-                slug: 'main-branch',
-                companyId: 'company-1'
-            }, user);
-            expect(result.success).toBe(true);
-            expect(result.data).toEqual(expect.objectContaining({
-                id: 'branch-1',
-                slug: 'main-branch'
-            }));
-        });
-    });
-    describe('getById', ()=>{
-        it('retrieves a branch by id', async ()=>{
-            const branch = buildBranch();
-            mockBranchService.findById.mockResolvedValue(branch);
-            const result = await controller.getById('branch-1', {}, null);
-            expect(mockBranchService.findById).toHaveBeenCalledWith('branch-1', null, undefined);
-            expect(result.data).toEqual(expect.objectContaining({
-                id: 'branch-1'
-            }));
-        });
-    });
-    describe('getAll', ()=>{
-        it('paginates branches and maps the response list', async ()=>{
-            mockBranchService.getAll.mockResolvedValue({
-                data: [
-                    buildBranch()
-                ],
-                total: 1
-            });
-            const result = await controller.getAll({}, buildMockUser(), 'main');
-            expect(mockBranchService.getAll).toHaveBeenCalledWith('main', {}, buildMockUser());
-            expect(result.data).toHaveLength(1);
-            expect(result.meta.total).toBe(1);
-        });
-    });
-    describe('update', ()=>{
-        it('updates a branch and returns the mapped response', async ()=>{
-            const branch = buildBranch({
-                name: 'Updated Branch'
-            });
-            mockBranchService.update.mockResolvedValue(branch);
-            const result = await controller.update({
-                id: 'branch-1',
-                name: 'Updated Branch'
-            }, buildMockUser());
-            expect(mockBranchService.update).toHaveBeenCalledWith({
-                id: 'branch-1',
-                name: 'Updated Branch'
-            }, buildMockUser());
-            expect(result.data).toEqual(expect.objectContaining({
-                name: 'Updated Branch'
-            }));
-        });
-    });
-    describe('delete', ()=>{
-        it('delegates soft-delete to the service', async ()=>{
-            mockBranchService.delete.mockResolvedValue({
-                count: 1
-            });
-            const result = await controller.delete({
-                id: [
-                    'branch-1'
-                ],
-                type: 'delete'
-            }, buildMockUser());
-            expect(mockBranchService.delete).toHaveBeenCalledWith({
-                id: [
-                    'branch-1'
-                ],
-                type: 'delete'
-            }, buildMockUser());
-            expect(result.success).toBe(true);
-        });
-    });
-});

package/fesm/controllers/company-selection.controller.js

@@ -1,188 +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 { AUTH_MESSAGES } from '../config';
-import { CurrentUser } from '@flusys/nestjs-shared/decorators';
-import { Body, Controller, HttpCode, HttpStatus, Inject, Post, UseGuards, UseInterceptors } from '@nestjs/common';
-import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { SelectDto, SwitchCompanyDto } from '../dtos/authentication.dto';
-import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
-import { SetToken } from '../interceptors/set-token.interceptor';
-import { AuthenticationService } from '../services/authentication.service';
-export class CompanySelectionController {
-    async select(dto) {
-        const data = await this.authService.select(dto.sessionId, dto.companyId, dto.branchId);
-        return {
-            success: true,
-            message: 'Company selected successfully',
-            messageKey: AUTH_MESSAGES.SELECT_SUCCESS,
-            data
-        };
-    }
-    async switchCompany(userId, dto) {
-        const data = await this.authService.switchCompany(userId, dto.companyId, dto.branchId);
-        return {
-            success: true,
-            message: 'Company switched successfully',
-            messageKey: AUTH_MESSAGES.SWITCH_COMPANY_SUCCESS,
-            data
-        };
-    }
-    async getUserCompanies(userId) {
-        const companies = await this.authService.getUserCompanies(userId);
-        return {
-            success: true,
-            message: 'User companies retrieved successfully',
-            messageKey: AUTH_MESSAGES.COMPANY_LIST_SUCCESS,
-            data: companies
-        };
-    }
-    async getUserBranches(userId, companyId) {
-        const branches = await this.authService.getUserBranches(userId, companyId);
-        return {
-            success: true,
-            message: 'Company branches retrieved successfully',
-            messageKey: AUTH_MESSAGES.BRANCH_LIST_SUCCESS,
-            data: branches
-        };
-    }
-    constructor(authService){
-        _define_property(this, "authService", void 0);
-        this.authService = authService;
-    }
-}
-_ts_decorate([
-    Post('select'),
-    HttpCode(HttpStatus.OK),
-    UseInterceptors(SetToken),
-    ApiOperation({
-        summary: 'Select company and branch after login',
-        description: 'Complete login by selecting company and branch when multiple options are available'
-    }),
-    ApiBody({
-        type: SelectDto
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Company selected, tokens returned'
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof SelectDto === "undefined" ? Object : SelectDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], CompanySelectionController.prototype, "select", null);
-_ts_decorate([
-    UseGuards(JwtAuthGuard),
-    Post('switch-company'),
-    HttpCode(HttpStatus.OK),
-    UseInterceptors(SetToken),
-    ApiBearerAuth(),
-    ApiOperation({
-        summary: 'Switch to different company/branch',
-        description: 'Switch to a different company and branch while already authenticated'
-    }),
-    ApiBody({
-        type: SwitchCompanyDto
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Company switched, new tokens returned'
-    }),
-    _ts_param(0, CurrentUser('id')),
-    _ts_param(1, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        typeof SwitchCompanyDto === "undefined" ? Object : SwitchCompanyDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], CompanySelectionController.prototype, "switchCompany", null);
-_ts_decorate([
-    UseGuards(JwtAuthGuard),
-    Post('get-companies'),
-    HttpCode(HttpStatus.OK),
-    ApiBearerAuth(),
-    ApiOperation({
-        summary: "Get user's available companies",
-        description: 'Get list of companies the current user has access to'
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'User companies retrieved successfully'
-    }),
-    _ts_param(0, CurrentUser('id')),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], CompanySelectionController.prototype, "getUserCompanies", null);
-_ts_decorate([
-    UseGuards(JwtAuthGuard),
-    Post('get-company-branches'),
-    HttpCode(HttpStatus.OK),
-    ApiBearerAuth(),
-    ApiOperation({
-        summary: 'Get branches for a company',
-        description: 'Get list of branches for a specific company that the user has access to'
-    }),
-    ApiBody({
-        schema: {
-            properties: {
-                companyId: {
-                    type: 'string'
-                }
-            },
-            required: [
-                'companyId'
-            ]
-        }
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Company branches retrieved successfully'
-    }),
-    _ts_param(0, CurrentUser('id')),
-    _ts_param(1, Body('companyId')),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String,
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], CompanySelectionController.prototype, "getUserBranches", null);
-CompanySelectionController = _ts_decorate([
-    ApiTags('Company Selection'),
-    Controller('auth'),
-    _ts_param(0, Inject(AuthenticationService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof AuthenticationService === "undefined" ? Object : AuthenticationService
-    ])
-], CompanySelectionController);

package/fesm/controllers/company-selection.controller.spec.js

@@ -1,80 +0,0 @@
-import { CompanySelectionController } from './company-selection.controller';
-describe('CompanySelectionController', ()=>{
-    let controller;
-    let mockAuthService;
-    beforeEach(()=>{
-        mockAuthService = {
-            select: jest.fn(),
-            switchCompany: jest.fn(),
-            getUserCompanies: jest.fn(),
-            getUserBranches: jest.fn()
-        };
-        controller = new CompanySelectionController(mockAuthService);
-    });
-    describe('select', ()=>{
-        it('completes login with the selected company/branch', async ()=>{
-            mockAuthService.select.mockResolvedValue({
-                accessToken: 'a'
-            });
-            const result = await controller.select({
-                sessionId: 'sess-1',
-                companyId: 'company-1',
-                branchId: 'branch-1'
-            });
-            expect(mockAuthService.select).toHaveBeenCalledWith('sess-1', 'company-1', 'branch-1');
-            expect(result).toEqual(expect.objectContaining({
-                success: true,
-                data: {
-                    accessToken: 'a'
-                }
-            }));
-        });
-    });
-    describe('switchCompany', ()=>{
-        it('switches company for the authenticated user', async ()=>{
-            mockAuthService.switchCompany.mockResolvedValue({
-                accessToken: 'b'
-            });
-            const result = await controller.switchCompany('user-1', {
-                companyId: 'company-2',
-                branchId: 'branch-2'
-            });
-            expect(mockAuthService.switchCompany).toHaveBeenCalledWith('user-1', 'company-2', 'branch-2');
-            expect(result.data).toEqual({
-                accessToken: 'b'
-            });
-        });
-    });
-    describe('getUserCompanies', ()=>{
-        it('returns the companies the user has access to', async ()=>{
-            mockAuthService.getUserCompanies.mockResolvedValue([
-                {
-                    id: 'company-1'
-                }
-            ]);
-            const result = await controller.getUserCompanies('user-1');
-            expect(mockAuthService.getUserCompanies).toHaveBeenCalledWith('user-1');
-            expect(result.data).toEqual([
-                {
-                    id: 'company-1'
-                }
-            ]);
-        });
-    });
-    describe('getUserBranches', ()=>{
-        it('returns the branches for the given company', async ()=>{
-            mockAuthService.getUserBranches.mockResolvedValue([
-                {
-                    id: 'branch-1'
-                }
-            ]);
-            const result = await controller.getUserBranches('user-1', 'company-1');
-            expect(mockAuthService.getUserBranches).toHaveBeenCalledWith('user-1', 'company-1');
-            expect(result.data).toEqual([
-                {
-                    id: 'branch-1'
-                }
-            ]);
-        });
-    });
-});

package/fesm/controllers/company.controller.js

@@ -1,92 +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, COMPANY_PERMISSIONS } from '@flusys/nestjs-shared/classes';
-import { Controller, Inject } from '@nestjs/common';
-import { ApiTags } from '@nestjs/swagger';
-import { CompanyResponseDto, CreateCompanyDto, UpdateCompanyDto } from '../dtos/company.dto';
-import { CompanyService } from '../services/company.service';
-export class CompanyController extends createApiController(CreateCompanyDto, UpdateCompanyDto, CompanyResponseDto, {
-    entityName: 'company',
-    security: {
-        insert: {
-            level: 'permission',
-            permissions: [
-                COMPANY_PERMISSIONS.CREATE
-            ]
-        },
-        insertMany: {
-            level: 'permission',
-            permissions: [
-                COMPANY_PERMISSIONS.CREATE
-            ]
-        },
-        getById: {
-            level: 'permission',
-            permissions: [
-                COMPANY_PERMISSIONS.READ
-            ]
-        },
-        getAll: {
-            level: 'permission',
-            permissions: [
-                COMPANY_PERMISSIONS.READ
-            ]
-        },
-        update: {
-            level: 'permission',
-            permissions: [
-                COMPANY_PERMISSIONS.UPDATE
-            ]
-        },
-        updateMany: {
-            level: 'permission',
-            permissions: [
-                COMPANY_PERMISSIONS.UPDATE
-            ]
-        },
-        delete: {
-            level: 'permission',
-            permissions: [
-                COMPANY_PERMISSIONS.DELETE
-            ]
-        }
-    }
-}) {
-    constructor(companyService){
-        super(companyService), _define_property(this, "companyService", void 0), this.companyService = companyService;
-    }
-}
-CompanyController = _ts_decorate([
-    ApiTags('Companies'),
-    Controller('administration/company'),
-    _ts_param(0, Inject(CompanyService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof CompanyService === "undefined" ? Object : CompanyService
-    ])
-], CompanyController);