@punks/backend-entity-manager 0.0.144 → 0.0.146

package/dist/cjs/index.js

@@ -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 {
@@ -22247,8 +22267,10 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
             .orderBy(field)
             .getRawMany();
         return {
-            field: field,
-            values: results,
+            values: results.map((x) => ({
+                value: x.value,
+                count: Number(x.count),
+            })),
         };
     }
     async calculateStringFieldFacets(field, request, context) {