@punks/backend-entity-manager 0.0.67 → 0.0.69

package/dist/esm/index.js

@@ -1,6 +1,7 @@
 import { Log, sort, byField, toDict, newUuid as newUuid$1, removeUndefinedProps } from '@punks/backend-core';
 import { applyDecorators, Injectable, SetMetadata, Global, Module, Scope, Logger, HttpStatus, HttpException } from '@nestjs/common';
 import { ApiProperty } from '@nestjs/swagger';
+import { Reflector } from '@nestjs/core';
 import { AsyncLocalStorage } from 'async_hooks';
 import { hash } from 'bcrypt';
 import { PATH_METADATA } from '@nestjs/common/constants';
@@ -9,7 +10,6 @@ import { MetadataScanner } from '@nestjs/core/metadata-scanner';
 import { JwtService, JwtModule } from '@nestjs/jwt';
 import { EventEmitter2, EventEmitterModule } from '@nestjs/event-emitter';
 import { In } from 'typeorm';
-import { Reflector } from '@nestjs/core';
 import { SendEmailCommand, SESClient } from '@aws-sdk/client-ses';
 import require$$2 from 'fs';
 import { MailService } from '@sendgrid/mail';
@@ -312,10 +312,27 @@ __decorate([
 
 const AuthenticationExtensionSymbols = {
     UserService: Symbol.for("WP.EXT:AUTHENTICATION.USER_SERVICE"),
+    RolesService: Symbol.for("WP.EXT:AUTHENTICATION.ROLES_SERVICE"),
+    UserRolesService: Symbol.for("WP.EXT:AUTHENTICATION.USER_ROLES_SERVICE"),
+};
+const AuthenticationGuardsSymbols = {
+    Authenticated: "guard:authenticated",
+    Public: "guard:public",
+    Roles: "guard:roles",
+    MemberOf: "guard:memberOf",
 };
 
+const Public = () => SetMetadata(AuthenticationGuardsSymbols.Public, true);
+const Authenticated = () => SetMetadata(AuthenticationGuardsSymbols.Authenticated, true);
+const Roles = (...roles) => SetMetadata(AuthenticationGuardsSymbols.Roles, roles);
+const MemberOf = (...groups) => SetMetadata(AuthenticationGuardsSymbols.MemberOf, groups);
+
+const WpRolesService = () => applyDecorators(Injectable(), SetMetadata(AuthenticationExtensionSymbols.RolesService, true));
+
 const WpUserService = () => applyDecorators(Injectable(), SetMetadata(AuthenticationExtensionSymbols.UserService, true));
 
+const WpUserRolesService = () => applyDecorators(Injectable(), SetMetadata(AuthenticationExtensionSymbols.UserRolesService, true));
+
 const AuthenticationEmailTemplates = {
     Registration: "registration",
     PasswordReset: "passwordReset",
@@ -350,6 +367,59 @@ const AuthenticationEvents = {
     UserPasswordResetCompleted: `${AUTHENTICATION_EVENTS_NAMESPACE}:user.passwordResetCompleted`,
 };
 
+let AuthGuard = class AuthGuard {
+    constructor(reflector) {
+        this.reflector = reflector;
+    }
+    canActivate(context) {
+        const isPublic = this.getIsPublic(context);
+        if (isPublic) {
+            return true;
+        }
+        const auth = this.getCurrentAuth(context);
+        const allowedRoles = this.getAllowedRoles(context);
+        if (allowedRoles) {
+            return this.isRoleMatching(allowedRoles, auth?.roles ?? []);
+        }
+        const isForAllAuthenticated = this.getIsForAllAuthenticated(context);
+        if (isForAllAuthenticated) {
+            return !!auth?.user;
+        }
+        return false;
+    }
+    isRoleMatching(allowedRoles, userRoles) {
+        return userRoles.some((role) => allowedRoles.includes(role.uid));
+    }
+    getIsForAllAuthenticated(context) {
+        return this.getMetadata(AuthenticationGuardsSymbols.Authenticated, context);
+    }
+    getIsPublic(context) {
+        return this.getMetadata(AuthenticationGuardsSymbols.Public, context);
+    }
+    getAllowedRoles(context) {
+        return this.getMetadata(AuthenticationGuardsSymbols.Roles, context);
+    }
+    getCurrentAuth(context) {
+        const request = context.switchToHttp()?.getRequest();
+        return request?.auth?.user
+            ? {
+                user: request.auth.user,
+                roles: request.auth.roles,
+            }
+            : undefined;
+    }
+    getMetadata(symbol, context) {
+        return this.reflector.getAllAndOverride(symbol, [
+            context.getHandler(),
+            context.getClass(),
+        ]);
+    }
+};
+AuthGuard = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [Reflector])
+], AuthGuard);
+
 const asyncLocalStorage = new AsyncLocalStorage();
 
 let AppSessionService = class AppSessionService {
@@ -19073,12 +19143,30 @@ let AuthenticationServicesResolver = class AuthenticationServicesResolver {
     registerUsersService(usersService) {
         this.usersService = usersService;
     }
+    registerRoleService(rolesService) {
+        this.rolesService = rolesService;
+    }
+    registerUserRolesService(userRolesService) {
+        this.usersRolesService = userRolesService;
+    }
     getUsersService() {
         if (!this.usersService) {
             throw new Error("Users service is not registered");
         }
         return this.usersService;
     }
+    getRoleService() {
+        if (!this.rolesService) {
+            throw new Error("Roles service is not registered");
+        }
+        return this.rolesService;
+    }
+    getUserRoleService() {
+        if (!this.usersRolesService) {
+            throw new Error("User roles service is not registered");
+        }
+        return this.usersRolesService;
+    }
 };
 AuthenticationServicesResolver = __decorate([
     Injectable()
@@ -19187,6 +19275,7 @@ let UserRegistrationHandler = class UserRegistrationHandler {
             this.logger.debug(`User already exists but not verified. Sending new verification email: ${input.email} - ${input.userName}`, { user });
             return {
                 success: true,
+                userId: user.id,
             };
         }
         const newUser = await this.createUser(input.email, input.registrationInfo, input.context);
@@ -19201,6 +19290,7 @@ let UserRegistrationHandler = class UserRegistrationHandler {
         });
         return {
             success: true,
+            userId: newUser.id,
         };
     }
     async createPasswordHash(password, userId) {
@@ -19565,7 +19655,7 @@ UserVerifyRequestHandler = __decorate([
 ], UserVerifyRequestHandler);
 
 let AuthenticationService = class AuthenticationService {
-    constructor(userDisableHandler, userEnableHandler, userLoginHandler, userPasswordChangeHandler, userPasswordResetFinalizeHandler, userPasswordResetRequestHandler, userRegistrationHandler, userTokenVerifyHandler, userVerifyRequestHandler, userVerifyCompleteHandler) {
+    constructor(userDisableHandler, userEnableHandler, userLoginHandler, userPasswordChangeHandler, userPasswordResetFinalizeHandler, userPasswordResetRequestHandler, userRegistrationHandler, userTokenVerifyHandler, userVerifyRequestHandler, userVerifyCompleteHandler, resolver) {
         this.userDisableHandler = userDisableHandler;
         this.userEnableHandler = userEnableHandler;
         this.userLoginHandler = userLoginHandler;
@@ -19576,6 +19666,7 @@ let AuthenticationService = class AuthenticationService {
         this.userTokenVerifyHandler = userTokenVerifyHandler;
         this.userVerifyRequestHandler = userVerifyRequestHandler;
         this.userVerifyCompleteHandler = userVerifyCompleteHandler;
+        this.resolver = resolver;
     }
     async userDisable(input) {
         await this.userDisableHandler.execute(input);
@@ -19607,6 +19698,15 @@ let AuthenticationService = class AuthenticationService {
     async userTokenVerify(input) {
         return await this.userTokenVerifyHandler.execute(input);
     }
+    get usersService() {
+        return this.resolver.getUsersService();
+    }
+    get rolesService() {
+        return this.resolver.getRoleService();
+    }
+    get userRolesService() {
+        return this.resolver.getUserRoleService();
+    }
 };
 AuthenticationService = __decorate([
     Injectable(),
@@ -19619,12 +19719,13 @@ AuthenticationService = __decorate([
         UserRegistrationHandler,
         UserTokenVerifyHandler,
         UserVerifyRequestHandler,
-        UserVerifyCompleteHandler])
+        UserVerifyCompleteHandler,
+        AuthenticationServicesResolver])
 ], AuthenticationService);
 
-const Services$1 = [AuthenticationService];
+const Services$2 = [AuthenticationService];
 
-const Services = [
+const Services$1 = [
     AppSessionService,
     AppHashingService,
     EntityManagerService,
@@ -19847,8 +19948,8 @@ let EntityManagerModule = class EntityManagerModule {
 EntityManagerModule = __decorate([
     Module({
         imports: [CustomDiscoveryModule, EventEmitterModule],
-        providers: [...IoC, ...Providers, ...Processors, ...Services],
-        exports: [EntityManagerRegistry, ...Services],
+        providers: [...IoC, ...Providers, ...Processors, ...Services$1],
+        exports: [EntityManagerRegistry, ...Services$1],
     })
 ], EntityManagerModule);
 
@@ -19875,16 +19976,44 @@ let AuthenticationInitializer = AuthenticationInitializer_1 = class Authenticati
         this.logger = new Logger(AuthenticationInitializer_1.name);
     }
     async initialize(app) {
-        const userService = await this.discoverUserService();
-        if (!userService) {
+        await this.registerRolesService();
+        await this.registerUsersService();
+        await this.registerUserRolesService();
+        this.logger.log("Authentication initialized 🔑");
+    }
+    async registerRolesService() {
+        const service = await this.discoverRolesService();
+        if (!service) {
+            throw new Error("No roles service found");
+        }
+        this.registry.registerRoleService(service.discoveredClass.instance);
+        this.logger.log(`Authentication roles service ${service.discoveredClass.name} registered`);
+    }
+    async registerUsersService() {
+        const service = await this.discoverUserService();
+        if (!service) {
             throw new Error("No user service found");
         }
-        this.registry.registerUsersService(userService.discoveredClass.instance);
-        this.logger.log("Authentication initialized 🔑");
+        this.registry.registerUsersService(service.discoveredClass.instance);
+        this.logger.log(`Authentication users service ${service.discoveredClass.name} registered`);
+    }
+    async registerUserRolesService() {
+        const service = await this.discoverUserRolesService();
+        if (!service) {
+            throw new Error("No user roles service found");
+        }
+        this.registry.registerUserRolesService(service.discoveredClass.instance);
+        this.logger.log(`Authentication user roles service ${service.discoveredClass.name} registered`);
     }
     async discoverUserService() {
         return await this.discover.providerWithMetaAtKey(AuthenticationExtensionSymbols.UserService);
     }
+    async discoverRolesService() {
+        return await this.discover.providerWithMetaAtKey(AuthenticationExtensionSymbols.RolesService);
+    }
+    async discoverUserRolesService() {
+        return await this.discover.providerWithMetaAtKey(AuthenticationExtensionSymbols.UserRolesService);
+    }
 };
 AuthenticationInitializer = AuthenticationInitializer_1 = __decorate([
     WpAppInitializer(),
@@ -19892,17 +20021,95 @@ AuthenticationInitializer = AuthenticationInitializer_1 = __decorate([
         AuthenticationServicesResolver])
 ], AuthenticationInitializer);
 
+class AppSession {
+    constructor(request, response) {
+        this._map = new Map();
+        this._request = request;
+        this._response = response;
+    }
+    get(key) {
+        return this._map.get(key);
+    }
+    set(key, value) {
+        this._map.set(key, value);
+    }
+    delete(key) {
+        this._map.delete(key);
+    }
+    clear() {
+        this._map.clear();
+    }
+    get request() {
+        return this._request;
+    }
+    get response() {
+        return this._response;
+    }
+}
+
+let AppSessionMiddleware = class AppSessionMiddleware {
+    use(req, res, next) {
+        asyncLocalStorage.run(new AppSession(req, res), () => {
+            next();
+        });
+    }
+};
+AppSessionMiddleware = __decorate([
+    Injectable()
+], AppSessionMiddleware);
+function appSessionMiddleware(req, res, next) {
+    asyncLocalStorage.run(new AppSession(req, res), () => {
+        next();
+    });
+}
+
+let AuthenticationMiddleware = class AuthenticationMiddleware {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    async use(req, res, next) {
+        const token = this.extractTokenFromHeader(req);
+        if (token) {
+            const parsedToken = await this.authService.userTokenVerify({ token });
+            if (parsedToken.isValid) {
+                const user = await this.getUserFromToken(parsedToken.data);
+                const roles = user ? await this.getUserRoles(user) : [];
+                req.auth = {
+                    user,
+                    roles,
+                };
+            }
+        }
+        next();
+    }
+    async getUserFromToken(parsedToken) {
+        return await this.authService.usersService.getById(parsedToken.userId);
+    }
+    async getUserRoles(user) {
+        return await this.authService.userRolesService.getUserRoles(user.id);
+    }
+    extractTokenFromHeader(request) {
+        const [type, token] = request.headers.authorization?.split(" ") ?? [];
+        return type === "Bearer" ? token : undefined;
+    }
+};
+AuthenticationMiddleware = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [AuthenticationService])
+], AuthenticationMiddleware);
+
 var AuthenticationModule_1;
 const ModuleData$2 = {
     imports: [EntityManagerModule, JwtModule],
     providers: [
         AuthenticationServicesResolver,
         AuthenticationInitializer,
-        ...Services$1,
+        AuthGuard,
+        ...Services$2,
         ...UserHandlers,
         ...AuthenticationProviders,
     ],
-    exports: [...Services$1],
+    exports: [...Services$2],
 };
 let AuthenticationModule = AuthenticationModule_1 = class AuthenticationModule {
     static forRoot(input) {
@@ -19912,6 +20119,13 @@ let AuthenticationModule = AuthenticationModule_1 = class AuthenticationModule {
             ...ModuleData$2,
         };
     }
+    configure(consumer) {
+        consumer
+            .apply(appSessionMiddleware)
+            .forRoutes("*")
+            .apply(AuthenticationMiddleware)
+            .forRoutes("*");
+    }
 };
 AuthenticationModule = AuthenticationModule_1 = __decorate([
     Module({
@@ -19919,10 +20133,41 @@ AuthenticationModule = AuthenticationModule_1 = __decorate([
     })
 ], AuthenticationModule);
 
+let OrganizationInitializerService = class OrganizationInitializerService {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async execute(template) { }
+};
+OrganizationInitializerService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [EntityManagerRegistry])
+], OrganizationInitializerService);
+
+let TenantInitializerService = class TenantInitializerService {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async execute(template) { }
+};
+TenantInitializerService = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [EntityManagerRegistry])
+], TenantInitializerService);
+
+const Services = [
+    OrganizationInitializerService,
+    TenantInitializerService,
+];
+
 let MultiTenancyModule = class MultiTenancyModule {
 };
 MultiTenancyModule = __decorate([
-    Module({})
+    Module({
+        imports: [EntityManagerModule],
+        providers: [...Providers, ...Services],
+        exports: [...Services],
+    })
 ], MultiTenancyModule);
 
 class QueryBuilderBase {
@@ -19972,7 +20217,7 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
                 ...(context ? this.buildContextFilter(context) : {}),
                 ...this.buildWhereClause(request),
             },
