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

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

@@ -1,243 +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.UserController
-            ]);
-            expect(providerTokens(dynamicModule.providers)).not.toContain(_services.AuthEmailService);
-            expect(providerTokens(dynamicModule.providers)).not.toContain(_services.CompanyService);
-        });
-        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/services/auth-config.service.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "AuthConfigService", {
-    enumerable: true,
-    get: function() {
-        return AuthConfigService;
-    }
-});
-const _config = require("@flusys/nestjs-core/config");
-const _constants = require("@flusys/nestjs-shared/constants");
-const _common = require("@nestjs/common");
-const _authconstants = require("../config/auth.constants");
-const _authmoduleoptionsinterface = require("../interfaces/auth-module-options.interface");
-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 AuthConfigService = class AuthConfigService {
-    // Database Mode (required by IModuleConfigService)
-    getDatabaseMode() {
-        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
-    }
-    isMultiTenant() {
-        return this.getDatabaseMode() === 'multi-tenant';
-    }
-    // Feature Flags
-    isCompanyFeatureEnabled() {
-        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
-    }
-    isEmailVerificationEnabled() {
-        return this.options.bootstrapAppConfig?.enableEmailVerification ?? true;
-    }
-    isPermissionModeFound() {
-        return this.options.bootstrapAppConfig?.permissionMode !== undefined;
-    }
-    // JWT Configuration
-    getJwtSecret() {
-        if (!this.config.jwtSecret) {
-            throw new _common.InternalServerErrorException({
-                message: '[AuthModule] JWT_SECRET is required - set via environment or module config',
-                messageKey: _constants.SYSTEM_MESSAGES.CONFIG_REQUIRED
-            });
-        }
-        return this.config.jwtSecret;
-    }
-    getJwtExpiration() {
-        return this.config.jwtExpiration ?? '1h';
-    }
-    getRefreshTokenSecret() {
-        if (this.config.refreshTokenSecret) {
-            return this.config.refreshTokenSecret;
-        }
-        if (_config.envConfig.isProduction()) {
-            throw new _common.InternalServerErrorException({
-                message: '[AuthModule] REFRESH_TOKEN_SECRET is required in production - using the same secret for access and refresh tokens is a security risk',
-                messageKey: _constants.SYSTEM_MESSAGES.CONFIG_REQUIRED
-            });
-        }
-        return this.getJwtSecret();
-    }
-    getRefreshTokenExpiration() {
-        return this.config.refreshTokenExpiration ?? '7d';
-    }
-    getRefreshTokenCookieName() {
-        return this.config.refreshTokenCookieName ?? 'fsn_refresh_token';
-    }
-    constructor(injectedOptions){
-        _define_property(this, "options", void 0);
-        _define_property(this, "config", void 0);
-        this.options = injectedOptions ?? {
-            global: false,
-            includeController: true
-        };
-        this.config = this.options.config ?? {};
-    }
-};
-AuthConfigService = _ts_decorate([
-    (0, _common.Injectable)(),
-    _ts_param(0, (0, _common.Optional)()),
-    _ts_param(0, (0, _common.Inject)(_authconstants.AUTH_MODULE_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _authmoduleoptionsinterface.AuthModuleOptions === "undefined" ? Object : _authmoduleoptionsinterface.AuthModuleOptions
-    ])
-], AuthConfigService);

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

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-const _common = require("@nestjs/common");
-const _config = require("@flusys/nestjs-core/config");
-const _authconfigservice = require("./auth-config.service");
-jest.mock('@flusys/nestjs-core/config', ()=>({
-        envConfig: {
-            isProduction: jest.fn().mockReturnValue(false)
-        }
-    }));
-describe('AuthConfigService', ()=>{
-    afterEach(()=>{
-        jest.clearAllMocks();
-    });
-    describe('with no injected options', ()=>{
-        it('defaults database mode to single and company feature to disabled', ()=>{
-            const service = new _authconfigservice.AuthConfigService();
-            expect(service.getDatabaseMode()).toBe('single');
-            expect(service.isMultiTenant()).toBe(false);
-            expect(service.isCompanyFeatureEnabled()).toBe(false);
-            expect(service.isEmailVerificationEnabled()).toBe(true);
-            expect(service.isPermissionModeFound()).toBe(false);
-        });
-        it('throws when reading the JWT secret without configuration', ()=>{
-            const service = new _authconfigservice.AuthConfigService();
-            expect(()=>service.getJwtSecret()).toThrow(_common.InternalServerErrorException);
-        });
-        it('falls back to the JWT secret for refresh token secret outside production', ()=>{
-            const service = new _authconfigservice.AuthConfigService({
-                global: false,
-                includeController: true,
-                config: {
-                    jwtSecret: 'shared-secret'
-                }
-            });
-            expect(service.getRefreshTokenSecret()).toBe('shared-secret');
-        });
-        it('returns default JWT expiration and refresh token expiration', ()=>{
-            const service = new _authconfigservice.AuthConfigService();
-            expect(service.getJwtExpiration()).toBe('1h');
-            expect(service.getRefreshTokenExpiration()).toBe('7d');
-            expect(service.getRefreshTokenCookieName()).toBe('fsn_refresh_token');
-        });
-    });
-    describe('with injected options', ()=>{
-        function buildOptions(overrides = {}) {
-            return {
-                global: false,
-                includeController: true,
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant',
-                    enableCompanyFeature: true,
-                    enableEmailVerification: false,
-                    permissionMode: 'RBAC'
-                },
-                config: {
-                    jwtSecret: 'jwt-secret',
-                    jwtExpiration: '30m',
-                    refreshTokenSecret: 'refresh-secret',
-                    refreshTokenExpiration: '14d',
-                    refreshTokenCookieName: 'custom_cookie'
-                },
-                ...overrides
-            };
-        }
-        it('reflects multi-tenant database mode', ()=>{
-            const service = new _authconfigservice.AuthConfigService(buildOptions());
-            expect(service.getDatabaseMode()).toBe('multi-tenant');
-            expect(service.isMultiTenant()).toBe(true);
-        });
-        it('reflects enabled company feature and email verification flags', ()=>{
-            const service = new _authconfigservice.AuthConfigService(buildOptions());
-            expect(service.isCompanyFeatureEnabled()).toBe(true);
-            expect(service.isEmailVerificationEnabled()).toBe(false);
-            expect(service.isPermissionModeFound()).toBe(true);
-        });
-        it('returns configured JWT and refresh token values', ()=>{
-            const service = new _authconfigservice.AuthConfigService(buildOptions());
-            expect(service.getJwtSecret()).toBe('jwt-secret');
-            expect(service.getJwtExpiration()).toBe('30m');
-            expect(service.getRefreshTokenSecret()).toBe('refresh-secret');
-            expect(service.getRefreshTokenExpiration()).toBe('14d');
-            expect(service.getRefreshTokenCookieName()).toBe('custom_cookie');
-        });
-        it('throws in production when refresh token secret is missing (security: prevents shared-secret fallback)', ()=>{
-            _config.envConfig.isProduction.mockReturnValue(true);
-            const service = new _authconfigservice.AuthConfigService(buildOptions({
-                config: {
-                    jwtSecret: 'jwt-secret'
-                }
-            }));
-            expect(()=>service.getRefreshTokenSecret()).toThrow(_common.InternalServerErrorException);
-        });
-    });
-});

