@flusys/nestjs-auth 7.1.0 → 8.0.0

package/cjs/modules/auth.module.js

@@ -1,208 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "AuthModule", {
-    enumerable: true,
-    get: function() {
-        return AuthModule;
-    }
-});
-const _modules = require("@flusys/nestjs-shared/modules");
-const _common = require("@nestjs/common");
-const _jwt = require("@nestjs/jwt");
-const _passport = require("@nestjs/passport");
-const _guards = require("@flusys/nestjs-shared/guards");
-const _authconstants = require("../config/auth.constants");
-const _controllers = require("../controllers");
-const _entities = require("../entities");
-const _cleartokeninterceptor = require("../interceptors/clear-token.interceptor");
-const _settokeninterceptor = require("../interceptors/set-token.interceptor");
-const _services = require("../services");
-const _authconfigservice = require("../services/auth-config.service");
-const _authdatasourceprovider = require("../services/auth-datasource.provider");
-const _jwtstrategy = require("../strategies/jwt.strategy");
-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;
-}
-let AuthModule = class AuthModule {
-    static forRoot(options) {
-        const optionsProvider = {
-            provide: _authconstants.AUTH_MODULE_OPTIONS,
-            useValue: options
-        };
-        return this.buildModule(options, [
-            optionsProvider,
-            ...options.providers ?? []
-        ]);
-    }
-    static forRootAsync(options) {
-        const asyncProviders = this.createAsyncProviders(options);
-        return this.buildModule(options, [
-            ...asyncProviders,
-            ...options.providers ?? []
-        ], options.imports);
-    }
-    static buildModule(options, providers, externalImports = []) {
-        const { global = false, includeController = true, bootstrapAppConfig } = options;
-        const featureFlags = this.getFeatureFlags(bootstrapAppConfig);
-        return {
-            module: AuthModule,
-            global,
-            imports: [
-                ...externalImports,
-                ...this.buildImports()
-            ],
-            controllers: this.buildControllers(includeController, featureFlags),
-            providers: [
-                ...providers,
-                ...this.buildProviders(featureFlags)
-            ],
-            exports: this.buildExports(featureFlags)
-        };
-    }
-    static getFeatureFlags(bootstrapAppConfig) {
-        return {
-            enableCompanyFeature: bootstrapAppConfig?.enableCompanyFeature ?? false,
-            enableEmailVerification: bootstrapAppConfig?.enableEmailVerification ?? true
-        };
-    }
-    static buildImports() {
-        return [
-            _passport.PassportModule.register({
-                defaultStrategy: 'jwt'
-            }),
-            _jwt.JwtModule.register({}),
-            _modules.CacheModule,
-            _modules.UtilsModule
-        ];
-    }
-    static buildControllers(includeController, flags) {
-        if (!includeController) return [];
-        const controllers = [
-            _controllers.AuthenticationController,
-            _controllers.SocialAuthController,
-            _controllers.SocialAuthConfigController,
-            _controllers.UserController
-        ];
-        if (flags.enableEmailVerification) {
-            controllers.push(_controllers.EmailVerificationController);
-        }
-        if (flags.enableCompanyFeature) {
-            controllers.push(_controllers.CompanySelectionController, _controllers.CompanyController, _controllers.BranchController, _controllers.UserPermissionController);
-        }
-        return controllers;
-    }
-    static buildProviders(flags) {
-        const providers = [
-            _authconfigservice.AuthConfigService,
-            _authdatasourceprovider.AuthDataSourceProvider,
-            _jwtstrategy.JwtStrategy,
-            _guards.JwtAuthGuard,
-            _services.AuthenticationService,
-            _services.SocialAuthService,
-            _services.SocialAuthConfigService,
-            _settokeninterceptor.SetToken,
-            _cleartokeninterceptor.ClearToken,
-            _services.UserService,
-            (0, _modules.createModuleEventsProvider)('auth', _authconstants.AUTH_MODULE_OPTIONS)
-        ];
-        if (flags.enableEmailVerification) {
-            providers.push(_services.AuthEmailService);
-        }
-        if (flags.enableCompanyFeature) {
-            providers.push(_services.CompanySelectionSessionService, _services.CompanyService, _services.BranchService, _services.UserPermissionService);
-        }
-        return providers;
-    }
-    static buildExports(flags) {
-        const exports1 = [
-            _passport.PassportModule,
-            _authconstants.AUTH_MODULE_OPTIONS,
-            _authconfigservice.AuthConfigService,
-            _authdatasourceprovider.AuthDataSourceProvider,
-            _jwtstrategy.JwtStrategy,
-            _guards.JwtAuthGuard,
-            _services.AuthenticationService,
-            _services.SocialAuthService,
-            _services.SocialAuthConfigService,
-            _services.UserService
-        ];
-        if (flags.enableEmailVerification) {
-            exports1.push(_services.AuthEmailService);
-        }
-        if (flags.enableCompanyFeature) {
-            exports1.push(_services.CompanySelectionSessionService, _services.CompanyService, _services.BranchService, _services.UserPermissionService);
-        }
-        return exports1;
-    }
-    static createAsyncProviders(options) {
-        const staticOptions = {
-            global: options.global,
-            includeController: options.includeController,
-            bootstrapAppConfig: options.bootstrapAppConfig
-        };
-        if (options.useFactory) {
-            return [
-                {
-                    provide: _authconstants.AUTH_MODULE_OPTIONS,
-                    useFactory: async (...args)=>({
-                            ...staticOptions,
-                            config: await options.useFactory(...args)
-                        }),
-                    inject: options.inject || []
-                }
-            ];
-        }
-        if (options.useClass) {
-            return [
-                {
-                    provide: options.useClass,
-                    useClass: options.useClass
-                },
-                {
-                    provide: _authconstants.AUTH_MODULE_OPTIONS,
-                    useFactory: async (factory)=>({
-                            ...staticOptions,
-                            config: await factory.createAuthOptions()
-                        }),
-                    inject: [
-                        options.useClass
-                    ]
-                }
-            ];
-        }
-        if (options.useExisting) {
-            return [
-                {
-                    provide: _authconstants.AUTH_MODULE_OPTIONS,
-                    useFactory: async (factory)=>({
-                            ...staticOptions,
-                            config: await factory.createAuthOptions()
-                        }),
-                    inject: [
-                        options.useExisting
-                    ]
-                }
-            ];
-        }
-        return [
-            {
-                provide: _authconstants.AUTH_MODULE_OPTIONS,
-                useValue: staticOptions
-            }
-        ];
-    }
-    static getEntities(config) {
-        return (0, _entities.getAuthEntitiesByConfig)({
-            enableCompanyFeature: config.enableCompanyFeature ?? false,
-            enableEmailVerification: config.enableEmailVerification ?? true
-        });
-    }
-};
-AuthModule = _ts_decorate([
-    (0, _common.Module)({})
-], AuthModule);

