@digipair/skill-temporal 0.113.1 → 0.114.1

package/src/lib/workflows.ts

@@ -0,0 +1,153 @@
+import { sleep, proxyActivities, condition, setHandler, defineSignal } from '@temporalio/workflow';
+import { ApplicationFailure } from '@temporalio/common';
+import { PinsSettings, preparePinsSettings } from '@digipair/engine';
+import * as feelin from 'feelin';
+
+import type * as activities from './activities.js';
+import { WorkflowArgs } from './shared.js';
+
+const { evaluate } = feelin as any;
+export const dataSignal = defineSignal<[any]>('data');
+
+async function executePins(
+  executePinsList: any,
+  steps: PinsSettings[],
+  state: { step: number },
+  settingsOrigin: PinsSettings,
+  context: any,
+) {
+  const settings = await preparePinsSettings(settingsOrigin, context);
+  let result = null;
+
+  if (settings.conditions?.each) {
+    const results = [] as any[];
+
+    for (let index = 0; index < settings.conditions.each.length; index++) {
+      const item = settings.conditions.each[index];
+      const itemSettingsOrigin = {
+        ...settingsOrigin,
+        conditions: { ...settingsOrigin.conditions, each: undefined },
+      };
+      const itemContext = {
+        ...context,
+        item,
+        index,
+        parent: { item: context.item, index: item.index, parent: context.parent },
+      };
+      const itemSettings = await preparePinsSettings(itemSettingsOrigin, itemContext);
+
+      if (typeof itemSettings.conditions?.if !== 'undefined' && !itemSettings.conditions.if) {
+        continue;
+      }
+
+      let itemResult = null;
+      try {
+        itemResult = await executePins(
+          executePinsList,
+          steps,
+          state,
+          itemSettingsOrigin,
+          itemContext,
+        );
+      } catch (error) {
+        if (error === 'DIGIPAIR_CONDITIONS_IF_FALSE') {
+          continue;
+        }
+
+        throw error;
+      }
+
+      results.push(itemResult);
+    }
+
+    return results;
+  }
+
+  if (typeof settings.conditions?.if !== 'undefined' && !settings.conditions.if) {
+    throw 'DIGIPAIR_CONDITIONS_IF_FALSE';
+  }
+
+  if (settings.element === 'sleep') {
+    result = await sleep((settings.properties as any)['duration']);
+  } else if (settings.element === 'condition') {
+    result = await condition(
+      () => evaluate(settings.properties.condition, context),
+      settings.properties.timeout,
+    );
+  } else if (settings.element === 'stop') {
+    throw 'DIGIPAIR_WORKFLOW_STOP';
+  } else if (settings.element === 'goto') {
+    const step = steps
+      .filter(current => !!current.properties?.['name'])
+      .findIndex(
+        current => (current.properties as any)['name'] === (settings.properties as any)['name'],
+      );
+
+    if (step <= -1) {
+      throw new ApplicationFailure('[SKILL-TEMPORAL] GOTO FAILED - STEP NOT FOUND', null, null, [
+        (settings.properties as any)['name'],
+      ]);
+    }
+    result = state.step = step;
+  } else if (settings.element === 'activity') {
+    try {
+      result = await executePinsList({
+        pinsSettingsList: (settings.properties as any)['execute'],
+        context,
+      });
+    } catch (error) {
+      throw new ApplicationFailure('[SKILL-TEMPORAL] EXECUTEPINS FAILED', null, null, [
+        error,
+        settings,
+        context,
+      ]);
+    }
+  }
+
+  return result;
+}
+
+export async function workflow({ steps, context, data, options }: WorkflowArgs): Promise<any> {
+  let result: any;
+
+  context.workflow = { steps: {}, data };
+  context.protected = {};
+
+  const { executePinsList } = proxyActivities<typeof activities>(options);
+  setHandler(dataSignal, (data: any) => {
+    context.workflow.data = { ...context.workflow.data, ...data };
+  });
+
+  // vérifie si tous les pinsSettings sont bien de la librairie @digipair/skill-temporal
+  const indexSkillNoWorkflow = steps.findIndex(
+    pinsSettings => pinsSettings.library !== '@digipair/skill-temporal',
+  );
+  if (indexSkillNoWorkflow >= 0) {
+    throw new ApplicationFailure('[SKILL-TEMPORAL] UNKNOWN STEP', null, null, [
+      steps[indexSkillNoWorkflow],
+    ]);
+  }
+
+  // parcourir tous les pins
+  for (let state = { step: 0 }; state.step < steps.length; state.step++) {
+    const pinsSettings = steps[state.step];
+
+    try {
+      result = await executePins(executePinsList, steps, state, pinsSettings, context);
+    } catch (error) {
+      if (error === 'DIGIPAIR_CONDITIONS_IF_FALSE') {
+        continue;
+      } else if (error === 'DIGIPAIR_WORKFLOW_STOP') {
+        return result;
+      }
+
+      throw error;
+    }
+
+    if (pinsSettings.properties?.['name']) {
+      context.workflow.steps[pinsSettings.properties['name']] = result;
+    }
+  }
+
+  return result;
+}

