@punks/backend-entity-manager 0.0.145 → 0.0.147

package/dist/cjs/index.js

@@ -20558,7 +20558,7 @@ let UserRegistrationHandler = class UserRegistrationHandler {
         await this.emailService.sendTemplatedEmail({
             to: [user.email],
             templateId: AuthenticationEmailTemplates.Registration,
-            languageId,
+            languageCode: languageId,
             payload: {
                 firstName: user.profile.firstName,
                 lastName: user.profile.lastName,
@@ -20761,17 +20761,17 @@ let UserPasswordResetRequestHandler = class UserPasswordResetRequestHandler {
                 success: false,
             };
         }
-        await this.sendPasswordResetEmail(user, input.callback, input.languageId);
+        await this.sendPasswordResetEmail(user, input.callback, input.languageCode);
         return {
             success: true,
         };
     }
-    async sendPasswordResetEmail(user, callback, languageId) {
+    async sendPasswordResetEmail(user, callback, languageCode) {
         const token = await this.generatePasswordResetToken(user);
         await this.emailService.sendTemplatedEmail({
             to: [user.email],
             templateId: AuthenticationEmailTemplates.PasswordReset,
-            languageId,
+            languageCode,
             payload: {
                 firstName: user.profile.firstName,
                 lastName: user.profile.lastName,
@@ -20886,7 +20886,7 @@ let UserVerifyRequestHandler = class UserVerifyRequestHandler {
                 lastName: user.profile.lastName,
                 callbackUrl: callback.urlTemplate.replace(callback.tokenPlaceholder, token),
             },
-            languageId,
+            languageCode: languageId,
         });
     }
     async generateEmailVerifyToken(user) {
@@ -21166,6 +21166,11 @@ const mapPipelineErrorType = (stepError) => {
     }
 };
 
+const isOperationSuccessStatus = (type) => {
+    return ["success", "skipped"].includes(type);
+};
+const isOperationRollbackErrorStatus = (type) => ["error"].includes(type);
+
 class PipelineInstance {
     constructor(definition, input, context) {
         this.definition = definition;
@@ -21242,10 +21247,9 @@ class PipelineInstance {
             result: x,
             operation: step.operations[i],
         }));
-        // .filter((x) => x.result.type === "success")
         const rollbackOperations = completedOperations.map((x) => this.rollbackOperations(x.operation, x.result.input, getOperationOutput(x.result), state));
         const rollbackResults = await Promise.all(rollbackOperations);
-        const isRollbackError = rollbackResults.some((x) => x.type === "error");
+        const isRollbackError = rollbackResults.some((x) => isOperationRollbackErrorStatus(x.type));
         if (isRollbackError) {
             return {
                 type: "error",
@@ -21276,7 +21280,7 @@ class PipelineInstance {
         }
         const stepOperations = step.operations.map((x) => this.executeOperation(x, input, state));
         const operationResults = await Promise.all(stepOperations);
-        const isSuccess = operationResults.every((x) => x.type === "success");
+        const isSuccess = operationResults.every((x) => isOperationSuccessStatus(x.type));
         if (isSuccess) {
             const output = step.outputsReducer
                 ? step.outputsReducer(operationResults.map((x) => getOperationOutput(x)))
@@ -21297,6 +21301,16 @@ class PipelineInstance {
     }
     async executeOperation(operation, input, state) {
         try {
+            const shouldSkip = await this.shouldSkipOperation(operation, input, state);
+            if (shouldSkip) {
+                this.logger.info(`Pipeline operation skipped -> operation:${operation.name}`, {
+                    input,
+                });
+                return {
+                    type: "skipped",
+                    input,
+                };
+            }
             const operationResult = await operation.operation.action(input, state);
             return {
                 type: "success",
@@ -21315,6 +21329,12 @@ class PipelineInstance {
             };
         }
     }
+    async shouldSkipOperation({ operation, }, input, state) {
+        if (!operation.skipIf) {
+            return false;
+        }
+        return await operation.skipIf(input, state);
+    }
     async rollbackOperations(operation, operationInput, operationOutput, state) {
         if (!operation.rollbackOperations?.length) {
             return {
@@ -28017,13 +28037,13 @@ let SendgridEmailProvider = class SendgridEmailProvider {
         const processedPayload = await template.processPayload(input.payload);
         const templateData = await template.getTemplateData(processedPayload);
         if (templateData.type === "html") {
-            const body = getLocalizedText(templateData.bodyTemplate, input.languageId);
+            const body = getLocalizedText(templateData.bodyTemplate, input.languageCode);
             if (!body) {
-                throw new Error(`Missing body template for language ${input.languageId}`);
+                throw new Error(`Missing body template for language ${input.languageCode}`);
             }
-            const subject = getLocalizedText(templateData.subjectTemplate, input.languageId);
+            const subject = getLocalizedText(templateData.subjectTemplate, input.languageCode);
             if (!subject) {
-                throw new Error(`Missing subject template for language ${input.languageId}`);
+                throw new Error(`Missing subject template for language ${input.languageCode}`);
             }
             await this.sendHtmlEmail({
                 bodyTemplate: body,