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

package/fesm/providers/linkedin.social-provider.js

@@ -1,56 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { SocialProviderTypeEnum } from '../enums/social-provider-type.enum';
-import { buildQuery, getJson, postForm, readAccessToken, readString, resolveScopes } from './oauth-http.util';
-const AUTHORIZE_URL = 'https://www.linkedin.com/oauth/v2/authorization';
-const TOKEN_URL = 'https://www.linkedin.com/oauth/v2/accessToken';
-const USERINFO_URL = 'https://api.linkedin.com/v2/userinfo';
-let LinkedInSocialProvider = class LinkedInSocialProvider {
-    buildAuthorizationUrl(credentials, state) {
-        const query = buildQuery({
-            response_type: 'code',
-            client_id: credentials.clientId,
-            redirect_uri: credentials.redirectUri,
-            scope: resolveScopes(credentials, this.defaultScopes),
-            state
-        });
-        return `${AUTHORIZE_URL}?${query}`;
-    }
-    async fetchProfile(credentials, code) {
-        const token = await postForm(this.provider, TOKEN_URL, {
-            grant_type: 'authorization_code',
-            code,
-            client_id: credentials.clientId,
-            client_secret: credentials.clientSecret,
-            redirect_uri: credentials.redirectUri
-        });
-        const profile = await getJson(this.provider, USERINFO_URL, readAccessToken(this.provider, token));
-        return {
-            providerUserId: readString(profile, 'sub') ?? '',
-            email: readString(profile, 'email'),
-            emailVerified: profile['email_verified'] === true,
-            name: readString(profile, 'name'),
-            avatarUrl: readString(profile, 'picture')
-        };
-    }
-    constructor(){
-        _define_property(this, "provider", SocialProviderTypeEnum.LINKEDIN);
-        _define_property(this, "defaultScopes", [
-            'openid',
-            'profile',
-            'email'
-        ]);
-    }
-};
-export const linkedInSocialProvider = new LinkedInSocialProvider();

package/fesm/providers/microsoft.social-provider.js

@@ -1,68 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { SocialProviderTypeEnum } from '../enums/social-provider-type.enum';
-import { buildQuery, getJson, postForm, readAccessToken, readString, resolveScopes } from './oauth-http.util';
-const GRAPH_ME_URL = 'https://graph.microsoft.com/v1.0/me';
-const DEFAULT_TENANT = 'common';
-function resolveTenant(credentials) {
-    const tenantId = credentials.extraConfig?.['tenantId'];
-    return typeof tenantId === 'string' && tenantId ? tenantId : DEFAULT_TENANT;
-}
-function endpoint(credentials, action) {
-    return `https://login.microsoftonline.com/${resolveTenant(credentials)}/oauth2/v2.0/${action}`;
-}
-let MicrosoftSocialProvider = class MicrosoftSocialProvider {
-    buildAuthorizationUrl(credentials, state) {
-        const query = buildQuery({
-            client_id: credentials.clientId,
-            response_type: 'code',
-            redirect_uri: credentials.redirectUri,
-            response_mode: 'query',
-            scope: resolveScopes(credentials, this.defaultScopes),
-            state
-        });
-        return `${endpoint(credentials, 'authorize')}?${query}`;
-    }
-    async fetchProfile(credentials, code) {
-        const token = await postForm(this.provider, endpoint(credentials, 'token'), {
-            client_id: credentials.clientId,
-            client_secret: credentials.clientSecret,
-            code,
-            redirect_uri: credentials.redirectUri,
-            grant_type: 'authorization_code',
-            scope: resolveScopes(credentials, this.defaultScopes)
-        });
-        const profile = await getJson(this.provider, GRAPH_ME_URL, readAccessToken(this.provider, token));
-        // `mail` is Microsoft's confirmed mailbox claim; `userPrincipalName` is a sign-in
-        // identifier that is not guaranteed to be a verified, owned mailbox address.
-        const verifiedEmail = readString(profile, 'mail');
-        return {
-            providerUserId: readString(profile, 'id') ?? '',
-            email: verifiedEmail ?? readString(profile, 'userPrincipalName'),
-            emailVerified: !!verifiedEmail,
-            name: readString(profile, 'displayName'),
-            avatarUrl: null
-        };
-    }
-    constructor(){
-        _define_property(this, "provider", SocialProviderTypeEnum.MICROSOFT);
-        _define_property(this, "defaultScopes", [
-            'openid',
-            'profile',
-            'email',
-            'User.Read'
-        ]);
-    }
-};
-export const microsoftSocialProvider = new MicrosoftSocialProvider();