-            relations: this.getRelationsToLoad(request),
+            relations: this.getRelationsToLoad(request, context),
             ...this.buildPagingParameters(request),
         });
     }
@@ -25399,42 +25644,5 @@ SendgridEmailModule = SendgridEmailModule_1 = __decorate([
     })
 ], SendgridEmailModule);
 
-class AppSession {
-    constructor(request, response) {
-        this._map = new Map();
-        this._request = request;
-        this._response = response;
-    }
-    get(key) {
-        return this._map.get(key);
-    }
-    set(key, value) {
-        this._map.set(key, value);
-    }
-    delete(key) {
-        this._map.delete(key);
-    }
-    clear() {
-        this._map.clear();
-    }
-    get request() {
-        return this._request;
-    }
-    get response() {
-        return this._response;
-    }
-}
-
-let AppSessionMiddleware = class AppSessionMiddleware {
-    use(req, res, next) {
-        asyncLocalStorage.run(new AppSession(req, res), () => {
-            next();
-        });
-    }
-};
-AppSessionMiddleware = __decorate([
-    Injectable()
-], AppSessionMiddleware);
-
-export { AUTHENTICATION_EVENTS_NAMESPACE, AppExceptionsFilterBase, AppHashingService, AppInMemorySettings, AppSessionMiddleware, AppSessionService, AuthenticationEmailTemplates, AuthenticationError, AuthenticationEvents, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationService, AwsEmailModule, AwsSesEmailTemplate, BooleanFacet, BooleanFacetItem, EmailService, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerRegistry, EntityManagerService, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntitySeeder, EventsService, InvalidCredentialsError, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestTypeOrmEntitySeeder, NestTypeOrmQueryBuilder, NestTypeOrmRepository, NumericFacet, NumericFacetItem, OperationTokenMismatchError, PLATFORM_EVENT_NAMESPACE, PlatformEvents, QueryBuilderBase, ReplicationMode, SendgridEmailModule, SendgridEmailTemplate, SortDirection, StringFacet, StringFacetItem, TrackingService, UserRegistrationError, WpAppInitializer, WpAwsSesEmailTemplate, WpEmailTemplate, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpEntitySeeder, WpEventsTracker, WpSendgridEmailTemplate, WpUserService, getLocalizedText, newUuid, renderHandlebarsTemplate };
+export { AUTHENTICATION_EVENTS_NAMESPACE, AppExceptionsFilterBase, AppHashingService, AppInMemorySettings, AppSessionMiddleware, AppSessionService, AuthGuard, Authenticated, AuthenticationEmailTemplates, AuthenticationError, AuthenticationEvents, AuthenticationExtensionSymbols, AuthenticationModule, AuthenticationService, AwsEmailModule, AwsSesEmailTemplate, BooleanFacet, BooleanFacetItem, EmailService, EntityManagerConfigurationError, EntityManagerException, EntityManagerInitializer, EntityManagerModule, EntityManagerRegistry, EntityManagerService, EntityManagerSymbols, EntityManagerUnauthorizedException, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntitySeeder, EventsService, InvalidCredentialsError, MemberOf, ModulesContainerProvider, MultiTenancyModule, MultipleEntitiesFoundException, NestEntityActions, NestEntityAuthorizationMiddleware, NestEntityManager, NestTypeOrmEntitySeeder, NestTypeOrmQueryBuilder, NestTypeOrmRepository, NumericFacet, NumericFacetItem, OperationTokenMismatchError, PLATFORM_EVENT_NAMESPACE, PlatformEvents, Public, QueryBuilderBase, ReplicationMode, Roles, SendgridEmailModule, SendgridEmailTemplate, SortDirection, StringFacet, StringFacetItem, TrackingService, UserRegistrationError, WpAppInitializer, WpAwsSesEmailTemplate, WpEmailTemplate, WpEntity, WpEntityActions, WpEntityAdapter, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository, WpEntitySeeder, WpEventsTracker, WpRolesService, WpSendgridEmailTemplate, WpUserRolesService, WpUserService, getLocalizedText, newUuid, renderHandlebarsTemplate };
 //# sourceMappingURL=index.js.map