@punks/backend-entity-manager 0.0.72 → 0.0.74

package/dist/cjs/index.js

@@ -433,7 +433,12 @@ exports.AuthGuard = __decorate([
     __metadata("design:paramtypes", [core.Reflector])
 ], exports.AuthGuard);
 
-const asyncLocalStorage = new async_hooks.AsyncLocalStorage();
+exports.UserCreationError = void 0;
+(function (UserCreationError) {
+    UserCreationError["UserAlreadyExists"] = "userAlreadyExists";
+})(exports.UserCreationError || (exports.UserCreationError = {}));
+
+const sessionStorage = new async_hooks.AsyncLocalStorage();
 
 exports.AppSessionService = class AppSessionService {
     getValue(key) {
@@ -449,7 +454,7 @@ exports.AppSessionService = class AppSessionService {
         return this.getSession().request;
     }
     getSession() {
-        const store = asyncLocalStorage.getStore();
+        const store = sessionStorage.getStore();
         if (!store) {
             throw new Error("No active context found");
         }
@@ -610,7 +615,10 @@ class EntityCreateCommand {
             return;
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService.getContext();
+        const context = await contextService?.getContext();
+        if (!context) {
+            return;
+        }
         const authorizationResult = await authorization.canCreate(entity, context);
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Create, this.services.getEntityName(), entity);
@@ -636,7 +644,10 @@ class EntityDeleteCommand {
             throw new EntityNotFoundException(id);
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService.getContext();
+        const context = await contextService?.getContext();
+        if (!context) {
+            return;
+        }
         const authorizationResult = await authorization.canDelete(entity, context);
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Delete, this.services.getEntityName(), entity);
@@ -670,7 +681,10 @@ class EntitiesDeleteCommand {
             return;
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService.getContext();
+        const context = await contextService?.getContext();
+        if (!context) {
+            return;
+        }
         const authorizationResult = await authorization.canDeleteItems(context);
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Delete, this.services.getEntityName());
@@ -708,7 +722,10 @@ class EntityUpdateCommand {
             throw new EntityNotFoundException();
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService.getContext();
+        const context = await contextService?.getContext();
+        if (!context) {
+            return;
+        }
         const authorizationResult = await authorization.canUpdate(currentEntity, context);
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Create, this.services.getEntityName(), currentEntity);
@@ -744,7 +761,10 @@ class EntityUpsertCommand {
         }
         const currentEntity = await this.services.resolveRepository().get(id);
         const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService.getContext();
+        const context = await contextService?.getContext();
+        if (!context) {
+            return;
+        }
         if (currentEntity) {
             const updateResult = await authorization.canUpdate(currentEntity, context);
             if (!updateResult.isAuthorized)
@@ -1087,7 +1107,9 @@ class EntitiesServiceLocator {
         this.provider.register(GlobalServices.Pipelines.IPipelineController, instance);
     }
     resolveAuthenticationContextProvider() {
-        return this.provider.resolve(GlobalServices.Authentication.IAuthenticationContextProvider);
+        return this.provider.resolve(GlobalServices.Authentication.IAuthenticationContextProvider, {
+            optional: true,
+        });
     }
     registerAuthenticationContextProvider(instance) {
         this.provider.register(GlobalServices.Authentication.IAuthenticationContextProvider, instance);
@@ -1399,7 +1421,10 @@ class EntityGetQuery {
             return;
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        const context = await contextService.getContext();
+        const context = await contextService?.getContext();
+        if (!context) {
+            return;
+        }
         const authorizationResult = await authorization.canRead(entity, context);
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Read, this.services.getEntityName(), entity);
@@ -1434,7 +1459,7 @@ class EntitiesSearchQuery {
             return undefined;
         }
         const contextService = this.services.resolveAuthenticationContextProvider();
-        return await contextService.getContext();
+        return await contextService?.getContext();
     }
     async filterAllowedEntities(entities, context) {
         const authorization = this.services.resolveAuthorizationMiddleware();
@@ -19513,7 +19538,7 @@ let UserRegistrationHandler = class UserRegistrationHandler {
                 userId: user.id,
             };
         }
-        const newUser = await this.createUser(input.email, input.registrationInfo, input.context);
+        const newUser = await this.createUser(input.email, input.userName, input.registrationInfo, input.context);
         const passwordHash = await this.createPasswordHash(input.password, newUser.id);
         await this.services.getUsersService().update(newUser.id, {
             passwordHash,
@@ -19554,8 +19579,10 @@ let UserRegistrationHandler = class UserRegistrationHandler {
             timestamp: Date.now(),
         });
     }
-    async createUser(email, info, context) {
-        return await this.services.getUsersService().create(email, info, context);
+    async createUser(email, userName, info, context) {
+        return await this.services
+            .getUsersService()
+            .create(email, userName, info, context);
     }
     async resolveUser(userName, context) {
         return ((await this.services
@@ -19889,9 +19916,92 @@ UserVerifyRequestHandler = __decorate([
         JwtProvider])
 ], UserVerifyRequestHandler);
 
+let UserCreationHandler = class UserCreationHandler {
+    constructor(services, passwordHashingProvider) {
+        this.services = services;
+        this.passwordHashingProvider = passwordHashingProvider;
+        this.logger = backendCore.Log.getLogger("UserCreation");
+    }
+    async execute(input) {
+        const user = (await this.resolveUser(input.email, input.context)) ??
+            (await this.resolveUser(input.userName, input.context));
+        if (user && user.verified) {
+            this.logger.debug(`User already exists: ${input.email} - ${input.userName}`, { user });
+            return {
+                success: false,
+                error: exports.UserCreationError.UserAlreadyExists,
+            };
+        }
+        if (user && !user.verified) {
+            const passwordHash = await this.createPasswordHash(input.password, user.id);
+            await this.services.getUsersService().update(user.id, {
+                passwordHash,
+                passwordUpdateTimestamp: new Date(),
+                verified: true,
+            });
+            this.logger.debug(`User already exists but not verified. Updating password and marking as verified: ${input.email} - ${input.userName}`, { user });
+            return {
+                success: true,
+                userId: user.id,
+            };
+        }
+        const newUser = await this.createUser(input.email, input.userName, input.registrationInfo, input.context);
+        const passwordHash = await this.createPasswordHash(input.password, newUser.id);
+        await this.services.getUsersService().update(newUser.id, {
+            passwordHash,
+            passwordUpdateTimestamp: new Date(),
+            verified: true,
+        });
+        this.logger.debug(`New user created: ${input.email} - ${input.userName}`, {
+            user: newUser,
+        });
+        return {
+            success: true,
+            userId: newUser.id,
+        };
+    }
+    async createPasswordHash(password, userId) {
+        return await this.passwordHashingProvider.hashPassword({
+            password,
+            userId,
+        });
+    }
+    async createUser(email, userName, info, context) {
+        return await this.services
+            .getUsersService()
+            .create(email, userName, info, context);
+    }
+    async resolveUser(userName, context) {
+        return ((await this.services
+            .getUsersService()
+            .getByUserName(userName, context)) ??
+            (await this.services.getUsersService().getByEmail(userName, context)));
+    }
+};
+UserCreationHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver,
+        PasswordHashingProvider])
+], UserCreationHandler);
+
+let UserDeleteHandler = class UserDeleteHandler {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(input) {
+        await this.services.getUsersService().delete(input.userId);
+    }
+};
+UserDeleteHandler = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [AuthenticationServicesResolver])
+], UserDeleteHandler);
+
 exports.AuthenticationService = class AuthenticationService {
-    constructor(userDisableHandler, userEnableHandler, userLoginHandler, userPasswordChangeHandler, userPasswordResetFinalizeHandler, userPasswordResetRequestHandler, userRegistrationHandler, userTokenVerifyHandler, userVerifyRequestHandler, userVerifyCompleteHandler, resolver) {
+    constructor(userCreationHandler, userDisableHandler, userDeleteHandler, userEnableHandler, userLoginHandler, userPasswordChangeHandler, userPasswordResetFinalizeHandler, userPasswordResetRequestHandler, userRegistrationHandler, userTokenVerifyHandler, userVerifyRequestHandler, userVerifyCompleteHandler, resolver) {
+        this.userCreationHandler = userCreationHandler;
         this.userDisableHandler = userDisableHandler;
+        this.userDeleteHandler = userDeleteHandler;
         this.userEnableHandler = userEnableHandler;
         this.userLoginHandler = userLoginHandler;
         this.userPasswordChangeHandler = userPasswordChangeHandler;
@@ -19903,9 +20013,15 @@ exports.AuthenticationService = class AuthenticationService {
         this.userVerifyCompleteHandler = userVerifyCompleteHandler;
         this.resolver = resolver;
     }
+    async userCreate(input) {
+        return await this.userCreationHandler.execute(input);
+    }
     async userDisable(input) {
         await this.userDisableHandler.execute(input);
     }
+    async userDelete(input) {
+        await this.userDeleteHandler.execute(input);
+    }
     async userEnable(input) {
         await this.userEnableHandler.execute(input);
     }
@@ -19945,7 +20061,9 @@ exports.AuthenticationService = class AuthenticationService {
 };
 exports.AuthenticationService = __decorate([
     common.Injectable(),
-    __metadata("design:paramtypes", [UserDisableHandler,
+    __metadata("design:paramtypes", [UserCreationHandler,
+        UserDisableHandler,
+        UserDeleteHandler,
         UserEnableHandler,
         UserLoginHandler,
         UserPasswordChangeHandler,
@@ -20006,6 +20124,21 @@ const orderByPriority = (items, priorityFieldSelector, nameFieldSelector) => {
     return backendCore.sort(items, backendCore.byField((x) => priorityFieldSelector(x) ?? Number.MAX_VALUE), backendCore.byField((x) => nameFieldSelector(x)));
 };
 
+exports.PipelineStepErrorType = void 0;
+(function (PipelineStepErrorType) {
+    PipelineStepErrorType["FailedPrecondition"] = "failedPrecondition";
+    PipelineStepErrorType["OperationError"] = "operationError";
+    PipelineStepErrorType["RollbackError"] = "rollbackError";
+    PipelineStepErrorType["GenericError"] = "genericError";
+})(exports.PipelineStepErrorType || (exports.PipelineStepErrorType = {}));
+exports.PipelineErrorType = void 0;
+(function (PipelineErrorType) {
+    PipelineErrorType["FailedPrecondition"] = "failedPrecondition";
+    PipelineErrorType["OperationError"] = "operationError";
+    PipelineErrorType["RollbackError"] = "rollbackError";
+    PipelineErrorType["Unauthorized"] = "unauthorized";
+    PipelineErrorType["GenericError"] = "genericError";
+})(exports.PipelineErrorType || (exports.PipelineErrorType = {}));
 exports.PipelineStatus = void 0;
 (function (PipelineStatus) {
     PipelineStatus["Initializing"] = "initializing";
@@ -20025,6 +20158,18 @@ const getStepOutput = (result) => {
 const getOperationOutput = (result) => {
     return result.type === "success" ? result.output : undefined;
 };
+const mapPipelineErrorType = (stepError) => {
+    switch (stepError) {
+        case exports.PipelineStepErrorType.FailedPrecondition:
+            return exports.PipelineErrorType.FailedPrecondition;
+        case exports.PipelineStepErrorType.OperationError:
+            return exports.PipelineErrorType.OperationError;
+        case exports.PipelineStepErrorType.RollbackError:
+            return exports.PipelineErrorType.RollbackError;
+        case exports.PipelineStepErrorType.GenericError:
+            return exports.PipelineErrorType.GenericError;
+    }
+};
 
 class PipelineInstance {
     constructor(definition, input, context) {
@@ -20048,6 +20193,7 @@ class PipelineInstance {
                 await this.rollbackSteps(executedSteps, stepResults, state);
                 return {
                     type: "error",
+                    errorType: mapPipelineErrorType(stepResult.errorType),
                     input: this.input,
                     stepResults,
                 };
@@ -20127,7 +20273,8 @@ class PipelineInstance {
         if (!preconditionResult.hasValidPrecondition) {
             return {
                 operationResults: [],
-                type: "preconditionFailed",
+                type: "error",
+                errorType: exports.PipelineStepErrorType.FailedPrecondition,
                 input,
             };
         }
@@ -20147,6 +20294,7 @@ class PipelineInstance {
         }
         return {
             type: "error",
+            errorType: exports.PipelineStepErrorType.OperationError,
             operationResults,
             input,
         };
@@ -20444,7 +20592,7 @@ class PipelineStepBuilder {
             },
         };
     }
-    build() {
+    complete() {
         return {
             steps: this.currentSteps,
         };
@@ -20497,7 +20645,19 @@ exports.PipelinesRunner = __decorate([
 
 const PipelineProviders = [exports.PipelinesBuilder, exports.PipelinesRunner];
 
+// export const iocStorage = new AsyncLocalStorage<IocContext>()
+const initializeIoCContext = (context) => {
+};
+
 exports.EntityManagerModule = class EntityManagerModule {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    onModuleInit() {
+        initializeIoCContext({
+            registry: this.registry,
+        });
+    }
 };
 exports.EntityManagerModule = __decorate([
     common.Module({
@@ -20510,11 +20670,14 @@ exports.EntityManagerModule = __decorate([
             ...PipelineProviders,
         ],
         exports: [exports.EntityManagerRegistry, ...Services$1],
-    })
+    }),
+    __metadata("design:paramtypes", [exports.EntityManagerRegistry])
 ], exports.EntityManagerModule);
 
 const UserHandlers = [
+    UserCreationHandler,
     UserDisableHandler,
+    UserDeleteHandler,
     UserEnableHandler,
     UserLoginHandler,
     UserPasswordChangeHandler,
@@ -20609,7 +20772,7 @@ class AppSession {
 
 exports.AppSessionMiddleware = class AppSessionMiddleware {
     use(req, res, next) {
-        asyncLocalStorage.run(new AppSession(req, res), () => {
+        sessionStorage.run(new AppSession(req, res), () => {
             next();
         });
     }
@@ -20618,7 +20781,7 @@ exports.AppSessionMiddleware = __decorate([
     common.Injectable()
 ], exports.AppSessionMiddleware);
 function appSessionMiddleware(req, res, next) {
-    asyncLocalStorage.run(new AppSession(req, res), () => {
+    sessionStorage.run(new AppSession(req, res), () => {
         next();
     });
 }
@@ -20974,6 +21137,14 @@ class NestTypeOrmEntitySeeder extends TypeOrmEntitySeeder {
     }
 }
 
+class PipelineInvocationError extends Error {
+    constructor(errorType, innerError, message) {
+        super(message ?? innerError?.message);
+        this.errorType = errorType;
+        this.innerError = innerError;
+    }
+}
+
 class AppExceptionsFilterBase {
     catch(exception, host) {
         const ctx = host.switchToHttp();
@@ -21009,6 +21180,16 @@ class AppExceptionsFilterBase {
         if (exception instanceof common.HttpException) {
             return exception.getStatus();
         }
+        if (exception instanceof PipelineInvocationError) {
+            switch (exception.errorType) {
+                case exports.PipelineErrorType.Unauthorized:
+                    return common.HttpStatus.UNAUTHORIZED;
+                case exports.PipelineErrorType.FailedPrecondition:
+                    return common.HttpStatus.PRECONDITION_FAILED;
+                default:
+                    return common.HttpStatus.INTERNAL_SERVER_ERROR;
+            }
+        }
         return common.HttpStatus.INTERNAL_SERVER_ERROR;
     }
 }