package/fesm/providers/oauth-http.util.js

@@ -1,77 +0,0 @@
-import { UnauthorizedException } from '@nestjs/common';
-import { SOCIAL_AUTH_MESSAGES } from '../config/message-keys';
-const OAUTH_HTTP_TIMEOUT_MS = 10_000;
-function failExchange(provider, detail) {
-    throw new UnauthorizedException({
-        message: `Social sign-in with ${provider} failed: ${detail}`,
-        messageKey: SOCIAL_AUTH_MESSAGES.EXCHANGE_FAILED,
-        messageVariables: {
-            provider
-        }
-    });
-}
-async function fetchWithTimeout(provider, url, init) {
-    try {
-        return await fetch(url, {
-            ...init,
-            signal: AbortSignal.timeout(OAUTH_HTTP_TIMEOUT_MS)
-        });
-    } catch (error) {
-        if (error instanceof Error && error.name === 'TimeoutError') {
-            failExchange(provider, 'request timed out');
-        }
-        throw error;
-    }
-}
-async function readJson(provider, response) {
-    const body = await response.text();
-    if (!response.ok) {
-        failExchange(provider, `${response.status} ${body.slice(0, 200)}`);
-    }
-    try {
-        return JSON.parse(body);
-    } catch  {
-        return failExchange(provider, 'response was not JSON');
-    }
-}
-export async function postForm(provider, url, form) {
-    const response = await fetchWithTimeout(provider, url, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/x-www-form-urlencoded',
-            Accept: 'application/json'
-        },
-        body: new URLSearchParams(form).toString()
-    });
-    return readJson(provider, response);
-}
-export async function getJson(provider, url, accessToken) {
-    const response = await fetchWithTimeout(provider, url, {
-        headers: {
-            Authorization: `Bearer ${accessToken}`,
-            Accept: 'application/json'
-        }
-    });
-    return readJson(provider, response);
-}
-export function readAccessToken(provider, token) {
-    const accessToken = token['access_token'];
-    if (typeof accessToken !== 'string' || !accessToken) {
-        failExchange(provider, 'no access token returned');
-    }
-    return accessToken;
-}
-export function readString(source, key) {
-    const value = source[key];
-    return typeof value === 'string' && value ? value : null;
-}
-export function buildQuery(params) {
-    const query = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)){
-        if (value) query.append(key, value);
-    }
-    return query.toString();
-}
-export function resolveScopes(credentials, defaults, separator = ' ') {
-    return (credentials.scopes?.length ? credentials.scopes : defaults).join(separator);
-}

package/fesm/providers/social-provider.registry.js

@@ -1,14 +0,0 @@
-import { SocialProviderTypeEnum } from '../enums/social-provider-type.enum';
-import { facebookSocialProvider } from './facebook.social-provider';
-import { googleSocialProvider } from './google.social-provider';
-import { linkedInSocialProvider } from './linkedin.social-provider';
-import { microsoftSocialProvider } from './microsoft.social-provider';
-const PROVIDERS = {
-    [SocialProviderTypeEnum.GOOGLE]: googleSocialProvider,
-    [SocialProviderTypeEnum.FACEBOOK]: facebookSocialProvider,
-    [SocialProviderTypeEnum.LINKEDIN]: linkedInSocialProvider,
-    [SocialProviderTypeEnum.MICROSOFT]: microsoftSocialProvider
-};
-export function getSocialProvider(provider) {
-    return PROVIDERS[provider];
-}

package/fesm/providers/social-provider.registry.spec.js