package/src/schema.fr.json

@@ -0,0 +1,443 @@
+{
+  "openapi": "3.0.0",
+  "info": {
+    "title": "@digipair/skill-temporal",
+    "summary": "Gestion des workflows temporal",
+    "description": "gérer des workflows temporal",
+    "version": "0.1.0",
+    "x-icon": "👩‍💻"
+  },
+  "paths": {
+    "/activity": {
+      "post": {
+        "tags": [
+          "service"
+        ],
+        "summary": "Activitée",
+        "description": "Définit une activité",
+        "parameters": [
+          {
+            "name": "name",
+            "summary": "Nom",
+            "required": false,
+            "description": "Nom de l'étape",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "execute",
+            "summary": "Exécute",
+            "required": true,
+            "description": "Liste des actions à exécuter",
+            "schema": {
+              "type": "array",
+              "items": {
+                "$ref": "https://schemas.digipair.ai/pinsSettings"
+              }
+            }
+          }
+        ],
+        "x-events": [],
+        "responses": {
+          "200": {
+            "description": "Résultat de l'exécution de l'activité",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "string",
+                  "description": "Résultat de l'exécution de l'activité"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/sleep": {
+      "post": {
+        "tags": [
+          "service"
+        ],
+        "summary": "Attente",
+        "parameters": [
+          {
+            "name": "name",
+            "summary": "Nom",
+            "required": false,
+            "description": "Nom de l'étape",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "duration",
+            "summary": "Durée",
+            "required": true,
+            "description": "Durée de l'attente",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "x-events": [],
+        "responses": {
+          "200": {
+            "description": "Confirmation de la durée d'attente",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "string",
+                  "description": "Confirmation que la durée d'attente a été appliquée"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/condition": {
+      "post": {
+        "tags": [
+          "service"
+        ],
+        "summary": "Condition d'attente",
+        "description": "Condition d'attente dans un workflow",
+        "parameters": [
+          {
+            "name": "condition",
+            "summary": "Condition",
+            "required": true,
+            "description": "Condition d'attente au format Feel",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "timeout",
+            "summary": "Timeout",
+            "required": false,
+            "description": "Timeout de la condition",
+            "schema": {
+              "type": "number"
+            }
+          }
+        ],
+        "x-events": [],
+        "responses": {
+          "200": {
+            "description": "Résultat de la condition d'attente",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "boolean",
+                  "description": "Si la condition a été remplie avant le timeout"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/goto": {
+      "post": {
+        "tags": [
+          "service"
+        ],
+        "summary": "Aller à l'étape",
+        "parameters": [
+          {
+            "name": "target",
+            "summary": "Nom de la destination",
+            "required": true,
+            "description": "Nom de l'étape de destination",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "name",
+            "summary": "Nom",
+            "required": false,
+            "description": "Nom de l'étape",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "x-events": [],
+        "responses": {
+          "200": {
+            "description": "Numéro d'étape après goto",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "number",
+                  "description": "Numéro de l'étape cible dans le workflow"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/stop": {
+      "post": {
+        "tags": [
+          "service"
+        ],
+        "summary": "Arrête le workflow",
+        "description": "Arrête le workflow",
+        "parameters": [
+          {
+            "name": "name",
+            "summary": "Nom",
+            "required": false,
+            "description": "Nom de l'étape",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "x-events": [],
+        "responses": {
+          "200": {
+            "description": "Confirmation de l'arrêt du workflow",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "null",
+                  "description": "Le workflow a été arrêté"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/push": {
+      "post": {
+        "tags": [
+          "service"
+        ],
+        "summary": "Envoi de nouvelles données dans un workflow",
+        "description": "Envoi de nouvelles données dans le workflow",
+        "parameters": [
+          {
+            "name": "id",
+            "summary": "Identifiant du workflow",
+            "required": true,
+            "description": "Identifiant du workflow",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "data",
+            "summary": "Données",
+            "required": true,
+            "description": "Données",
+            "schema": {
+              "type": "object"
+            }
+          }
+        ],
+        "x-events": [],
+        "responses": {
+          "200": {
+            "description": "Confirmation de l'envoi des données",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "null",
+                  "description": "Les données ont été envoyées avec succès au workflow"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/terminate": {
+      "post": {
+        "tags": [
+          "service"
+        ],
+        "summary": "Arrête un workflow",
+        "description": "Arrête un workflow",
+        "parameters": [
+          {
+            "name": "id",
+            "summary": "Identifiant du workflow",
+            "required": true,
+            "description": "Identifiant du workflow",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "x-events": [],
+        "responses": {
+          "200": {
+            "description": "Confirmation de l'arrêt du workflow",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "null",
+                  "description": "Le workflow a été arrêté avec succès"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/list": {
+      "post": {
+        "tags": [
+          "service"
+        ],
+        "summary": "Liste les workflows",
+        "description": "Liste les workflows",
+        "parameters": [
+          {
+            "name": "query",
+            "summary": "Requête",
+            "required": false,
+            "description": "Requête de recherche",
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "x-events": [],
+        "responses": {
+          "200": {
+            "description": "Liste des workflows",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/WorkflowExecutionInfo"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "WorkflowExecutionInfo": {
+        "tags": [],
+        "type": "object",
+        "description": "Informations sur une exécution de workflow Temporal",
+        "properties": {
+          "workflowId": {
+            "type": "string",
+            "description": "Identifiant unique du workflow"
+          },
+          "runId": {
+            "type": "string",
+            "description": "Identifiant unique de l'exécution du workflow"
+          },
+          "type": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string",
+                "description": "Nom du type de workflow"
+              }
+            }
+          },
+          "status": {
+            "type": "string",
+            "enum": [
+              "Running",
+              "Completed",
+              "Failed",
+              "Cancelled",
+              "Terminated"
+            ],
+            "description": "Statut actuel du workflow"
+          },
+          "startTime": {
+            "type": "string",
+            "format": "date-time",
+            "description": "Quand le workflow a été démarré"
+          },
+          "taskQueue": {
+            "type": "string",
+            "description": "Nom de la file d'attente des tâches utilisée par le workflow"
+          }
+        }
+      }
+    }
+  },
+  "x-scene-blocks": {
+    "/workflow": {
+      "summary": "Workflow Temporal",
+      "description": "Execute un workflow Temporal",
+      "tags": [
+        "service"
+      ],
+      "metadata": [],
+      "parameters": [
+        {
+          "name": "id",
+          "summary": "Identifiant",
+          "required": true,
+          "description": "Identifiant du workflow",
+          "schema": {
+            "type": "string"
+          }
+        },
+        {
+          "name": "steps",
+          "summary": "Exécute les étapes suivantes",
+          "required": true,
+          "description": "Exécute les étapes définies",
+          "schema": {
+            "type": "array",
+            "items": {
+              "$ref": "https://schemas.digipair.ai/pinsSettings"
+            }
+          }
+        },
+        {
+          "name": "data",
+          "summary": "Données du workflow",
+          "required": false,
+          "description": "Données du workflow temporal",
+          "schema": {
+            "type": "object"
+          }
+        },
+        {
+          "name": "options",
+          "summary": "Options temporal",
+          "required": false,
+          "description": "Options du workflow temporal",
+          "schema": {
+            "type": "object"
+          }
+        }
+      ],
+      "responses": {
+        "200": {
+          "description": "Résultat de l'exécution du workflow",
+          "content": {
+            "application/json": {
+              "schema": {
+                "description": "Le résultat de la dernière étape exécutée dans le workflow"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}