@flusys/nestjs-auth 1.0.0-beta → 1.0.0

package/cjs/entities/user-token.entity.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get TokenType () {
+        return TokenType;
+    },
+    get UserToken () {
+        return UserToken;
+    }
+});
+const _typeorm = require("typeorm");
+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);
+}
+var TokenType = /*#__PURE__*/ function(TokenType) {
+    TokenType["PASSWORD_RESET"] = "password_reset";
+    TokenType["EMAIL_VERIFICATION"] = "email_verification";
+    TokenType["EMAIL_CHANGE"] = "email_change";
+    return TokenType;
+}({});
+let UserToken = class UserToken {
+    constructor(){
+        _define_property(this, "id", void 0);
+        _define_property(this, "userId", void 0);
+        _define_property(this, "type", void 0);
+        _define_property(this, "token", void 0);
+        _define_property(this, "expiresAt", void 0);
+        _define_property(this, "usedAt", void 0);
+        _define_property(this, "metadata", void 0);
+        _define_property(this, "createdAt", void 0);
+    }
+};
+_ts_decorate([
+    (0, _typeorm.PrimaryGeneratedColumn)('uuid'),
+    _ts_metadata("design:type", String)
+], UserToken.prototype, "id", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'uuid',
+        name: 'user_id'
+    }),
+    _ts_metadata("design:type", String)
+], UserToken.prototype, "userId", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'varchar',
+        length: 32
+    }),
+    _ts_metadata("design:type", String)
+], UserToken.prototype, "type", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'varchar',
+        length: 64
+    }),
+    _ts_metadata("design:type", String)
+], UserToken.prototype, "token", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'timestamp',
+        name: 'expires_at'
+    }),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], UserToken.prototype, "expiresAt", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'timestamp',
+        name: 'used_at',
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], UserToken.prototype, "usedAt", void 0);
+_ts_decorate([
+    (0, _typeorm.Column)({
+        type: 'varchar',
+        length: 255,
+        nullable: true
+    }),
+    _ts_metadata("design:type", Object)
+], UserToken.prototype, "metadata", void 0);
+_ts_decorate([
+    (0, _typeorm.CreateDateColumn)({
+        type: 'timestamp',
+        name: 'created_at'
+    }),
+    _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], UserToken.prototype, "createdAt", void 0);
+UserToken = _ts_decorate([
+    (0, _typeorm.Entity)('user_tokens'),
+    (0, _typeorm.Index)('IDX_user_token_token', [
+        'token'
+    ], {
+        unique: true
+    }),
+    (0, _typeorm.Index)('IDX_user_token_user_type', [
+        'userId',
+        'type'
+    ]),
+    (0, _typeorm.Index)('IDX_user_token_expires', [
+        'expiresAt'
+    ])
+], UserToken);

package/cjs/interceptors/clear-token.interceptor.js

@@ -8,8 +8,10 @@ Object.defineProperty(exports, "ClearToken", {
         return ClearToken;
     }
 });
+const _utils = require("@flusys/nestjs-shared/utils");
 const _common = require("@nestjs/common");
 const _rxjs = require("rxjs");
+const _config = require("../config");
 const _authconfigservice = require("../services/auth-config.service");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -38,39 +40,24 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-const DEFAULT_COOKIE_NAME = 'fsn_refresh_token';
 let ClearToken = class ClearToken {
     get cookieName() {
-        return this.authConfig?.getRefreshTokenCookieName() ?? DEFAULT_COOKIE_NAME;
+        return this.authConfig?.getRefreshTokenCookieName() ?? _config.DEFAULT_COOKIE_NAME;
     }
     intercept(context, next) {
         const req = context.switchToHttp().getRequest();
         const res = context.switchToHttp().getResponse();
         return next.handle().pipe((0, _rxjs.map)((value)=>{
-            // Clear the refresh token cookie
-            this.clearRefreshTokenCookie(req, res);
+            if ((0, _utils.isBrowserRequest)(req)) {
+                res.clearCookie(this.cookieName, {
+                    httpOnly: true,
+                    path: '/',
+                    ...(0, _utils.buildCookieOptions)(req)
+                });
+            }
             return value;
         }));
     }
-    /**
-   * Clear refresh token cookie
-   */ clearRefreshTokenCookie(req, res) {
-        const origin = req.headers.origin || '';
-        const hostname = req.hostname || '';
-        const isHttps = origin.startsWith('https://') || req.secure;
-        let cookieDomain = hostname;
-        const domainParts = hostname.split('.');
-        if (domainParts.length > 2) {
-            cookieDomain = '.' + domainParts.slice(-2).join('.');
-        }
-        res.clearCookie(this.cookieName, {
-            httpOnly: true,
-            secure: isHttps,
-            sameSite: isHttps ? 'strict' : 'lax',
-            domain: cookieDomain,
-            path: '/'
-        });
-    }
     constructor(authConfig){
         _define_property(this, "authConfig", void 0);
         this.authConfig = authConfig;

package/cjs/interceptors/set-token.interceptor.js

@@ -8,9 +8,11 @@ Object.defineProperty(exports, "SetToken", {
         return SetToken;
     }
 });
+const _utils = require("@flusys/nestjs-shared/utils");
 const _common = require("@nestjs/common");
 const _buffer = require("buffer");
 const _rxjs = require("rxjs");
+const _config = require("../config");
 const _authconfigservice = require("../services/auth-config.service");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -39,80 +41,37 @@ function _ts_param(paramIndex, decorator) {
         decorator(target, key, paramIndex);
     };
 }