package/cjs/modules/auth.module.spec.js

@@ -1,258 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _authmodule = require("./auth.module");
-const _authconstants = require("../config/auth.constants");
-const _controllers = require("../controllers");
-const _services = require("../services");
-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 providerTokens(providers) {
-    return providers.map((p)=>typeof p === 'function' ? p : p.provide);
-}
-describe('AuthModule', ()=>{
-    describe('forRoot', ()=>{
-        it('should build a non-global module by default with the minimal feature set', ()=>{
-            const dynamicModule = _authmodule.AuthModule.forRoot({
-                bootstrapAppConfig: {
-                    enableEmailVerification: false
-                }
-            });
-            expect(dynamicModule.module).toBe(_authmodule.AuthModule);
-            expect(dynamicModule.global).toBe(false);
-            expect(dynamicModule.controllers).toEqual([
-                _controllers.AuthenticationController,
-                _controllers.SocialAuthController,
-                _controllers.SocialAuthConfigController,
-                _controllers.UserController
-            ]);
-            expect(providerTokens(dynamicModule.providers)).not.toContain(_services.AuthEmailService);
-            expect(providerTokens(dynamicModule.providers)).not.toContain(_services.CompanyService);
-        });
-        it('should always register social sign-in, whatever the feature flags say', ()=>{
-            const dynamicModule = _authmodule.AuthModule.forRoot({
-                bootstrapAppConfig: {
-                    enableCompanyFeature: false
-                }
-            });
-            expect(dynamicModule.controllers).toContain(_controllers.SocialAuthController);
-            expect(dynamicModule.controllers).toContain(_controllers.SocialAuthConfigController);
-            expect(providerTokens(dynamicModule.providers)).toContain(_services.SocialAuthService);
-            expect(providerTokens(dynamicModule.providers)).toContain(_services.SocialAuthConfigService);
-            expect(dynamicModule.exports).toContain(_services.SocialAuthService);
-            expect(dynamicModule.exports).toContain(_services.SocialAuthConfigService);
-        });
-        it('should respect global: true', ()=>{
-            const dynamicModule = _authmodule.AuthModule.forRoot({
-                global: true
-            });
-            expect(dynamicModule.global).toBe(true);
-        });
-        it('should register no controllers when includeController is false', ()=>{
-            const dynamicModule = _authmodule.AuthModule.forRoot({
-                includeController: false
-            });
-            expect(dynamicModule.controllers).toEqual([]);
-        });
-        it('should enable email verification by default (bootstrapAppConfig omitted)', ()=>{
-            const dynamicModule = _authmodule.AuthModule.forRoot({});
-            expect(dynamicModule.controllers).toContain(_controllers.EmailVerificationController);
-            expect(providerTokens(dynamicModule.providers)).toContain(_services.AuthEmailService);
-            expect(dynamicModule.exports).toContain(_services.AuthEmailService);
-        });
-        it('should omit email verification controller/provider/export when explicitly disabled', ()=>{
-            const dynamicModule = _authmodule.AuthModule.forRoot({
-                bootstrapAppConfig: {
-                    enableEmailVerification: false
-                }
-            });
-            expect(dynamicModule.controllers).not.toContain(_controllers.EmailVerificationController);
-            expect(providerTokens(dynamicModule.providers)).not.toContain(_services.AuthEmailService);
-            expect(dynamicModule.exports).not.toContain(_services.AuthEmailService);
-        });
-        it('should add company controllers/providers/exports when enableCompanyFeature is true', ()=>{
-            const dynamicModule = _authmodule.AuthModule.forRoot({
-                bootstrapAppConfig: {
-                    enableCompanyFeature: true
-                }
-            });
-            expect(dynamicModule.controllers).toEqual(expect.arrayContaining([
-                _controllers.CompanySelectionController,
-                _controllers.CompanyController,
-                _controllers.BranchController,
-                _controllers.UserPermissionController
-            ]));
-            expect(providerTokens(dynamicModule.providers)).toEqual(expect.arrayContaining([
-                _services.CompanySelectionSessionService,
-                _services.CompanyService,
-                _services.BranchService,
-                _services.UserPermissionService
-            ]));
-            expect(dynamicModule.exports).toEqual(expect.arrayContaining([
-                _services.CompanyService,
-                _services.BranchService,
-                _services.UserPermissionService
-            ]));
-        });
-        it('should register an AUTH_MODULE_OPTIONS provider carrying the given options', ()=>{
-            const options = {
-                bootstrapAppConfig: {
-                    enableCompanyFeature: true
-                }
-            };
-            const dynamicModule = _authmodule.AuthModule.forRoot(options);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _authconstants.AUTH_MODULE_OPTIONS);
-            expect(optionsProvider.useValue).toBe(options);
-        });
-        it('should append any caller-supplied extra providers', ()=>{
-            const extraProvider = {
-                provide: 'EXTRA',
-                useValue: 'x'
-            };
-            const dynamicModule = _authmodule.AuthModule.forRoot({
-                providers: [
-                    extraProvider
-                ]
-            });
-            expect(dynamicModule.providers).toEqual(expect.arrayContaining([
-                extraProvider
-            ]));
-        });
-    });
-    describe('forRootAsync', ()=>{
-        it('should default AUTH_MODULE_OPTIONS to the static options when no useFactory/useClass/useExisting is given', async ()=>{
-            const dynamicModule = _authmodule.AuthModule.forRootAsync({
-                bootstrapAppConfig: {},
-                global: true
-            });
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _authconstants.AUTH_MODULE_OPTIONS);
-            expect(optionsProvider.useValue).toEqual({
-                global: true,
-                includeController: undefined,
-                bootstrapAppConfig: {}
-            });
-        });
-        it('should resolve config via useFactory and merge it with the static options', async ()=>{
-            const useFactory = jest.fn().mockResolvedValue({
-                jwtSecret: 'from-factory'
-            });
-            const dynamicModule = _authmodule.AuthModule.forRootAsync({
-                bootstrapAppConfig: {},
-                useFactory,
-                inject: [
-                    'SOME_TOKEN'
-                ]
-            });
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _authconstants.AUTH_MODULE_OPTIONS);
-            expect(optionsProvider.inject).toEqual([
-                'SOME_TOKEN'
-            ]);
-            const resolved = await optionsProvider.useFactory('injected-value');
-            expect(useFactory).toHaveBeenCalledWith('injected-value');
-            expect(resolved).toEqual({
-                global: undefined,
-                includeController: undefined,
-                bootstrapAppConfig: {},
-                config: {
-                    jwtSecret: 'from-factory'
-                }
-            });
-        });
-        it('should resolve config via a useClass factory', async ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createAuthOptions", jest.fn().mockResolvedValue({
-                        jwtSecret: 'from-class'
-                    }));
-                }
-            };
-            const dynamicModule = _authmodule.AuthModule.forRootAsync({
-                bootstrapAppConfig: {},
-                useClass: MyOptionsFactory
-            });
-            const classProvider = dynamicModule.providers.find((p)=>p.provide === MyOptionsFactory);
-            expect(classProvider.useClass).toBe(MyOptionsFactory);
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _authconstants.AUTH_MODULE_OPTIONS);
-            expect(optionsProvider.inject).toEqual([
-                MyOptionsFactory
-            ]);
-            const factoryInstance = new MyOptionsFactory();
-            const resolved = await optionsProvider.useFactory(factoryInstance);
-            expect(factoryInstance.createAuthOptions).toHaveBeenCalled();
-            expect(resolved.config).toEqual({
-                jwtSecret: 'from-class'
-            });
-        });
-        it('should resolve config via a useExisting factory', async ()=>{
-            let MyOptionsFactory = class MyOptionsFactory {
-                constructor(){
-                    _define_property(this, "createAuthOptions", jest.fn().mockResolvedValue({
-                        jwtSecret: 'from-existing'
-                    }));
-                }
-            };
-            const dynamicModule = _authmodule.AuthModule.forRootAsync({
-                bootstrapAppConfig: {},
-                useExisting: MyOptionsFactory
-            });
-            const optionsProvider = dynamicModule.providers.find((p)=>p.provide === _authconstants.AUTH_MODULE_OPTIONS);
-            expect(optionsProvider.inject).toEqual([
-                MyOptionsFactory
-            ]);
-            const factoryInstance = new MyOptionsFactory();
-            const resolved = await optionsProvider.useFactory(factoryInstance);
-            expect(resolved.config).toEqual({
-                jwtSecret: 'from-existing'
-            });
-        });
-        it('should forward the async `imports` array into the built module', ()=>{
-            let FakeImportedModule = class FakeImportedModule {
-            };
-            const dynamicModule = _authmodule.AuthModule.forRootAsync({
-                bootstrapAppConfig: {},
-                imports: [
-                    FakeImportedModule
-                ]
-            });
-            expect(dynamicModule.imports).toEqual(expect.arrayContaining([
-                FakeImportedModule
-            ]));
-        });
-        it('should append any caller-supplied extra providers alongside the async options provider', ()=>{
-            const extraProvider = {
-                provide: 'EXTRA',
-                useValue: 'x'
-            };
-            const dynamicModule = _authmodule.AuthModule.forRootAsync({
-                bootstrapAppConfig: {},
-                providers: [
-                    extraProvider
-                ]
-            });
-            expect(dynamicModule.providers).toEqual(expect.arrayContaining([
-                extraProvider
-            ]));
-        });
-    });
-    describe('getEntities', ()=>{
-        it('should delegate to getAuthEntitiesByConfig with the bootstrap flags', ()=>{
-            const entitiesWithDefaults = _authmodule.AuthModule.getEntities({});
-            const entitiesWithCompany = _authmodule.AuthModule.getEntities({
-                enableCompanyFeature: true
-            });
-            expect(entitiesWithDefaults.length).toBeLessThan(entitiesWithCompany.length);
-        });
-    });
-});