@@ -1,131 +0,0 @@
-import { UnauthorizedException } from '@nestjs/common';
-import { SocialProviderTypeEnum } from '../enums/social-provider-type.enum';
-import { getSocialProvider } from './social-provider.registry';
-const CREDENTIALS = {
-    clientId: 'client-id',
-    clientSecret: 'client-secret',
-    redirectUri: 'http://localhost:2001/auth/social/callback'
-};
-function mockFetchSequence(...responses) {
-    const fetchMock = jest.fn();
-    for (const response of responses){
-        fetchMock.mockResolvedValueOnce({
-            ok: response.ok ?? true,
-            status: response.status ?? 200,
-            text: async ()=>JSON.stringify(response.body)
-        });
-    }
-    globalThis.fetch = fetchMock;
-    return fetchMock;
-}
-describe('social providers', ()=>{
-    afterEach(()=>jest.restoreAllMocks());
-    describe('buildAuthorizationUrl', ()=>{
-        it.each(Object.values(SocialProviderTypeEnum))('carries the client id, redirect URI and state for %s', (provider)=>{
-            const url = new URL(getSocialProvider(provider).buildAuthorizationUrl(CREDENTIALS, 'state-token'));
-            expect(url.searchParams.get('client_id')).toBe('client-id');
-            expect(url.searchParams.get('redirect_uri')).toBe(CREDENTIALS.redirectUri);
-            expect(url.searchParams.get('state')).toBe('state-token');
-            expect(url.searchParams.get('scope')).toBeTruthy();
-        });
-        it('uses the configured scopes over the provider defaults', ()=>{
-            const url = new URL(getSocialProvider(SocialProviderTypeEnum.GOOGLE).buildAuthorizationUrl({
-                ...CREDENTIALS,
-                scopes: [
-                    'openid',
-                    'email'
-                ]
-            }, 'state-token'));
-            expect(url.searchParams.get('scope')).toBe('openid email');
-        });
-        it('targets the common Microsoft directory unless a tenant is configured', ()=>{
-            const provider = getSocialProvider(SocialProviderTypeEnum.MICROSOFT);
-            expect(provider.buildAuthorizationUrl(CREDENTIALS, 'state-token')).toContain('login.microsoftonline.com/common/');
-            expect(provider.buildAuthorizationUrl({
-                ...CREDENTIALS,
-                extraConfig: {
-                    tenantId: 'contoso'
-                }
-            }, 'state-token')).toContain('login.microsoftonline.com/contoso/');
-        });
-    });
-    describe('fetchProfile', ()=>{
-        it('normalises a Google OpenID profile', async ()=>{
-            mockFetchSequence({
-                body: {
-                    access_token: 'token'
-                }
-            }, {
-                body: {
-                    sub: 'google-1',
-                    email: 'user@example.com',
-                    email_verified: true,
-                    name: 'Test User',
-                    picture: 'https://cdn.test/avatar.png'
-                }
-            });
-            const profile = await getSocialProvider(SocialProviderTypeEnum.GOOGLE).fetchProfile(CREDENTIALS, 'code');
-            expect(profile).toEqual({
-                providerUserId: 'google-1',
-                email: 'user@example.com',
-                emailVerified: true,
-                name: 'Test User',
-                avatarUrl: 'https://cdn.test/avatar.png'
-            });
-        });
-        it('reads the nested avatar Facebook returns', async ()=>{
-            mockFetchSequence({
-                body: {
-                    access_token: 'token'
-                }
-            }, {
-                body: {
-                    id: 'fb-1',
-                    name: 'Test User',
-                    email: 'user@example.com',
-                    picture: {
-                        data: {
-                            url: 'https://cdn.test/fb.png'
-                        }
-                    }
-                }
-            });
-            const profile = await getSocialProvider(SocialProviderTypeEnum.FACEBOOK).fetchProfile(CREDENTIALS, 'code');
-            expect(profile.avatarUrl).toBe('https://cdn.test/fb.png');
-            expect(profile.emailVerified).toBe(true);
-        });
-        it('falls back to the Microsoft principal name when no mailbox is set', async ()=>{
-            mockFetchSequence({
-                body: {
-                    access_token: 'token'
-                }
-            }, {
-                body: {
-                    id: 'ms-1',
-                    displayName: 'Test User',
-                    userPrincipalName: 'user@contoso.com'
-                }
-            });
-            const profile = await getSocialProvider(SocialProviderTypeEnum.MICROSOFT).fetchProfile(CREDENTIALS, 'code');
-            expect(profile.email).toBe('user@contoso.com');
-        });
-        it('rejects when the token endpoint fails', async ()=>{
-            mockFetchSequence({
-                ok: false,
-                status: 400,
-                body: {
-                    error: 'invalid_grant'
-                }
-            });
-            await expect(getSocialProvider(SocialProviderTypeEnum.LINKEDIN).fetchProfile(CREDENTIALS, 'code')).rejects.toThrow(UnauthorizedException);
-        });
-        it('rejects when the token response carries no access token', async ()=>{
-            mockFetchSequence({
-                body: {
-                    token_type: 'bearer'
-                }
-            });
-            await expect(getSocialProvider(SocialProviderTypeEnum.GOOGLE).fetchProfile(CREDENTIALS, 'code')).rejects.toThrow(UnauthorizedException);
-        });
-    });
-});

package/fesm/services/auth-config.service.js

