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

package/fesm/controllers/social-auth.controller.js

@@ -1,165 +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 { Body, Controller, HttpCode, HttpStatus, Inject, Post, UseInterceptors } from '@nestjs/common';
-import { ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { Throttle } from '@nestjs/throttler';
-import { AUTH_MESSAGES, SOCIAL_AUTH_MESSAGES } from '../config';
-import { SocialAuthorizeDto, SocialAuthorizeResponseDto, SocialCallbackDto, SocialProviderInfoDto, SocialProvidersDto } from '../dtos/social-auth.dto';
-import { SetToken } from '../interceptors/set-token.interceptor';
-import { SocialAuthService } from '../services/social-auth.service';
-export class SocialAuthController {
-    async getProviders(dto) {
-        const data = await this.socialAuthService.listEnabledProviders(dto.redirectUri);
-        return {
-            success: true,
-            message: 'Social providers retrieved successfully',
-            messageKey: SOCIAL_AUTH_MESSAGES.PROVIDERS_SUCCESS,
-            data
-        };
-    }
-    async authorize(dto) {
-        const data = await this.socialAuthService.createAuthorization(dto.provider, dto.redirectUri);
-        return {
-            success: true,
-            message: 'Authorization URL generated successfully',
-            messageKey: SOCIAL_AUTH_MESSAGES.AUTHORIZE_SUCCESS,
-            data
-        };
-    }
-    async callback(dto) {
-        const result = await this.socialAuthService.completeLogin(dto.code, dto.state, dto.redirectUri);
-        if ('requiresSelection' in result) {
-            return {
-                success: true,
-                message: 'Company selection required',
-                messageKey: AUTH_MESSAGES.LOGIN_REQUIRES_SELECTION,
-                data: result
-            };
-        }
-        return {
-            success: true,
-            message: 'Login successful',
-            messageKey: SOCIAL_AUTH_MESSAGES.LOGIN_SUCCESS,
-            data: result
-        };
-    }
-    constructor(socialAuthService){
-        _define_property(this, "socialAuthService", void 0);
-        this.socialAuthService = socialAuthService;
-    }
-}
-_ts_decorate([
-    Post('providers'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 30,
-            ttl: 60000
-        }
-    }),
-    ApiOperation({
-        summary: 'List enabled social sign-in providers'
-    }),
-    ApiBody({
-        type: SocialProvidersDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: [
-            SocialProviderInfoDto
-        ]
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof SocialProvidersDto === "undefined" ? Object : SocialProvidersDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], SocialAuthController.prototype, "getProviders", null);
-_ts_decorate([
-    Post('authorize'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 10,
-            ttl: 60000
-        }
-    }),
-    ApiOperation({
-        summary: "Start a sign-in and get the provider's consent URL"
-    }),
-    ApiBody({
-        type: SocialAuthorizeDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: SocialAuthorizeResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof SocialAuthorizeDto === "undefined" ? Object : SocialAuthorizeDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], SocialAuthController.prototype, "authorize", null);
-_ts_decorate([
-    Post('callback'),
-    HttpCode(HttpStatus.OK),
-    Throttle({
-        default: {
-            limit: 10,
-            ttl: 60000
-        }
-    }),
-    UseInterceptors(SetToken),
-    ApiOperation({
-        summary: 'Complete a social sign-in'
-    }),
-    ApiBody({
-        type: SocialCallbackDto
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Sign-in successful, or company selection is still required'
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof SocialCallbackDto === "undefined" ? Object : SocialCallbackDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], SocialAuthController.prototype, "callback", null);
-SocialAuthController = _ts_decorate([
-    ApiTags('Social Authentication'),
-    Controller('auth/social'),
-    _ts_param(0, Inject(SocialAuthService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof SocialAuthService === "undefined" ? Object : SocialAuthService
-    ])
-], SocialAuthController);

package/fesm/controllers/social-auth.controller.spec.js

@@ -1,75 +0,0 @@
-import { AUTH_MESSAGES, SOCIAL_AUTH_MESSAGES } from '../config';
-import { SocialProviderTypeEnum } from '../enums/social-provider-type.enum';
-import { SocialAuthController } from './social-auth.controller';
-const REDIRECT_URI = 'http://localhost:2001/auth/social/callback';
-describe('SocialAuthController', ()=>{
-    let controller;
-    let mockSocialAuthService;
-    beforeEach(()=>{
-        mockSocialAuthService = {
-            listEnabledProviders: jest.fn(),
-            createAuthorization: jest.fn(),
-            completeLogin: jest.fn()
-        };
-        controller = new SocialAuthController(mockSocialAuthService);
-    });
-    it('wraps the enabled provider list', async ()=>{
-        const providers = [
-            {
-                provider: SocialProviderTypeEnum.GOOGLE,
-                redirectUri: REDIRECT_URI
-            }
-        ];
-        mockSocialAuthService.listEnabledProviders.mockResolvedValue(providers);
-        const result = await controller.getProviders({
-            redirectUri: REDIRECT_URI
-        });
-        expect(result.data).toBe(providers);
-        expect(result.messageKey).toBe(SOCIAL_AUTH_MESSAGES.PROVIDERS_SUCCESS);
-        expect(mockSocialAuthService.listEnabledProviders).toHaveBeenCalledWith(REDIRECT_URI);
-    });
-    it('wraps the authorization URL', async ()=>{
-        mockSocialAuthService.createAuthorization.mockResolvedValue({
-            provider: SocialProviderTypeEnum.GOOGLE,
-            authorizationUrl: 'https://provider.test/consent',
-            state: 'state-token'
-        });
-        const result = await controller.authorize({
-            provider: SocialProviderTypeEnum.GOOGLE,
-            redirectUri: REDIRECT_URI
-        });
-        expect(result.data?.authorizationUrl).toBe('https://provider.test/consent');
-        expect(result.messageKey).toBe(SOCIAL_AUTH_MESSAGES.AUTHORIZE_SUCCESS);
-    });
-    it('wraps a completed sign-in', async ()=>{
-        mockSocialAuthService.completeLogin.mockResolvedValue({
-            accessToken: 'a',
-            refreshToken: 'r'
-        });
-        const result = await controller.callback({
-            code: 'code',
-            state: 'state-token',
-            redirectUri: REDIRECT_URI
-        });
-        expect(result.messageKey).toBe(SOCIAL_AUTH_MESSAGES.LOGIN_SUCCESS);
-        expect(result.data).toEqual(expect.objectContaining({
-            accessToken: 'a'
-        }));
-        expect(mockSocialAuthService.completeLogin).toHaveBeenCalledWith('code', 'state-token', REDIRECT_URI);
-    });
-    it('wraps a sign-in that still needs a company, like the password login does', async ()=>{
-        mockSocialAuthService.completeLogin.mockResolvedValue({
-            requiresSelection: true,
-            sessionId: 'sess-1'
-        });
-        const result = await controller.callback({
-            code: 'code',
-            state: 'state-token',
-            redirectUri: REDIRECT_URI
-        });
-        expect(result.messageKey).toBe(AUTH_MESSAGES.LOGIN_REQUIRES_SELECTION);
-        expect(result.data).toEqual(expect.objectContaining({
-            requiresSelection: true
-        }));
-    });
-});

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

@@ -1,213 +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 { JwtAuthGuard, PermissionGuard, RequirePermission, USER_PERMISSIONS } from '@flusys/nestjs-shared';
-import { Body, Controller, Inject, Post, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
-import { USER_PERMISSION_MESSAGES } from '../config';
-import { AssignUserBranchDto, AssignUserCompanyDto, UserBranchesResponseDto, UserCompaniesResponseDto } from '../dtos/user-permission.dto';
-import { PermissionType } from '../entities/user-company-permission.entity';
-import { UserPermissionService } from '../services/user-permission.service';
-export class UserPermissionController {
-    async assignUserCompany(dto) {
-        return this.processBatchPermissions(dto.userId, dto.items, PermissionType.COMPANY);
-    }
-    async getUserCompanies(userId) {
-        const permissions = await this.permissionService.findUserCompanies(userId);
-        return {
-            success: true,
-            message: 'User companies retrieved successfully',
-            messageKey: 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, PermissionType.BRANCH);
-    }
-    async getUserBranches(userId, companyId) {
-        const permissions = await this.permissionService.findUserBranches(userId, companyId);
-        return {
-            success: true,
-            message: 'User branches retrieved successfully',
-            messageKey: 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: USER_PERMISSION_MESSAGES.BATCH_SUCCESS,
-            messageVariables: {
-                added,
-                removed
-            }
-        };
-    }
-    constructor(permissionService){
-        _define_property(this, "permissionService", void 0);
-        this.permissionService = permissionService;
-    }
-}
-_ts_decorate([
-    Post('user-company/assign'),
-    RequirePermission(USER_PERMISSIONS.UPDATE),
-    ApiOperation({
-        summary: 'Batch assign/revoke user-company permissions'
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Company permissions updated successfully'
-    }),
-    ApiBody({
-        type: AssignUserCompanyDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof AssignUserCompanyDto === "undefined" ? Object : AssignUserCompanyDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserPermissionController.prototype, "assignUserCompany", null);
-_ts_decorate([
-    Post('get-user-company'),
-    RequirePermission(USER_PERMISSIONS.READ),
-    ApiOperation({
-        summary: 'Get user companies'
-    }),
-    ApiBody({
-        schema: {
-            properties: {
-                userId: {
-                    type: 'string'
-                }
-            },
-            required: [
-                'userId'
-            ]
-        }
-    }),
-    ApiResponse({
-        status: 200,
-        type: UserCompaniesResponseDto
-    }),
-    _ts_param(0, Body('userId')),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserPermissionController.prototype, "getUserCompanies", null);
-_ts_decorate([
-    Post('user-branch/assign'),
-    RequirePermission(USER_PERMISSIONS.UPDATE),
-    ApiOperation({
-        summary: 'Batch assign/revoke user-branch permissions'
-    }),
-    ApiResponse({
-        status: 200,
-        description: 'Branch permissions updated successfully'
-    }),
-    ApiBody({
-        type: AssignUserBranchDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof AssignUserBranchDto === "undefined" ? Object : AssignUserBranchDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], UserPermissionController.prototype, "assignUserBranch", null);
-_ts_decorate([
-    Post('get-user-branch'),
-    RequirePermission(USER_PERMISSIONS.READ),
-    ApiOperation({
-        summary: 'Get user branches'
-    }),
-    ApiBody({
-        schema: {
-            properties: {
-                userId: {
-                    type: 'string'
-                },
-                companyId: {
-                    type: 'string',
-                    description: 'Optional company ID to filter branches'
-                }
-            },
-            required: [
-                'userId'
-            ]
-        }
-    }),
-    ApiResponse({
-        status: 200,
-        type: UserBranchesResponseDto
-    }),
-    _ts_param(0, Body('userId')),
-    _ts_param(1, 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([
-    ApiTags('User Permissions'),
-    ApiBearerAuth(),
-    Controller('administration/permissions'),
-    UseGuards(JwtAuthGuard, PermissionGuard),
-    _ts_param(0, Inject(UserPermissionService)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof UserPermissionService === "undefined" ? Object : UserPermissionService
-    ])
-], UserPermissionController);

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

@@ -1,134 +0,0 @@
-import { UserPermissionController } from './user-permission.controller';
-import { PermissionType } from '../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(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', PermissionType.COMPANY);
-            expect(mockPermissionService.revokePermission).toHaveBeenCalledWith('user-1', 'company-2', 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', 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);
-        });
-    });
-});