package/cjs/modules/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./auth.module"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/cjs/providers/facebook.social-provider.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "facebookSocialProvider", {
-    enumerable: true,
-    get: function() {
-        return facebookSocialProvider;
-    }
-});
-const _socialprovidertypeenum = require("../enums/social-provider-type.enum");
-const _oauthhttputil = require("./oauth-http.util");
-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;
-}
-const GRAPH_VERSION = 'v21.0';
-const AUTHORIZE_URL = `https://www.facebook.com/${GRAPH_VERSION}/dialog/oauth`;
-const TOKEN_URL = `https://graph.facebook.com/${GRAPH_VERSION}/oauth/access_token`;
-const PROFILE_URL = `https://graph.facebook.com/${GRAPH_VERSION}/me?fields=id,name,email,picture.type(large)`;
-function readAvatarUrl(profile) {
-    const picture = profile['picture'];
-    if (typeof picture !== 'object' || picture === null) return null;
-    const data = picture['data'];
-    if (typeof data !== 'object' || data === null) return null;
-    return (0, _oauthhttputil.readString)(data, 'url');
-}
-let FacebookSocialProvider = class FacebookSocialProvider {
-    buildAuthorizationUrl(credentials, state) {
-        const query = (0, _oauthhttputil.buildQuery)({
-            client_id: credentials.clientId,
-            redirect_uri: credentials.redirectUri,
-            response_type: 'code',
-            scope: (0, _oauthhttputil.resolveScopes)(credentials, this.defaultScopes, ','),
-            state
-        });
-        return `${AUTHORIZE_URL}?${query}`;
-    }
-    async fetchProfile(credentials, code) {
-        const token = await (0, _oauthhttputil.postForm)(this.provider, TOKEN_URL, {
-            code,
-            client_id: credentials.clientId,
-            client_secret: credentials.clientSecret,
-            redirect_uri: credentials.redirectUri
-        });
-        const profile = await (0, _oauthhttputil.getJson)(this.provider, PROFILE_URL, (0, _oauthhttputil.readAccessToken)(this.provider, token));
-        const email = (0, _oauthhttputil.readString)(profile, 'email');
-        return {
-            providerUserId: (0, _oauthhttputil.readString)(profile, 'id') ?? '',
-            email,
-            emailVerified: !!email,
-            name: (0, _oauthhttputil.readString)(profile, 'name'),
-            avatarUrl: readAvatarUrl(profile)
-        };
-    }
-    constructor(){
-        _define_property(this, "provider", _socialprovidertypeenum.SocialProviderTypeEnum.FACEBOOK);
-        _define_property(this, "defaultScopes", [
-            'email',
-            'public_profile'
-        ]);
-    }
-};
-const facebookSocialProvider = new FacebookSocialProvider();

