@flusys/nestjs-auth 7.0.1 → 7.1.0

package/cjs/services/authentication.service.spec.js

@@ -131,6 +131,7 @@ describe('AuthenticationService', ()=>{
     let mockUserEnricher;
     let companyFeatureEnabled;
     let emailVerificationEnabled;
+    let signUpEnabled;
     function buildService(overrides = {}) {
         return new _authenticationservice.AuthenticationService(mockJwtService, mockAuthConfig, 'cacheManager' in overrides ? overrides.cacheManager : mockCacheManager, 'dataSourceProvider' in overrides ? overrides.dataSourceProvider : mockDataSourceProvider, 'sessionService' in overrides ? overrides.sessionService : mockSessionService, 'authEmailService' in overrides ? overrides.authEmailService : mockAuthEmailService, 'userEnricher' in overrides ? overrides.userEnricher : mockUserEnricher, 'notificationAdapter' in overrides ? overrides.notificationAdapter : undefined);
     }
@@ -147,6 +148,7 @@ describe('AuthenticationService', ()=>{
         });
         companyFeatureEnabled = false;
         emailVerificationEnabled = false;
+        signUpEnabled = true;
         mockJwtService = {
             sign: jest.fn().mockReturnValue('signed-token'),
             verify: jest.fn()
@@ -154,6 +156,7 @@ describe('AuthenticationService', ()=>{
         mockAuthConfig = {
             isCompanyFeatureEnabled: jest.fn().mockImplementation(()=>companyFeatureEnabled),
             isEmailVerificationEnabled: jest.fn().mockImplementation(()=>emailVerificationEnabled),
+            isSignUpEnabled: jest.fn().mockImplementation(()=>signUpEnabled),
             getJwtSecret: jest.fn().mockReturnValue('jwt-secret'),
             getJwtExpiration: jest.fn().mockReturnValue('1h'),
             getRefreshTokenSecret: jest.fn().mockReturnValue('refresh-secret'),
@@ -167,6 +170,7 @@ describe('AuthenticationService', ()=>{
         mockDataSourceProvider = {
             isCompanyFeatureEnabled: jest.fn().mockImplementation(()=>companyFeatureEnabled),
             isEmailVerificationEnabled: jest.fn().mockImplementation(()=>emailVerificationEnabled),
+            isSignUpEnabled: jest.fn().mockImplementation(()=>signUpEnabled),
             getRepository: jest.fn().mockImplementation(async (entity)=>{
                 if (entity === _appuserentity.AppUser) return userRepo;
                 if (entity === _companyentity.Company) return companyRepo;
@@ -341,6 +345,20 @@ describe('AuthenticationService', ()=>{
                 password: 'Password1!'
             })).rejects.toThrow(_common.BadRequestException);
         });
+        it('throws BadRequestException when the email belongs to a permanently deleted account', async ()=>{
+            userRepo.findOne.mockResolvedValue(buildUser({
+                deletedAt: new Date()
+            }));
+            const service = buildService();
+            await expect(service.register({
+                email: 'user@example.com',
+                name: 'Test',
+                password: 'Password1!'
+            })).rejects.toThrow(_common.BadRequestException);
+            expect(userRepo.findOne).toHaveBeenCalledWith(expect.objectContaining({
+                withDeleted: true
+            }));
+        });
         it('routes existing users to company registration when the company feature is enabled', async ()=>{
             companyFeatureEnabled = true;
             userRepo.findOne.mockResolvedValue(buildUser());
@@ -362,6 +380,16 @@ describe('AuthenticationService', ()=>{
                 accessToken: expect.any(String)
             }));
         });
+        it('throws BadRequestException for a new user when sign-up is disabled', async ()=>{
+            signUpEnabled = false;
+            userRepo.findOne.mockResolvedValue(null);
+            const service = buildService();
+            await expect(service.register({
+                email: 'new@example.com',
+                name: 'New User',
+                password: 'Password1!'
+            })).rejects.toThrow(_common.BadRequestException);
+        });
         it('sends a verification email and returns requiresEmailVerification when email verification is enabled', async ()=>{
             emailVerificationEnabled = true;
             userRepo.findOne.mockResolvedValue(null);
@@ -868,6 +896,36 @@ describe('AuthenticationService', ()=>{
             })).rejects.toThrow(_common.BadRequestException);
             expect(queryRunner.rollbackTransaction).toHaveBeenCalled();
         });
+        it('throws BadRequestException when the email belongs to a permanently deleted account', async ()=>{
+            const queryRunner = {
+                connect: jest.fn(),
+                startTransaction: jest.fn(),
+                commitTransaction: jest.fn(),
+                rollbackTransaction: jest.fn(),
+                release: jest.fn(),
+                manager: {
+                    findOne: jest.fn().mockResolvedValue(buildUser({
+                        deletedAt: new Date()
+                    })),
+                    create: jest.fn(),
+                    save: jest.fn()
+                }
+            };
+            mockDataSourceProvider.getDataSource.mockResolvedValue({
+                createQueryRunner: ()=>queryRunner
+            });
+            const service = buildService();
+            await expect(service.createUserFromPendingRegistration({
+                email: 'user@example.com',
+                name: 'Test',
+                passwordHash: 'hash'
+            })).rejects.toThrow(_common.BadRequestException);
+            expect(queryRunner.manager.findOne).toHaveBeenCalledWith(_appuserentity.AppUser, expect.objectContaining({
+                withDeleted: true
+            }));
+            expect(queryRunner.manager.create).not.toHaveBeenCalled();
+            expect(queryRunner.rollbackTransaction).toHaveBeenCalled();
+        });
         it('creates the user with the email marked as verified', async ()=>{
             const queryRunner = {
                 connect: jest.fn(),

package/cjs/services/index.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 _export_star(require("./authentication.service"), exports);
 _export_star(require("./auth-email.service"), exports);
 _export_star(require("./company-selection-session.service"), exports);
+_export_star(require("./social-auth.service"), exports);
+_export_star(require("./social-auth-config.service"), exports);
 _export_star(require("./user.service"), exports);
 _export_star(require("./company.service"), exports);
 _export_star(require("./branch.service"), exports);

package/cjs/services/social-auth-config.service.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SocialAuthConfigService", {
+    enumerable: true,
+    get: function() {
+        return SocialAuthConfigService;
+    }
+});
+const _classes = require("@flusys/nestjs-shared/classes");
+const _modules = require("@flusys/nestjs-shared/modules");
+const _common = require("@nestjs/common");
+const _typeorm = require("typeorm");
+const _config = require("../config");
+const _socialauthconfigentity = require("../entities/social-auth-config.entity");
+const _authdatasourceprovider = require("./auth-datasource.provider");
+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 SocialAuthConfigService = class SocialAuthConfigService extends _classes.ApiService {
+    async beforeInsertOperation(dto, _user, _queryRunner) {
+        for (const entry of Array.isArray(dto) ? dto : [
+            dto
+        ]){
+            await this.ensureProviderUnclaimed(entry.provider);
+        }
+    }
+    async beforeUpdateOperation(dto, _user, _queryRunner) {
+        for (const entry of Array.isArray(dto) ? dto : [
+            dto
+        ]){
+            if (entry.provider) await this.ensureProviderUnclaimed(entry.provider, entry.id);
+        }
+    }
+    async ensureProviderUnclaimed(provider, exceptId) {
+        await this.ensureDataSourceRepository();
+        const existing = await this.repository.findOne({
+            where: {
+                provider,
+                deletedAt: (0, _typeorm.IsNull)(),
+                ...exceptId ? {
+                    id: (0, _typeorm.Not)(exceptId)
+                } : {}
+            }
+        });
+        if (existing) {
+            throw new _common.ConflictException({
+                message: `Social provider "${provider}" is already configured`,
+                messageKey: _config.SOCIAL_AUTH_CONFIG_MESSAGES.PROVIDER_ALREADY_CONFIGURED,
+                messageVariables: {
+                    provider
+                }
+            });
+        }
+    }
+    async getExtraManipulateQuery(query, filterDto, user) {
+        const result = await super.getExtraManipulateQuery(query, filterDto, user);
+        query.orderBy(`${this.entityName}.provider`, 'ASC');
+        return result;
+    }
+    constructor(cacheManager, utilsService, dataSourceProvider){
+        super(_config.AUTH_EVENT_ENTITIES.SOCIAL_AUTH_CONFIG, cacheManager, utilsService, SocialAuthConfigService.name, true, _config.AUTH_EVENT_MODULE, dataSourceProvider, _socialauthconfigentity.SocialAuthConfig), _define_property(this, "cacheManager", void 0), _define_property(this, "utilsService", void 0), this.cacheManager = cacheManager, this.utilsService = utilsService;
+    }
+};
+SocialAuthConfigService = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)('CACHE_INSTANCE')),
+    _ts_param(1, (0, _common.Inject)(_modules.UtilsService)),
+    _ts_param(2, (0, _common.Inject)(_authdatasourceprovider.AuthDataSourceProvider)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache,
+        typeof _modules.UtilsService === "undefined" ? Object : _modules.UtilsService,
+        typeof _authdatasourceprovider.AuthDataSourceProvider === "undefined" ? Object : _authdatasourceprovider.AuthDataSourceProvider
+    ])
+], SocialAuthConfigService);

package/cjs/services/social-auth-config.service.spec.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _repositorymock = require("@test-utils/mocks/repository.mock");
+const _typeorm = require("typeorm");
+const _socialprovidertypeenum = require("../enums/social-provider-type.enum");
+const _socialauthconfigservice = require("./social-auth-config.service");
+describe('SocialAuthConfigService', ()=>{
+    let repo;
+    let service;
+    beforeEach(()=>{
+        repo = (0, _repositorymock.createMockRepository)();
+        const dataSourceProvider = {
+            getRepository: jest.fn().mockResolvedValue(repo)
+        };
+        service = new _socialauthconfigservice.SocialAuthConfigService({
+            get: jest.fn(),
+            set: jest.fn(),
+            del: jest.fn()
+        }, {}, dataSourceProvider);
+    });
+    const beforeInsert = (dto)=>service.beforeInsertOperation(dto, null, {});
+    const beforeUpdate = (dto)=>service.beforeUpdateOperation(dto, null, {});
+    it('allows the first configuration of a provider', async ()=>{
+        repo.findOne.mockResolvedValue(null);
+        await expect(beforeInsert({
+            provider: _socialprovidertypeenum.SocialProviderTypeEnum.GOOGLE
+        })).resolves.toBeUndefined();
+    });
+    it('rejects a second row for a provider that is already configured', async ()=>{
+        repo.findOne.mockResolvedValue({
+            id: 'existing'
+        });
+        await expect(beforeInsert({
+            provider: _socialprovidertypeenum.SocialProviderTypeEnum.GOOGLE
+        })).rejects.toThrow(_common.ConflictException);
+    });
+    it('checks every provider in a batch insert', async ()=>{
+        repo.findOne.mockResolvedValue(null);
+        await beforeInsert([
+            {
+                provider: _socialprovidertypeenum.SocialProviderTypeEnum.GOOGLE
+            },
+            {
+                provider: _socialprovidertypeenum.SocialProviderTypeEnum.FACEBOOK
+            }
+        ]);
+        expect(repo.findOne).toHaveBeenCalledTimes(2);
+    });
+    it('lets a row keep its own provider on update', async ()=>{
+        repo.findOne.mockResolvedValue(null);
+        await beforeUpdate({
+            id: 'config-1',
+            provider: _socialprovidertypeenum.SocialProviderTypeEnum.GOOGLE
+        });
+        expect(repo.findOne).toHaveBeenCalledWith(expect.objectContaining({
+            where: expect.objectContaining({
+                id: (0, _typeorm.Not)('config-1')
+            })
+        }));
+    });
+    it('skips the check for an update that does not touch the provider', async ()=>{
+        await beforeUpdate({
+            id: 'config-1',
+            isEnabled: false
+        });
+        expect(repo.findOne).not.toHaveBeenCalled();
+    });
+});

package/cjs/services/social-auth.service.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SocialAuthService", {
+    enumerable: true,
+    get: function() {
+        return SocialAuthService;
+    }
+});
+const _nestjsshared = require("@flusys/nestjs-shared");
+const _classes = require("@flusys/nestjs-shared/classes");
+const _constants = require("@flusys/nestjs-shared/constants");
+const _common = require("@nestjs/common");
+const _crypto = require("crypto");
+const _typeorm = require("typeorm");
+const _config = require("../config");
+const _appuserentity = require("../entities/app-user.entity");
+const _socialauthconfigentity = require("../entities/social-auth-config.entity");
+const _socialprovidertypeenum = require("../enums/social-provider-type.enum");
+const _socialproviderregistry = require("../providers/social-provider.registry");
+const _authdatasourceprovider = require("./auth-datasource.provider");
+const _authenticationservice = require("./authentication.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 SocialAuthService = class SocialAuthService {
+    async listEnabledProviders(redirectUri) {
+        const repository = await this.dataSourceProvider.getRepository(_socialauthconfigentity.SocialAuthConfig);
+        const configs = await repository.find({
+            where: {
+                isEnabled: true,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        return configs.filter((config)=>!!config.clientId && !!config.clientSecret).map((config)=>({
+                provider: config.provider,
+                redirectUri
+            }));
+    }
+    async createAuthorization(provider, redirectUri) {
+        const config = await this.getUsableConfig(provider);
+        const state = (0, _crypto.randomBytes)(24).toString('hex');
+        await this.getCache().set(this.stateKey(state), {
+            provider,
+            redirectUri
+        }, _config.SOCIAL_STATE_TTL_MS);
+        return {
+            provider,
+            authorizationUrl: (0, _socialproviderregistry.getSocialProvider)(provider).buildAuthorizationUrl(this.toCredentials(config, redirectUri), state),
+            state
+        };
+    }
+    async completeLogin(code, state, redirectUri) {
+        const provider = await this.consumeState(state, redirectUri);
+        const config = await this.getUsableConfig(provider);
+        const profile = await (0, _socialproviderregistry.getSocialProvider)(provider).fetchProfile(this.toCredentials(config, redirectUri), code);
+        if (!profile.providerUserId) {
+            throw new _common.UnauthorizedException({
+                message: `${provider} did not return an account identifier`,
+                messageKey: _config.SOCIAL_AUTH_MESSAGES.PROFILE_INCOMPLETE,
+                messageVariables: {
+                    provider
+                }
+            });
+        }
+        const user = await this.resolveUser(provider, profile);
+        const response = await this.authService.issueLoginForUser(user);
+        this.publishSocialEvent(_config.AUTH_EVENT_ENTITIES.SESSION, _config.AUTH_EVENT_ACTIONS.SOCIAL_LOGGED_IN, user, provider);
+        return response;
+    }
+    async resolveUser(provider, profile) {
+        this.ensureVerifiedEmail(provider, profile);
+        const userRepository = await this.dataSourceProvider.getRepository(_appuserentity.AppUser);
+        const existing = await userRepository.findOne({
+            where: {
+                email: profile.email
+            },
+            withDeleted: true
+        });
+        if (existing?.deletedAt) {
+            throw new _common.UnauthorizedException({
+                message: 'This account has been permanently deleted. Please contact your system administrator.',
+                messageKey: _config.SOCIAL_AUTH_MESSAGES.ACCOUNT_DELETED
+            });
+        }
+        if (existing) {
+            // The provider already proved ownership of this email (ensureVerifiedEmail above),
+            // so a social login carries at least as much proof as clicking a verification link.
+            if (!existing.emailVerified) {
+                existing.emailVerified = true;
+                await userRepository.save(existing);
+            }
+            return existing;
+        }
+        const user = await this.registerUser(provider, userRepository, profile);
+        this.publishSocialEvent(_config.AUTH_EVENT_ENTITIES.USER, _config.AUTH_EVENT_ACTIONS.REGISTERED, user, provider);
+        return user;
+    }
+    ensureVerifiedEmail(provider, profile) {
+        if (!profile.email) {
+            throw new _common.UnauthorizedException({
+                message: `${provider} did not share an email address`,
+                messageKey: _config.SOCIAL_AUTH_MESSAGES.EMAIL_REQUIRED,
+                messageVariables: {
+                    provider
+                }
+            });
+        }
+        if (!profile.emailVerified) {
+            throw new _common.UnauthorizedException({
+                message: `${provider} has not verified this email address`,
+                messageKey: _config.SOCIAL_AUTH_MESSAGES.EMAIL_NOT_VERIFIED,
+                messageVariables: {
+                    provider
+                }
+            });
+        }
+    }
+    async registerUser(provider, userRepository, profile) {
+        if (!this.dataSourceProvider.isSignUpEnabled()) {
+            throw new _common.UnauthorizedException({
+                message: `No account is linked to this ${provider} profile`,
+                messageKey: _config.SOCIAL_AUTH_MESSAGES.ACCOUNT_NOT_LINKED,
+                messageVariables: {
+                    provider
+                }
+            });
+        }
+        if (this.dataSourceProvider.isCompanyFeatureEnabled()) {
+            throw new _common.UnauthorizedException({
+                message: `No account is linked to this ${provider} profile. Please sign up manually and join or create a company first, then social sign-in will work.`,
+                messageKey: _config.SOCIAL_AUTH_MESSAGES.COMPANY_REQUIRED,
+                messageVariables: {
+                    provider
+                }
+            });
+        }
+        return userRepository.save(userRepository.create({
+            email: profile.email,
+            name: profile.name,
+            password: null,
+            isActive: true,
+            emailVerified: true
+        }));
+    }
+    async getUsableConfig(provider) {
+        const repository = await this.dataSourceProvider.getRepository(_socialauthconfigentity.SocialAuthConfig);
+        const config = await repository.findOne({
+            where: {
+                provider,
+                deletedAt: (0, _typeorm.IsNull)()
+            }
+        });
+        if (!config?.isEnabled) {
+            throw new _common.BadRequestException({
+                message: `Social sign-in with ${provider} is not enabled`,
+                messageKey: _config.SOCIAL_AUTH_MESSAGES.PROVIDER_DISABLED,
+                messageVariables: {
+                    provider
+                }
+            });
+        }
+        if (!config.clientId || !config.clientSecret) {
+            throw new _common.BadRequestException({
+                message: `Social sign-in with ${provider} is missing its client credentials`,
+                messageKey: _config.SOCIAL_AUTH_MESSAGES.PROVIDER_NOT_CONFIGURED,
+                messageVariables: {
+                    provider
+                }
+            });
+        }
+        return config;
+    }
+    toCredentials(config, redirectUri) {
+        return {
+            clientId: config.clientId,
+            clientSecret: config.clientSecret,
+            redirectUri,
+            scopes: config.scopes,
+            extraConfig: config.extraConfig
+        };
+    }
+    async consumeState(state, redirectUri) {
+        const key = this.stateKey(state);
+        const stored = await this.getCache().get(key);
+        await this.getCache().del(key);
+        if (!stored) {
+            throw new _common.UnauthorizedException({
+                message: 'Social sign-in session is invalid or has expired',
+                messageKey: _config.SOCIAL_AUTH_MESSAGES.STATE_INVALID
+            });
+        }
+        if (stored.redirectUri !== redirectUri) {
+            throw new _common.UnauthorizedException({
+                message: 'Redirect URI does not match the one the sign-in started with',
+                messageKey: _config.SOCIAL_AUTH_MESSAGES.REDIRECT_URI_MISMATCH
+            });
+        }
+        return stored.provider;
+    }
+    stateKey(state) {
+        return `${_config.SOCIAL_STATE_PREFIX}:${state}`;
+    }
+    getCache() {
+        if (!this.cacheManager) {
+            throw new _common.InternalServerErrorException({
+                message: 'Cache is required to hold the social sign-in state',
+                messageKey: _constants.SYSTEM_MESSAGES.SERVICE_NOT_AVAILABLE,
+                messageVariables: {
+                    provider: 'CACHE_INSTANCE',
+                    available: ''
+                }
+            });
+        }
+        return this.cacheManager;
+    }
+    publishSocialEvent(entity, action, user, provider) {
+        void (0, _classes.publishDomainEvent)({
+            module: _config.AUTH_EVENT_MODULE,
+            entity,
+            action,
+            ids: [
+                user.id
+            ],
+            metadata: {
+                email: user.email,
+                provider
+            },
+            user: {
+                id: user.id,
+                email: user.email
+            }
+        });
+    }
+    constructor(authService, dataSourceProvider, cacheManager){
+        _define_property(this, "authService", void 0);
+        _define_property(this, "dataSourceProvider", void 0);
+        _define_property(this, "cacheManager", void 0);
+        this.authService = authService;
+        this.dataSourceProvider = dataSourceProvider;
+        this.cacheManager = cacheManager;
+    }
+};
+_ts_decorate([
+    (0, _nestjsshared.LogAction)({
+        action: 'auth.social.authorize',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _socialprovidertypeenum.SocialProviderTypeEnum === "undefined" ? Object : _socialprovidertypeenum.SocialProviderTypeEnum,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], SocialAuthService.prototype, "createAuthorization", null);
+_ts_decorate([
+    (0, _nestjsshared.LogAction)({
+        action: 'auth.social.login',
+        module: 'auth',
+        includeParams: false
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String,
+        String,
+        String
+    ]),
+    _ts_metadata("design:returntype", Promise)
+], SocialAuthService.prototype, "completeLogin", null);
+SocialAuthService = _ts_decorate([
+    (0, _common.Injectable)({
+        scope: _common.Scope.REQUEST
+    }),
+    _ts_param(0, (0, _common.Inject)(_authenticationservice.AuthenticationService)),
+    _ts_param(1, (0, _common.Inject)(_authdatasourceprovider.AuthDataSourceProvider)),
+    _ts_param(2, (0, _common.Optional)()),
+    _ts_param(2, (0, _common.Inject)('CACHE_INSTANCE')),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _authenticationservice.AuthenticationService === "undefined" ? Object : _authenticationservice.AuthenticationService,
+        typeof _authdatasourceprovider.AuthDataSourceProvider === "undefined" ? Object : _authdatasourceprovider.AuthDataSourceProvider,
+        typeof _classes.HybridCache === "undefined" ? Object : _classes.HybridCache
+    ])
+], SocialAuthService);