@punks/backend-entity-manager 0.0.144 → 0.0.146

package/dist/cjs/types/integrations/repository/typeorm/facets.d.ts

@@ -4,7 +4,6 @@ export type FacetValueType<T> = {
 };
 export type FacetType<T> = {
     values: FacetValueType<T>[];
-    field: string;
 };
 export type StringFacetsType = FacetType<string>;
 export type NumberFacetsType = FacetType<number>;

package/dist/cjs/types/templates/pipelines/instance/index.d.ts

@@ -15,6 +15,7 @@ export declare class PipelineInstance<TPipelineInput, TPipelineOutput, TContext>
     private validateStepPrecondition;
     private executeStep;
     private executeOperation;
+    private shouldSkipOperation;
     private rollbackOperations;
     private rollbackOperation;
 }

package/dist/cjs/types/templates/pipelines/utils/index.d.ts

@@ -0,0 +1,4 @@
+import { PipelineOperationResultType, PipelineOperationRollbackResultType, PipelineStepResultType } from "../../../types";
+export declare const isOperationSuccessStatus: (type: PipelineOperationResultType) => boolean;
+export declare const isOperationRollbackErrorStatus: (type: PipelineOperationRollbackResultType) => boolean;
+export declare const isStepSuccessStatus: (type: PipelineStepResultType) => boolean;

package/dist/cjs/types/types/pipelines.d.ts

@@ -12,6 +12,7 @@ export type OperationDefinition<TOperationInput, TOperationOutput, TCurrentStepI
     name: string;
     action: (input: TOperationInput, state: PipelineCurrentStepState<TPipelineInput, TContext, TCurrentStepInput>) => Promise<TOperationOutput> | TOperationOutput;
     precondition?: (input: TOperationInput, state: PipelineCurrentStepState<TPipelineInput, TContext, TCurrentStepInput>) => Promise<boolean> | boolean;
+    skipIf?: (input: TOperationInput, state: PipelineCurrentStepState<TPipelineInput, TContext, TCurrentStepInput>) => Promise<boolean> | boolean;
 };
 export type RollbackOperationDefinition<TOperationInput, TOperationOutput, TCurrentStepInput, TPipelineInput, TContext> = {
     name: string;
@@ -39,6 +40,8 @@ export type PipelineOperationResult<TOperationInput, TOperationOutput> = {
 } & ({
     type: "success";
     output: TOperationOutput;
+} | {
+    type: "skipped";
 } | {
     type: "preconditionFailed";
 } | {

package/dist/esm/index.js

@@ -21158,6 +21158,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;
@@ -21234,10 +21239,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",
@@ -21268,7 +21272,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)))
@@ -21289,6 +21293,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",
@@ -21307,6 +21321,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 {
@@ -22239,8 +22259,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) {