package/cjs/services/auth-datasource.provider.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "AuthDataSourceProvider", {
-    enumerable: true,
-    get: function() {
-        return AuthDataSourceProvider;
-    }
-});
-const _nestjsshared = require("@flusys/nestjs-shared");
-const _common = require("@nestjs/common");
-const _core = require("@nestjs/core");
-const _express = require("express");
-const _authconstants = require("../config/auth.constants");
-const _authmoduleoptionsinterface = require("../interfaces/auth-module-options.interface");
-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 _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-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 AuthDataSourceProvider = class AuthDataSourceProvider extends _nestjsshared.MultiTenantDataSourceService {
-    static buildParentOptions(options) {
-        return {
-            bootstrapAppConfig: options.bootstrapAppConfig,
-            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
-            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
-            tenants: options.config?.tenants
-        };
-    }
-    isCompanyFeatureEnabled(tenant) {
-        const effectiveTenant = tenant ?? this.getCurrentTenant();
-        return effectiveTenant?.enableCompanyFeature ?? this.authOptions.bootstrapAppConfig?.enableCompanyFeature ?? false;
-    }
-    isEmailVerificationEnabled(tenant) {
-        const effectiveTenant = tenant ?? this.getCurrentTenant();
-        return effectiveTenant?.enableEmailVerification ?? this.authOptions.bootstrapAppConfig?.enableEmailVerification ?? true;
-    }
-    async getAuthEntities() {
-        const { getAuthEntitiesByConfig } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../entities")));
-        return getAuthEntitiesByConfig({
-            enableCompanyFeature: this.isCompanyFeatureEnabled(),
-            enableEmailVerification: this.isEmailVerificationEnabled()
-        });
-    }
-    async createDataSourceFromConfig(config) {
-        return super.createDataSourceFromConfig(config, await this.getAuthEntities());
-    }
-    constructor(authOptions, request){
-        super(AuthDataSourceProvider.buildParentOptions(authOptions), request), _define_property(this, "authOptions", void 0), this.authOptions = authOptions;
-    }
-};
-_define_property(AuthDataSourceProvider, "tenantConnections", new Map());
-_define_property(AuthDataSourceProvider, "singleDataSource", null);
-_define_property(AuthDataSourceProvider, "tenantsRegistry", new Map());
-_define_property(AuthDataSourceProvider, "initialized", false);
-_define_property(AuthDataSourceProvider, "connectionLocks", new Map());
-_define_property(AuthDataSourceProvider, "singleConnectionLock", null);
-AuthDataSourceProvider = _ts_decorate([
-    (0, _common.Injectable)({
-        scope: _common.Scope.REQUEST
-    }),
-    _ts_param(0, (0, _common.Inject)(_authconstants.AUTH_MODULE_OPTIONS)),
-    _ts_param(1, (0, _common.Optional)()),
-    _ts_param(1, (0, _common.Inject)(_core.REQUEST)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _authmoduleoptionsinterface.AuthModuleOptions === "undefined" ? Object : _authmoduleoptionsinterface.AuthModuleOptions,
-        typeof _express.Request === "undefined" ? Object : _express.Request
-    ])
-], AuthDataSourceProvider);