package/cjs/providers/google.social-provider.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "googleSocialProvider", {
-    enumerable: true,
-    get: function() {
-        return googleSocialProvider;
-    }
-});
-const _socialprovidertypeenum = require("../enums/social-provider-type.enum");
-const _oauthhttputil = require("./oauth-http.util");
-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;
-}
-const AUTHORIZE_URL = 'https://accounts.google.com/o/oauth2/v2/auth';
-const TOKEN_URL = 'https://oauth2.googleapis.com/token';
-const USERINFO_URL = 'https://openidconnect.googleapis.com/v1/userinfo';
-let GoogleSocialProvider = class GoogleSocialProvider {
-    buildAuthorizationUrl(credentials, state) {
-        const query = (0, _oauthhttputil.buildQuery)({
-            client_id: credentials.clientId,
-            redirect_uri: credentials.redirectUri,
-            response_type: 'code',
-            scope: (0, _oauthhttputil.resolveScopes)(credentials, this.defaultScopes),
-            state,
-            access_type: 'online',
-            prompt: 'select_account'
-        });
-        return `${AUTHORIZE_URL}?${query}`;
-    }
-    async fetchProfile(credentials, code) {
-        const token = await (0, _oauthhttputil.postForm)(this.provider, TOKEN_URL, {
-            code,
-            client_id: credentials.clientId,
-            client_secret: credentials.clientSecret,
-            redirect_uri: credentials.redirectUri,
-            grant_type: 'authorization_code'
-        });
-        const profile = await (0, _oauthhttputil.getJson)(this.provider, USERINFO_URL, (0, _oauthhttputil.readAccessToken)(this.provider, token));
-        return {
-            providerUserId: (0, _oauthhttputil.readString)(profile, 'sub') ?? '',
-            email: (0, _oauthhttputil.readString)(profile, 'email'),
-            emailVerified: profile['email_verified'] === true,
-            name: (0, _oauthhttputil.readString)(profile, 'name'),
-            avatarUrl: (0, _oauthhttputil.readString)(profile, 'picture')
-        };
-    }
-    constructor(){
-        _define_property(this, "provider", _socialprovidertypeenum.SocialProviderTypeEnum.GOOGLE);
-        _define_property(this, "defaultScopes", [
-            'openid',
-            'email',
-            'profile'
-        ]);
-    }
-};
-const googleSocialProvider = new GoogleSocialProvider();

package/cjs/providers/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./social-provider.registry"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}