@flusys/nestjs-auth 6.0.1 → 6.1.0

package/fesm/services/branch.service.js

@@ -25,14 +25,38 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
+import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { IPermissionSyncAdapter, PERMISSION_SYNC_ADAPTER } from '@flusys/nestjs-shared/interfaces';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
 import { applyCompanyFilter } from '@flusys/nestjs-shared/utils';
-import { Inject, Injectable, Scope } from '@nestjs/common';
+import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
+import { In } from 'typeorm';
 import { CompanyBranch } from '../entities/company-branch.entity';
+import { UserCompanyPermission } from '../entities/user-company-permission.entity';
 import { AuthConfigService } from './auth-config.service';
 import { AuthDataSourceProvider } from './auth-datasource.provider';
 export class BranchService extends ApiService {
+    async beforeDeleteOperation(dto, user, queryRunner) {
+        const branchIds = Array.isArray(dto.id) ? dto.id : [
+            dto.id
+        ];
+        await queryRunner.manager.getRepository(UserCompanyPermission).delete({
+            targetId: In(branchIds)
+        });
+        if (!this.permissionSyncAdapter?.onBranchDeleted) {
+            return;
+        }
+        const rows = await queryRunner.manager.getRepository(CompanyBranch).find({
+            where: {
+                id: In(branchIds)
+            },
+            select: [
+                'id',
+                'companyId'
+            ]
+        });
+        await Promise.all(rows.map((row)=>this.permissionSyncAdapter.onBranchDeleted(row.id, row.companyId)));
+    }
     // Query Customization
     async getSelectQuery(query, _user, select) {
         if (!select?.length) {
@@ -74,8 +98,8 @@ export class BranchService extends ApiService {
         }
         return result;
     }
-    constructor(cacheManager, utilsService, dataSourceProvider, authConfig){
-        super('company_branch', cacheManager, utilsService, BranchService.name, true, 'auth', CompanyBranch, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "authConfig", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.authConfig = authConfig;
+    constructor(cacheManager, utilsService, dataSourceProvider, authConfig, permissionSyncAdapter){
+        super('company_branch', cacheManager, utilsService, BranchService.name, true, 'auth', CompanyBranch, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "authConfig", void 0), _define_property(this, "permissionSyncAdapter", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.authConfig = authConfig, this.permissionSyncAdapter = permissionSyncAdapter;
     }
 }
 BranchService = _ts_decorate([
@@ -86,11 +110,14 @@ BranchService = _ts_decorate([
     _ts_param(1, Inject(UtilsService)),
     _ts_param(2, Inject(AuthDataSourceProvider)),
     _ts_param(3, Inject(AuthConfigService)),
+    _ts_param(4, Optional()),
+    _ts_param(4, Inject(PERMISSION_SYNC_ADAPTER)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof HybridCache === "undefined" ? Object : HybridCache,
         typeof UtilsService === "undefined" ? Object : UtilsService,
         typeof AuthDataSourceProvider === "undefined" ? Object : AuthDataSourceProvider,
-        typeof AuthConfigService === "undefined" ? Object : AuthConfigService
+        typeof AuthConfigService === "undefined" ? Object : AuthConfigService,
+        typeof IPermissionSyncAdapter === "undefined" ? Object : IPermissionSyncAdapter
     ])
 ], BranchService);

package/fesm/services/branch.service.spec.js

@@ -0,0 +1,150 @@
+import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
+import { BranchService } from './branch.service';
+import { CompanyBranch } from '../entities/company-branch.entity';
+import { UserCompanyPermission } from '../entities/user-company-permission.entity';
+describe('BranchService', ()=>{
+    let service;
+    let mockRepo;
+    let mockAuthConfig;
+    let mockPermissionSyncAdapter;
+    let mockQueryRunner;
+    beforeEach(()=>{
+        mockRepo = createMockRepository();
+        Object.assign(mockRepo.createQueryBuilder(), {
+            leftJoinAndSelect: jest.fn().mockReturnThis(),
+            addOrderBy: jest.fn().mockReturnThis()
+        });
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        mockAuthConfig = {
+            isCompanyFeatureEnabled: jest.fn().mockReturnValue(false)
+        };
+        mockPermissionSyncAdapter = {
+            onBranchDeleted: jest.fn()
+        };
+        service = new BranchService({}, {}, mockDataSourceProvider, mockAuthConfig, mockPermissionSyncAdapter);
+        const permissionRepo = createMockRepository();
+        const branchRepo = createMockRepository();
+        branchRepo.find.mockResolvedValue([]);
+        mockQueryRunner = {
+            manager: {
+                getRepository: jest.fn().mockImplementation((entity)=>{
+                    if (entity === UserCompanyPermission) return permissionRepo;
+                    if (entity === CompanyBranch) return branchRepo;
+                    throw new Error('Unexpected entity');
+                })
+            }
+        };
+    });
+    describe('beforeDeleteOperation', ()=>{
+        it('deletes user permissions targeting the deleted branch ids', async ()=>{
+            await service.beforeDeleteOperation({
+                id: [
+                    'branch-1',
+                    'branch-2'
+                ]
+            }, null, mockQueryRunner);
+            const permissionRepo = mockQueryRunner.manager.getRepository(UserCompanyPermission);
+            expect(permissionRepo.delete).toHaveBeenCalledWith({
+                targetId: expect.anything()
+            });
+        });
+        it('handles a single (non-array) branch id', async ()=>{
+            await service.beforeDeleteOperation({
+                id: 'branch-1'
+            }, null, mockQueryRunner);
+            const permissionRepo = mockQueryRunner.manager.getRepository(UserCompanyPermission);
+            expect(permissionRepo.delete).toHaveBeenCalled();
+        });
+        it('does nothing further when no permission sync adapter is configured', async ()=>{
+            service = new BranchService({}, {}, createMockDataSourceProvider(mockRepo), mockAuthConfig, undefined);
+            await expect(service.beforeDeleteOperation({
+                id: [
+                    'branch-1'
+                ]
+            }, null, mockQueryRunner)).resolves.toBeUndefined();
+        });
+        it('notifies the permission sync adapter for each deleted branch', async ()=>{
+            const branchRepo = mockQueryRunner.manager.getRepository(CompanyBranch);
+            branchRepo.find.mockResolvedValue([
+                {
+                    id: 'branch-1',
+                    companyId: 'company-1'
+                }
+            ]);
+            await service.beforeDeleteOperation({
+                id: [
+                    'branch-1'
+                ]
+            }, null, mockQueryRunner);
+            expect(mockPermissionSyncAdapter.onBranchDeleted).toHaveBeenCalledWith('branch-1', 'company-1');
+        });
+    });
+    describe('getSelectQuery', ()=>{
+        it('applies the default selected fields when none are provided', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            const { isRaw } = await service.getSelectQuery(qb, null);
+            expect(qb.select).toHaveBeenCalledWith(expect.arrayContaining([
+                'company_branch.id',
+                'company_branch.name',
+                'company_branch.slug'
+            ]));
+            expect(isRaw).toBe(false);
+        });
+        it('honors an explicit select list', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            await service.getSelectQuery(qb, null, [
+                'id',
+                'name'
+            ]);
+            expect(qb.select).toHaveBeenCalledWith([
+                'company_branch.id',
+                'company_branch.name'
+            ]);
+        });
+    });
+    describe('getGlobalSearchQuery', ()=>{
+        it('adds a LIKE search clause across name/slug/email', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            await service.getGlobalSearchQuery(qb, 'acme');
+            expect(qb.andWhere).toHaveBeenCalledWith(expect.stringContaining('company_branch.name LIKE'), {
+                search: '%acme%'
+            });
+        });
+    });
+    describe('getExtraManipulateQuery', ()=>{
+        it('applies a company filter when company feature is enabled and no explicit companyId filter is present', async ()=>{
+            mockAuthConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const qb = mockRepo.createQueryBuilder();
+            await service.getExtraManipulateQuery(qb, {
+                filter: {}
+            }, {
+                id: 'user-1',
+                companyId: 'company-1'
+            });
+            expect(qb.andWhere).toHaveBeenCalledWith('company_branch.company_id = :companyId', {
+                companyId: 'company-1'
+            });
+        });
+        it('does not apply a company filter when companyId is explicitly provided in the filter', async ()=>{
+            mockAuthConfig.isCompanyFeatureEnabled.mockReturnValue(true);
+            const qb = mockRepo.createQueryBuilder();
+            await service.getExtraManipulateQuery(qb, {
+                filter: {
+                    companyId: 'explicit-company'
+                }
+            }, {
+                id: 'user-1',
+                companyId: 'company-1'
+            });
+            expect(qb.andWhere).not.toHaveBeenCalledWith('company_branch.company_id = :companyId', expect.anything());
+        });
+        it('does not apply a company filter when the company feature is disabled', async ()=>{
+            mockAuthConfig.isCompanyFeatureEnabled.mockReturnValue(false);
+            const qb = mockRepo.createQueryBuilder();
+            await service.getExtraManipulateQuery(qb, {
+                filter: {}
+            }, null);
+            expect(qb.andWhere).not.toHaveBeenCalledWith('company_branch.company_id = :companyId', expect.anything());
+        });
+    });
+});

package/fesm/services/company-selection-session.service.spec.js

@@ -0,0 +1,86 @@
+import { CompanySelectionSessionService } from './company-selection-session.service';
+describe('CompanySelectionSessionService', ()=>{
+    let service;
+    let mockCacheManager;
+    beforeEach(()=>{
+        mockCacheManager = {
+            set: jest.fn(),
+            get: jest.fn(),
+            del: jest.fn()
+        };
+        service = new CompanySelectionSessionService(mockCacheManager);
+    });
+    describe('createSession', ()=>{
+        it('stores a session in the cache and returns a session id', async ()=>{
+            const sessionId = await service.createSession('user-1');
+            expect(typeof sessionId).toBe('string');
+            expect(sessionId.length).toBeGreaterThan(0);
+            expect(mockCacheManager.set).toHaveBeenCalledWith(`auth:session:${sessionId}`, expect.objectContaining({
+                sessionId,
+                userId: 'user-1'
+            }), 5 * 60 * 1000);
+        });
+        it('generates unique session ids on successive calls', async ()=>{
+            const first = await service.createSession('user-1');
+            const second = await service.createSession('user-1');
+            expect(first).not.toBe(second);
+        });
+    });
+    describe('getSession', ()=>{
+        it('returns null when no session is cached', async ()=>{
+            mockCacheManager.get.mockResolvedValue(undefined);
+            const result = await service.getSession('missing-session');
+            expect(result).toBeNull();
+        });
+        it('returns the session when present and not expired', async ()=>{
+            const session = {
+                sessionId: 'sess-1',
+                userId: 'user-1',
+                createdAt: new Date(),
+                expiresAt: new Date(Date.now() + 60_000)
+            };
+            mockCacheManager.get.mockResolvedValue(session);
+            const result = await service.getSession('sess-1');
+            expect(result).toEqual(session);
+            expect(mockCacheManager.get).toHaveBeenCalledWith('auth:session:sess-1');
+        });
+        it('deletes and returns null when the cached session has expired', async ()=>{
+            const session = {
+                sessionId: 'sess-1',
+                userId: 'user-1',
+                createdAt: new Date(Date.now() - 10 * 60_000),
+                expiresAt: new Date(Date.now() - 60_000)
+            };
+            mockCacheManager.get.mockResolvedValue(session);
+            const result = await service.getSession('sess-1');
+            expect(result).toBeNull();
+            expect(mockCacheManager.del).toHaveBeenCalledWith('auth:session:sess-1');
+        });
+    });
+    describe('consumeSession', ()=>{
+        it('returns and deletes the session when present', async ()=>{
+            const session = {
+                sessionId: 'sess-1',
+                userId: 'user-1',
+                createdAt: new Date(),
+                expiresAt: new Date(Date.now() + 60_000)
+            };
+            mockCacheManager.get.mockResolvedValue(session);
+            const result = await service.consumeSession('sess-1');
+            expect(result).toEqual(session);
+            expect(mockCacheManager.del).toHaveBeenCalledWith('auth:session:sess-1');
+        });
+        it('returns null and does not delete when session is missing', async ()=>{
+            mockCacheManager.get.mockResolvedValue(undefined);
+            const result = await service.consumeSession('missing');
+            expect(result).toBeNull();
+            expect(mockCacheManager.del).not.toHaveBeenCalled();
+        });
+    });
+    describe('deleteSession', ()=>{
+        it('deletes the session by key', async ()=>{
+            await service.deleteSession('sess-1');
+            expect(mockCacheManager.del).toHaveBeenCalledWith('auth:session:sess-1');
+        });
+    });
+});

package/fesm/services/company.service.js

@@ -25,12 +25,40 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-import { HybridCache, ApiService } from '@flusys/nestjs-shared/classes';
+import { ApiService, HybridCache } from '@flusys/nestjs-shared/classes';
+import { IPermissionSyncAdapter, PERMISSION_SYNC_ADAPTER } from '@flusys/nestjs-shared/interfaces';
 import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { Inject, Injectable, Scope } from '@nestjs/common';
+import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
+import { In } from 'typeorm';
+import { CompanyBranch } from '../entities/company-branch.entity';
 import { Company } from '../entities/company.entity';
+import { UserCompanyPermission } from '../entities/user-company-permission.entity';
 import { AuthDataSourceProvider } from './auth-datasource.provider';
 export class CompanyService extends ApiService {
+    async beforeDeleteOperation(dto, user, queryRunner) {
+        const companyIds = Array.isArray(dto.id) ? dto.id : [
+            dto.id
+        ];
+        const branchRows = await queryRunner.manager.getRepository(CompanyBranch).find({
+            where: {
+                companyId: In(companyIds)
+            },
+            select: [
+                'id'
+            ]
+        });
+        const targetIds = [
+            ...companyIds,
+            ...branchRows.map((row)=>row.id)
+        ];
+        await queryRunner.manager.getRepository(UserCompanyPermission).delete({
+            targetId: In(targetIds)
+        });
+        if (!this.permissionSyncAdapter?.onCompanyDeleted) {
+            return;
+        }
+        await Promise.all(companyIds.map((companyId)=>this.permissionSyncAdapter.onCompanyDeleted(companyId)));
+    }
     // Query Customization
     async getSelectQuery(query, _user, select) {
         if (!select?.length) {
@@ -59,8 +87,8 @@ export class CompanyService extends ApiService {
             isRaw: false
         };
     }
-    constructor(cacheManager, utilsService, dataSourceProvider){
-        super('company', cacheManager, utilsService, CompanyService.name, true, 'auth', Company, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService;
+    constructor(cacheManager, utilsService, dataSourceProvider, permissionSyncAdapter){
+        super('company', cacheManager, utilsService, CompanyService.name, true, 'auth', Company, dataSourceProvider), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), _define_property(this, "permissionSyncAdapter", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService, this.permissionSyncAdapter = permissionSyncAdapter;
     }
 }
 CompanyService = _ts_decorate([
@@ -70,10 +98,13 @@ CompanyService = _ts_decorate([
     _ts_param(0, Inject('CACHE_INSTANCE')),
     _ts_param(1, Inject(UtilsService)),
     _ts_param(2, Inject(AuthDataSourceProvider)),
+    _ts_param(3, Optional()),
+    _ts_param(3, Inject(PERMISSION_SYNC_ADAPTER)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof HybridCache === "undefined" ? Object : HybridCache,
         typeof UtilsService === "undefined" ? Object : UtilsService,
-        typeof AuthDataSourceProvider === "undefined" ? Object : AuthDataSourceProvider
+        typeof AuthDataSourceProvider === "undefined" ? Object : AuthDataSourceProvider,
+        typeof IPermissionSyncAdapter === "undefined" ? Object : IPermissionSyncAdapter
     ])
 ], CompanyService);

package/fesm/services/company.service.spec.js

@@ -0,0 +1,109 @@
+import { createMockDataSourceProvider, createMockRepository } from '@test-utils/mocks/repository.mock';
+import { CompanyService } from './company.service';
+import { CompanyBranch } from '../entities/company-branch.entity';
+import { UserCompanyPermission } from '../entities/user-company-permission.entity';
+describe('CompanyService', ()=>{
+    let service;
+    let mockRepo;
+    let mockPermissionSyncAdapter;
+    let mockQueryRunner;
+    let branchRepo;
+    let permissionRepo;
+    beforeEach(()=>{
+        mockRepo = createMockRepository();
+        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
+        mockPermissionSyncAdapter = {
+            onCompanyDeleted: jest.fn()
+        };
+        service = new CompanyService({}, {}, mockDataSourceProvider, mockPermissionSyncAdapter);
+        branchRepo = createMockRepository();
+        branchRepo.find.mockResolvedValue([]);
+        permissionRepo = createMockRepository();
+        mockQueryRunner = {
+            manager: {
+                getRepository: jest.fn().mockImplementation((entity)=>{
+                    if (entity === CompanyBranch) return branchRepo;
+                    if (entity === UserCompanyPermission) return permissionRepo;
+                    throw new Error('Unexpected entity');
+                })
+            }
+        };
+    });
+    describe('beforeDeleteOperation', ()=>{
+        it('deletes permissions for the companies and their branches', async ()=>{
+            branchRepo.find.mockResolvedValue([
+                {
+                    id: 'branch-1'
+                }
+            ]);
+            await service.beforeDeleteOperation({
+                id: [
+                    'company-1'
+                ]
+            }, null, mockQueryRunner);
+            const deleteArg = permissionRepo.delete.mock.calls[0][0];
+            expect(deleteArg.targetId._value).toEqual(expect.arrayContaining([
+                'company-1',
+                'branch-1'
+            ]));
+        });
+        it('handles a single (non-array) company id', async ()=>{
+            await service.beforeDeleteOperation({
+                id: 'company-1'
+            }, null, mockQueryRunner);
+            expect(branchRepo.find).toHaveBeenCalledWith(expect.objectContaining({
+                where: {
+                    companyId: expect.anything()
+                }
+            }));
+        });
+        it('does nothing further when no permission sync adapter is configured', async ()=>{
+            service = new CompanyService({}, {}, createMockDataSourceProvider(mockRepo), undefined);
+            await expect(service.beforeDeleteOperation({
+                id: [
+                    'company-1'
+                ]
+            }, null, mockQueryRunner)).resolves.toBeUndefined();
+        });
+        it('notifies the permission sync adapter for each deleted company', async ()=>{
+            await service.beforeDeleteOperation({
+                id: [
+                    'company-1',
+                    'company-2'
+                ]
+            }, null, mockQueryRunner);
+            expect(mockPermissionSyncAdapter.onCompanyDeleted).toHaveBeenCalledWith('company-1');
+            expect(mockPermissionSyncAdapter.onCompanyDeleted).toHaveBeenCalledWith('company-2');
+        });
+    });
+    describe('getSelectQuery', ()=>{
+        it('applies the default selected fields when none are provided', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            const { isRaw } = await service.getSelectQuery(qb, null);
+            expect(qb.select).toHaveBeenCalledWith(expect.arrayContaining([
+                'company.id',
+                'company.name',
+                'company.slug'
+            ]));
+            expect(isRaw).toBe(false);
+        });
+        it('honors an explicit select list', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            await service.getSelectQuery(qb, null, [
+                'id'
+            ]);
+            expect(qb.select).toHaveBeenCalledWith([
+                'company.id'
+            ]);
+        });
+    });
+    describe('getGlobalSearchQuery', ()=>{
+        it('adds a LIKE search clause across name/slug/email', async ()=>{
+            const qb = mockRepo.createQueryBuilder();
+            await service.getGlobalSearchQuery(qb, 'acme');
+            expect(qb.andWhere).toHaveBeenCalledWith(expect.stringContaining('company.name LIKE'), {
+                search: '%acme%'
+            });
+        });
+    });
+});

package/fesm/services/user-permission.service.js

@@ -26,7 +26,8 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { LogAction } from '@flusys/nestjs-shared';
-import { ConflictException, Inject, Injectable, NotFoundException, Scope } from '@nestjs/common';
+import { IPermissionSyncAdapter, PERMISSION_SYNC_ADAPTER } from '@flusys/nestjs-shared/interfaces';
+import { ConflictException, Inject, Injectable, NotFoundException, Optional, Scope } from '@nestjs/common';
 import { USER_PERMISSION_MESSAGES } from '../config';
 import { PermissionType, UserCompanyPermission } from '../entities/user-company-permission.entity';
 import { AuthDataSourceProvider } from './auth-datasource.provider';
@@ -92,7 +93,7 @@ export class UserPermissionService {
             throw error;
         }
     }
-    /** Revoke permission from user */ async revokePermission(userId, targetId, type) {
+    async revokePermission(userId, targetId, type) {
         const repository = await this.getRepository();
         const typeName = type === PermissionType.COMPANY ? 'company' : 'branch';
         const permission = await repository.findOne({
@@ -100,7 +101,10 @@ export class UserPermissionService {
                 userId,
                 targetId,
                 permissionType: type
-            }
+            },
+            relations: [
+                type === PermissionType.BRANCH ? 'branch' : 'company'
+            ]
         });
         if (!permission) {
             throw new NotFoundException({
@@ -111,7 +115,29 @@ export class UserPermissionService {
                 }
             });
         }
+        const companyId = type === PermissionType.COMPANY ? targetId : permission.branch?.companyId;
         await repository.remove(permission);
+        if (type === PermissionType.COMPANY) {
+            const revokedBranchIds = await this.revokeBranchPermissionsForCompany(repository, userId, targetId);
+            await this.permissionSyncAdapter?.onUserCompanyAccessRevoked?.(userId, targetId);
+            await Promise.all(revokedBranchIds.map((branchId)=>this.permissionSyncAdapter?.onUserBranchAccessRevoked?.(userId, branchId, targetId)));
+        } else {
+            if (companyId) await this.permissionSyncAdapter?.onUserBranchAccessRevoked?.(userId, targetId, companyId);
+        }
+    }
+    async revokeBranchPermissionsForCompany(repository, userId, companyId) {
+        const branchPermissions = await repository.createQueryBuilder('permission').innerJoin('permission.branch', 'branch').where('permission.userId = :userId', {
+            userId
+        }).andWhere('permission.permissionType = :type', {
+            type: PermissionType.BRANCH
+        }).andWhere('branch.companyId = :companyId', {
+            companyId
+        }).getMany();
+        if (branchPermissions.length === 0) {
+            return [];
+        }
+        await repository.remove(branchPermissions);
+        return branchPermissions.map((permission)=>permission.targetId);
     }
     /** Find user branch permissions with optional company filter */ async findUserBranches(userId, companyId) {
         const repository = await this.getRepository();
@@ -127,12 +153,14 @@ export class UserPermissionService {
         }
         return queryBuilder.getMany();
     }
-    constructor(dataSourceProvider){
+    constructor(dataSourceProvider, permissionSyncAdapter){
         _define_property(this, "dataSourceProvider", void 0);
+        _define_property(this, "permissionSyncAdapter", void 0);
         _define_property(this, "_repository", void 0);
         // Convenience Methods
         _define_property(this, "findUserCompanies", void 0);
         this.dataSourceProvider = dataSourceProvider;
+        this.permissionSyncAdapter = permissionSyncAdapter;
         this._repository = null;
         this.findUserCompanies = (userId)=>this.findUserPermissions(userId, PermissionType.COMPANY);
     }
@@ -168,8 +196,11 @@ UserPermissionService = _ts_decorate([
         scope: Scope.REQUEST
     }),
     _ts_param(0, Inject(AuthDataSourceProvider)),
+    _ts_param(1, Optional()),
+    _ts_param(1, Inject(PERMISSION_SYNC_ADAPTER)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
-        typeof AuthDataSourceProvider === "undefined" ? Object : AuthDataSourceProvider
+        typeof AuthDataSourceProvider === "undefined" ? Object : AuthDataSourceProvider,
+        typeof IPermissionSyncAdapter === "undefined" ? Object : IPermissionSyncAdapter
     ])
 ], UserPermissionService);