-const DEFAULT_COOKIE_NAME = 'fsn_refresh_token';
-const MAX_COOKIE_BYTES = 3500;
 let SetToken = class SetToken {
     get cookieName() {
-        return this.authConfig?.getRefreshTokenCookieName() ?? DEFAULT_COOKIE_NAME;
+        return this.authConfig?.getRefreshTokenCookieName() ?? _config.DEFAULT_COOKIE_NAME;
+    }
+    get maxAgeMs() {
+        return (0, _utils.parseDurationToMs)(this.authConfig?.getRefreshTokenExpiration() ?? '7d');
     }
     intercept(context, next) {
         const req = context.switchToHttp().getRequest();
         const res = context.switchToHttp().getResponse();
         return next.handle().pipe((0, _rxjs.map)((value)=>{
-            // Skip if no refreshToken in response
-            if (!value || !value.refreshToken) {
-                return value;
-            }
-            const isBrowser = this.isBrowserRequest(req);
-            const tokenValue = value.refreshToken;
-            if (isBrowser) {
-                // Browser: Set cookie and remove from response body
-                this.setRefreshTokenCookie(req, res, tokenValue);
-                // Return response without refreshToken for browsers
+            if (!value?.refreshToken) return value;
+            if ((0, _utils.isBrowserRequest)(req)) {
+                this.setRefreshTokenCookie(req, res, value.refreshToken);
                 const { refreshToken, ...responseWithoutToken } = value;
                 return responseWithoutToken;
             }
-            // API/Mobile: Keep refreshToken in response body
             return value;
         }), (0, _rxjs.catchError)((err)=>(0, _rxjs.throwError)(()=>err)));
     }
-    /**
-   * Detect if request is from a browser
-   * Checks Accept header and custom X-Client-Type header
-   */ isBrowserRequest(req) {
-        // Check custom header first (allows explicit client identification)
-        const clientType = req.headers['x-client-type'];
-        if (clientType) {
-            return clientType.toLowerCase() === 'browser' || clientType.toLowerCase() === 'web';
-        }
-        // Check Accept header - browsers typically include text/html
-        const accept = req.headers['accept'] || '';
-        if (accept.includes('text/html')) {
-            return true;
-        }
-        // Check User-Agent for common browsers
-        const userAgent = req.headers['user-agent'] || '';
-        const browserPatterns = /mozilla|chrome|safari|firefox|edge|opera|msie/i;
-        if (browserPatterns.test(userAgent) && !userAgent.includes('Postman')) {
-            return true;
-        }
-        return false;
-    }
-    /**
-   * Set refresh token in HTTP-only cookie
-   */ setRefreshTokenCookie(req, res, tokenValue) {
-        const origin = req.headers.origin || '';
-        const hostname = req.hostname || '';
-        const isHttps = origin.startsWith('https://') || req.secure;
-        let cookieDomain = hostname;
-        const domainParts = hostname.split('.');
-        if (domainParts.length > 2) {
-            cookieDomain = '.' + domainParts.slice(-2).join('.');
-        }
-        // Check cookie size
-        const rawCookieString = `${this.cookieName}=${tokenValue}; HttpOnly; Domain=${cookieDomain}`;
+    setRefreshTokenCookie(req, res, tokenValue) {
+        const rawCookieString = `${this.cookieName}=${tokenValue}; HttpOnly`;
         const estimatedBytes = _buffer.Buffer.byteLength(rawCookieString, 'utf8');
-        if (estimatedBytes > MAX_COOKIE_BYTES) {
+        if (estimatedBytes > _config.MAX_COOKIE_BYTES) {
             throw new _common.PayloadTooLargeException(`Refresh token too large (≈${estimatedBytes} bytes)`);
         }
-        // Set HTTP-only secure cookie
         res.cookie(this.cookieName, tokenValue, {
             httpOnly: true,
-            secure: isHttps,
-            sameSite: isHttps ? 'strict' : 'lax',
-            domain: cookieDomain,
             path: '/',
-            maxAge: 7 * 24 * 60 * 60 * 1000
+            maxAge: this.maxAgeMs,
+            ...(0, _utils.buildCookieOptions)(req)
         });
     }
     constructor(authConfig){
@@ -123,6 +82,7 @@ let SetToken = class SetToken {
 SetToken = _ts_decorate([
     (0, _common.Injectable)(),
     _ts_param(0, (0, _common.Optional)()),
+    _ts_param(0, (0, _common.Inject)(_authconfigservice.AuthConfigService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _authconfigservice.AuthConfigService === "undefined" ? Object : _authconfigservice.AuthConfigService

package/cjs/interfaces/auth-email-provider.interface.js

@@ -0,0 +1,45 @@
+/**
+ * Auth Email  Provider Interface
+ *
+ * This interface defines the contract for email sending in the auth module.
+ * It allows auth to work independently of the email module.
+ *
+ * To use email features in auth:
+ * 1. Provide AUTH_EMAIL_PROVIDER in your app module
+ * 2. Implement IAuthEmailProvider using EmailSendService from nestjs-email
+ *
+ * @example
+ * ```typescript
+ * // In app.module.ts or a provider file
+ * {
+ *   provide: AUTH_EMAIL_PROVIDER,
+ *   useFactory: (emailSendService: EmailSendService) => ({
+ *     sendPasswordResetEmail: async (email, token, resetUrl) => {
+ *       await emailSendService.sendTemplateEmail({
+ *         templateSlug: 'password-reset',
+ *         to: email,
+ *         variables: { resetUrl, token },
+ *       });
+ *     },
+ *     sendVerificationEmail: async (email, token, verifyUrl) => {
+ *       await emailSendService.sendTemplateEmail({
+ *         templateSlug: 'email-verification',
+ *         to: email,
+ *         variables: { verifyUrl, token },
+ *       });
+ *     },
+ *   }),
+ *   inject: [EmailSendService],
+ * }
+ * ```
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AUTH_EMAIL_PROVIDER", {
+    enumerable: true,
+    get: function() {
+        return AUTH_EMAIL_PROVIDER;
+    }
+});
+const AUTH_EMAIL_PROVIDER = 'AUTH_EMAIL_PROVIDER';

package/cjs/interfaces/index.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./authentication.interface"), exports);
+_export_star(require("./auth-email-provider.interface"), exports);
 _export_star(require("./company-branch.interface"), exports);
 _export_star(require("./company.interface"), exports);
 _export_star(require("./user.interface"), exports);
+_export_star(require("./user-enricher.interface"), exports);
 _export_star(require("./auth-module-options.interface"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/cjs/interfaces/user-enricher.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/cjs/modules/auth.module.js

@@ -12,16 +12,15 @@ const _modules = require("@flusys/nestjs-shared/modules");
 const _common = require("@nestjs/common");
 const _jwt = require("@nestjs/jwt");
 const _passport = require("@nestjs/passport");
-const _typeorm = require("@nestjs/typeorm");
-const _authconfigservice = require("../services/auth-config.service");
-const _authdatasourceprovider = require("../services/auth-datasource.provider");
+const _guards = require("@flusys/nestjs-shared/guards");
 const _authconstants = require("../config/auth.constants");
 const _controllers = require("../controllers");
 const _entities = require("../entities");
-const _guards = require("@flusys/nestjs-shared/guards");
 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;
@@ -31,79 +30,42 @@ function _ts_decorate(decorators, target, key, desc) {
 }
 let AuthModule = class AuthModule {
     static forRoot(options) {
-        return this.buildDynamicModule(options);
+        const optionsProvider = {
+            provide: _authconstants.AUTH_MODULE_OPTIONS,
+            useValue: options
+        };
+        return this.buildModule(options, [
+            optionsProvider,
+            ...options.providers ?? []
+        ]);
     }
-    static forRootAsync(asyncOptions) {
-        const { global = false, includeController = true, bootstrapAppConfig: { enableCompanyFeature } = {}, imports: externalImports = [] } = asyncOptions;
-        const asyncProviders = this.createAsyncProviders(asyncOptions);
-        // Build imports
-        const imports = [
-            ...externalImports,
-            _passport.PassportModule.register({
-                defaultStrategy: 'jwt'
-            }),
-            _jwt.JwtModule.register({}),
-            _modules.CacheModule,
-            _modules.UtilsModule
-        ];
-        // Build controllers based on configuration
-        const controllers = [];
-        if (includeController) {
-            // Core authentication controller (always included)
-            controllers.push(_controllers.AuthenticationController);
-            // User controller (always included)
-            controllers.push(_controllers.UserController);
-            // Company feature controllers (conditional)
-            if (enableCompanyFeature) {
-                controllers.push(_controllers.CompanySelectionController, _controllers.CompanyController, _controllers.BranchController, _controllers.UserPermissionController);
-            }
-        }
-        // Build providers
-        const providers = [
+    static forRootAsync(options) {
+        const asyncProviders = this.createAsyncProviders(options);
+        return this.buildModule(options, [
             ...asyncProviders,
-            // Config & Infrastructure
-            _authconfigservice.AuthConfigService,
-            _authdatasourceprovider.AuthDataSourceProvider,
-            // Auth core
-            _jwtstrategy.JwtStrategy,
-            _guards.JwtAuthGuard,
-            _services.AuthenticationService,
-            // Interceptors
-            _settokeninterceptor.SetToken,
-            _cleartokeninterceptor.ClearToken,
-            // Core services (always included)
-            _services.UserService
-        ];
-        // Company feature services (conditional)
-        if (enableCompanyFeature) {
-            providers.push(_services.CompanySelectionSessionService, _services.CompanyService, _services.BranchService, _services.UserPermissionService);
-        }
-        // Build exports
-        const exports1 = [
-            _passport.PassportModule,
-            _authconstants.AUTH_MODULE_OPTIONS,
-            _authconfigservice.AuthConfigService,
-            _authdatasourceprovider.AuthDataSourceProvider,
-            _jwtstrategy.JwtStrategy,
-            _guards.JwtAuthGuard,
-            _services.AuthenticationService,
-            _services.UserService
-        ];
-        if (enableCompanyFeature) {
-            exports1.push(_services.CompanySelectionSessionService, _services.CompanyService, _services.BranchService, _services.UserPermissionService);
-        }
+            ...options.providers ?? []
+        ], options.imports);
+    }
+    /** Build the dynamic module with shared logic */ static buildModule(options, providers, externalImports = []) {
+        const { global = false, includeController = true, bootstrapAppConfig } = options;
+        const enableCompanyFeature = bootstrapAppConfig?.enableCompanyFeature ?? false;
         return {
             module: AuthModule,
             global,
-            imports,
-            controllers,
-            providers,
-            exports: exports1
+            imports: [
+                ...externalImports,
+                ...this.buildImports()
+            ],
+            controllers: this.buildControllers(includeController, enableCompanyFeature),
+            providers: [
+                ...providers,
+                ...this.buildProviders(enableCompanyFeature)
+            ],
+            exports: this.buildExports(enableCompanyFeature)
         };
     }
-    static buildDynamicModule(options) {
-        const { bootstrapAppConfig: { enableCompanyFeature } = {}, includeController = true, global = false } = options;
-        const imports = [
+    /** Common module imports */ static buildImports() {
+        return [
             _passport.PassportModule.register({
                 defaultStrategy: 'jwt'
             }),
@@ -111,40 +73,36 @@ let AuthModule = class AuthModule {
             _modules.CacheModule,
             _modules.UtilsModule
         ];
-        // Build controllers based on configuration
-        const controllers = [];
-        if (includeController) {
-            // Core authentication controller (always included)
-            controllers.push(_controllers.AuthenticationController);
-            // User controller (always included)
-            controllers.push(_controllers.UserController);
-            // Company feature controllers (conditional)
-            if (enableCompanyFeature) {
-                controllers.push(_controllers.CompanySelectionController, _controllers.CompanyController, _controllers.BranchController, _controllers.UserPermissionController);
-            }
+    }
+    /** Build controllers based on feature flags */ static buildControllers(includeController, enableCompanyFeature) {
+        if (!includeController) return [];
+        const controllers = [
+            _controllers.AuthenticationController,
+            _controllers.UserController
+        ];
+        if (enableCompanyFeature) {
+            controllers.push(_controllers.CompanySelectionController, _controllers.CompanyController, _controllers.BranchController, _controllers.UserPermissionController);
         }
+        return controllers;
+    }
+    /** Core providers (without AUTH_MODULE_OPTIONS - that's added separately) */ static buildProviders(enableCompanyFeature) {
         const providers = [
-            {
-                provide: _authconstants.AUTH_MODULE_OPTIONS,
-                useValue: options
-            },
-            // Config & Infrastructure
             _authconfigservice.AuthConfigService,
             _authdatasourceprovider.AuthDataSourceProvider,
-            // Auth core
             _jwtstrategy.JwtStrategy,
             _guards.JwtAuthGuard,
             _services.AuthenticationService,
-            // Interceptors
+            _services.AuthEmailService,
             _settokeninterceptor.SetToken,
             _cleartokeninterceptor.ClearToken,
-            // Core services (always included)
             _services.UserService
         ];
-        // Company feature services (conditional)
         if (enableCompanyFeature) {
             providers.push(_services.CompanySelectionSessionService, _services.CompanyService, _services.BranchService, _services.UserPermissionService);
         }
+        return providers;
+    }
+    /** Build module exports */ static buildExports(enableCompanyFeature) {
         const exports1 = [
             _passport.PassportModule,
             _authconstants.AUTH_MODULE_OPTIONS,
@@ -153,21 +111,15 @@ let AuthModule = class AuthModule {
             _jwtstrategy.JwtStrategy,
             _guards.JwtAuthGuard,
             _services.AuthenticationService,
+            _services.AuthEmailService,
             _services.UserService
         ];
         if (enableCompanyFeature) {
             exports1.push(_services.CompanySelectionSessionService, _services.CompanyService, _services.BranchService, _services.UserPermissionService);
         }
-        return {
-            module: AuthModule,
-            global,
-            imports,
-            controllers,
-            providers,
-            exports: exports1
-        };
+        return exports1;
     }
-    static createAsyncProviders(options) {
+    /** Create async providers for forRootAsync */ static createAsyncProviders(options) {
         const staticOptions = {
             global: options.global,
             includeController: options.includeController,
@@ -177,13 +129,10 @@ let AuthModule = class AuthModule {
             return [
                 {
                     provide: _authconstants.AUTH_MODULE_OPTIONS,
-                    useFactory: async (...args)=>{
-                        const config = await options.useFactory(...args);
-                        return {
+                    useFactory: async (...args)=>({
                             ...staticOptions,
-                            config
-                        };
-                    },
+                            config: await options.useFactory(...args)
+                        }),
                     inject: options.inject || []
                 }
             ];
@@ -196,13 +145,10 @@ let AuthModule = class AuthModule {
                 },
                 {
                     provide: _authconstants.AUTH_MODULE_OPTIONS,
-                    useFactory: async (factory)=>{
-                        const config = await factory.createAuthOptions();
-                        return {
+                    useFactory: async (factory)=>({
                             ...staticOptions,
-                            config
-                        };
-                    },
+                            config: await factory.createAuthOptions()
+                        }),
                     inject: [
                         options.useClass
                     ]
@@ -213,13 +159,10 @@ let AuthModule = class AuthModule {
             return [
                 {
                     provide: _authconstants.AUTH_MODULE_OPTIONS,
-                    useFactory: async (factory)=>{
-                        const config = await factory.createAuthOptions();
-                        return {
+                    useFactory: async (factory)=>({
                             ...staticOptions,
-                            config
-                        };
-                    },
+                            config: await factory.createAuthOptions()
+                        }),
                     inject: [
                         options.useExisting
                     ]
@@ -233,35 +176,14 @@ let AuthModule = class AuthModule {
             }
         ];
     }
-    /**
-   * Create repository providers that use AuthDataSourceProvider
-   * This replaces TypeOrmModule.forFeature() functionality
-   * Note: Must be REQUEST-scoped since AuthDataSourceProvider is REQUEST-scoped
-   */ static getRepositoryProviders(enableCompanyFeature) {
-        const entities = this.getEntities(enableCompanyFeature);
-        return entities.map((entity)=>({
-                provide: (0, _typeorm.getRepositoryToken)(entity),
-                scope: _common.Scope.REQUEST,
-                useFactory: async (dataSourceProvider)=>{
-                    return await dataSourceProvider.getRepository(entity);
-                },
-                inject: [
-                    _authdatasourceprovider.AuthDataSourceProvider
-                ]
-            }));
-    }
-    static getEntities(enableCompanyFeature = false) {
-        const coreEntities = [
-            _entities.User
-        ];
-        const companyEntities = enableCompanyFeature ? [
+    /** Get auth entities based on feature flags */ static getEntities(enableCompanyFeature = false) {
+        return enableCompanyFeature ? [
+            _entities.User,
             _entities.Company,
             _entities.CompanyBranch,
             _entities.UserCompanyPermission
-        ] : [];
-        return [
-            ...coreEntities,
-            ...companyEntities
+        ] : [
+            _entities.User
         ];
     }
 };