@@ -1,103 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { envConfig } from '@flusys/nestjs-core/config';
-import { SYSTEM_MESSAGES } from '@flusys/nestjs-shared/constants';
-import { Inject, Injectable, InternalServerErrorException, Optional } from '@nestjs/common';
-import { AUTH_MODULE_OPTIONS } from '../config/auth.constants';
-import { AuthModuleOptions } from '../interfaces/auth-module-options.interface';
-export 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;
-    }
-    isSignUpEnabled() {
-        return this.options.bootstrapAppConfig?.enableSignUp ?? true;
-    }
-    isPermissionModeFound() {
-        return this.options.bootstrapAppConfig?.permissionMode !== undefined;
-    }
-    // JWT Configuration
-    getJwtSecret() {
-        if (!this.config.jwtSecret) {
-            throw new InternalServerErrorException({
-                message: '[AuthModule] JWT_SECRET is required - set via environment or module config',
-                messageKey: SYSTEM_MESSAGES.CONFIG_REQUIRED
-            });
-        }
-        return this.config.jwtSecret;
-    }
-    getJwtExpiration() {
-        return this.config.jwtExpiration ?? '1h';
-    }
-    getRefreshTokenSecret() {
-        if (this.config.refreshTokenSecret) {
-            return this.config.refreshTokenSecret;
-        }
-        if (envConfig.isProduction()) {
-            throw new InternalServerErrorException({
-                message: '[AuthModule] REFRESH_TOKEN_SECRET is required in production - using the same secret for access and refresh tokens is a security risk',
-                messageKey: 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([
-    Injectable(),
-    _ts_param(0, Optional()),
-    _ts_param(0, Inject(AUTH_MODULE_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof AuthModuleOptions === "undefined" ? Object : AuthModuleOptions
-    ])
-], AuthConfigService);

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

@@ -1,96 +0,0 @@
-import { InternalServerErrorException } from '@nestjs/common';
-import { envConfig } from '@flusys/nestjs-core/config';
-import { AuthConfigService } from './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();
-            expect(service.getDatabaseMode()).toBe('single');
-            expect(service.isMultiTenant()).toBe(false);
-            expect(service.isCompanyFeatureEnabled()).toBe(false);
-            expect(service.isEmailVerificationEnabled()).toBe(true);
-            expect(service.isSignUpEnabled()).toBe(true);
-            expect(service.isPermissionModeFound()).toBe(false);
-        });
-        it('throws when reading the JWT secret without configuration', ()=>{
-            const service = new AuthConfigService();
-            expect(()=>service.getJwtSecret()).toThrow(InternalServerErrorException);
-        });
-        it('falls back to the JWT secret for refresh token secret outside production', ()=>{
-            const service = new 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();
-            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,
-                    enableSignUp: 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(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(buildOptions());
-            expect(service.isCompanyFeatureEnabled()).toBe(true);
-            expect(service.isEmailVerificationEnabled()).toBe(false);
-            expect(service.isSignUpEnabled()).toBe(false);
-            expect(service.isPermissionModeFound()).toBe(true);
-        });
-        it('returns configured JWT and refresh token values', ()=>{
-            const service = new 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)', ()=>{
-            envConfig.isProduction.mockReturnValue(true);
-            const service = new AuthConfigService(buildOptions({
-                config: {
-                    jwtSecret: 'jwt-secret'
-                }
-            }));
-            expect(()=>service.getRefreshTokenSecret()).toThrow(InternalServerErrorException);
-        });
-    });
-});

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

@@ -1,87 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { MultiTenantDataSourceService } from '@flusys/nestjs-shared';
-import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
-import { REQUEST } from '@nestjs/core';
-import { Request } from 'express';
-import { AUTH_MODULE_OPTIONS } from '../config/auth.constants';
-import { AuthModuleOptions } from '../interfaces/auth-module-options.interface';
-export class AuthDataSourceProvider extends 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;
-    }
-    isSignUpEnabled(tenant) {
-        const effectiveTenant = tenant ?? this.getCurrentTenant();
-        return effectiveTenant?.enableSignUp ?? this.authOptions.bootstrapAppConfig?.enableSignUp ?? true;
-    }
-    async getAuthEntities() {
-        const { getAuthEntitiesByConfig } = await import('../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([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject(AUTH_MODULE_OPTIONS)),
-    _ts_param(1, Optional()),
-    _ts_param(1, Inject(REQUEST)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof AuthModuleOptions === "undefined" ? Object : AuthModuleOptions,
-        typeof Request === "undefined" ? Object : Request
-    ])
-], AuthDataSourceProvider);