@solidxai/core 0.1.13-beta.2 → 0.1.13-beta.4

package/src/seeders/seed-data/solid-core-metadata.json

@@ -8681,16 +8681,42 @@
     {
       "displayName": "Workflow Definitions",
       "name": "workflowDefinition-list-action",
-      "type": "custom",
+      "type": "solid",
       "domain": "",
       "context": "",
-      "customComponent": "/admin/core/solid-core/workflow-definition/list",
+      "customComponent": "",
       "customIsModal": true,
       "serverEndpoint": "",
       "viewUserKey": "workflowDefinition-list-view",
       "moduleUserKey": "solid-core",
       "modelUserKey": "workflowDefinition"
     },
+    {
+      "displayName": "New Workflow Definition",
+      "name": "workflowDefinition-create-action",
+      "type": "custom",
+      "domain": "",
+      "context": "{}",
+      "customComponent": "/admin/core/solid-core/workflow-definition/editor/new",
+      "customIsModal": false,
+      "serverEndpoint": "",
+      "viewUserKey": "workflowDefinition-list-view",
+      "moduleUserKey": "solid-core",
+      "modelUserKey": "workflowDefinition"
+    },
+    {
+      "displayName": "Workflow Definition Editor",
+      "name": "workflowDefinition-editor-action",
+      "type": "custom",
+      "domain": "",
+      "context": "{}",
+      "customComponent": "/admin/core/solid-core/workflow-definition/editor",
+      "customIsModal": false,
+      "serverEndpoint": "",
+      "viewUserKey": "workflowDefinition-list-view",
+      "moduleUserKey": "solid-core",
+      "modelUserKey": "workflowDefinition"
+    },
     {
       "displayName": "Workflow Execution List Action",
       "name": "workflowExecution-list-action",
@@ -17260,97 +17286,71 @@
           ],
           "enableGlobalSearch": true,
           "create": true,
+          "createAction": "workflowDefinition-create-action",
           "edit": true,
+          "editAction": "workflowDefinition-editor-action",
           "delete": true,
-          "headerButtons": [
-            {
-              "attrs": {
-                "label": "Open Workflow Editor",
-                "action": "openWorkflowDefinitionEditorHeaderAction",
-                "actionInContextMenu": false,
-                "openInPopup": false,
-                "icon": "si-sparkles"
-              }
-            }
-          ],
-          "rowButtons": [
-            {
-              "attrs": {
-                "className": "p-button-text",
-                "icon": "si-pencil",
-                "label": "Open Editor",
-                "action": "openWorkflowDefinitionEditorRowAction",
-                "openInPopup": false,
-                "actionInContextMenu": true
-              }
-            }
-          ]
+          "showRowActionsAsIconOnly": true,
+          "showRowActionsInContextMenu": false
         },
         "children": [
           {
             "type": "field",
             "attrs": {
-              "name": "id"
-            }
-          },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "key"
-            }
-          },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "moduleMetadata"
-            }
-          },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "displayName"
-            }
-          },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "namespace"
-            }
-          },
-          {
-            "type": "field",
-            "attrs": {
-              "name": "description"
+              "name": "key",
+              "className": "font-bold",
+              "sortable": true,
+              "isSearchable": true,
+              "truncateAfter": 28
             }
           },
           {
             "type": "field",
             "attrs": {
-              "name": "status"
+              "name": "displayName",
+              "className": "font-bold",
+              "sortable": true,
+              "isSearchable": true,
+              "truncateAfter": 32
             }
           },
           {
             "type": "field",
             "attrs": {
-              "name": "definitionVersion"
+              "name": "namespace",
+              "sortable": true,
+              "isSearchable": true,
+              "truncateAfter": 28
             }
           },
           {
             "type": "field",
             "attrs": {
-              "name": "definitionChecksum"
+              "name": "description",
+              "isSearchable": true,
+              "truncateAfter": 56
             }
           },
           {
             "type": "field",
             "attrs": {
-              "name": "definitionYaml"
+              "name": "status",
+              "sortable": true,
+              "viewWidget": "PillWidget",
+              "pillColorMap": {
+                "draft": "#e5e7eb",
+                "active": "#dcfce7",
+                "inactive": "#fef3c7",
+                "archived": "#ede9fe",
+                "default": "#e5e7eb"
+              }
             }
           },
           {
             "type": "field",
             "attrs": {
-              "name": "tags"
+              "name": "definitionVersion",
+              "sortable": true
             }
           }
         ]
@@ -17518,7 +17518,7 @@
             50
           ],
           "enableGlobalSearch": true,
-          "create": true,
+          "create": false,
           "edit": true,
           "editAction": "workflowExecution-detail-action",
           "delete": true,
@@ -17539,8 +17539,10 @@
             "type": "field",
             "attrs": {
               "name": "executionIdentifier",
+              "className": "font-bold",
               "sortable": true,
-              "isSearchable": true
+              "isSearchable": true,
+              "truncateAfter": 28
             }
           },
           {
@@ -17549,7 +17551,8 @@
               "name": "workflowDefinition",
               "sortable": true,
               "isSearchable": true,
-              "searchField": "workflowDefinition.displayName"
+              "searchField": "workflowDefinition.displayName",
+              "truncateAfter": 30
             }
           },
           {
@@ -17558,7 +17561,8 @@
               "name": "workflowDisplayName",
               "className": "font-bold",
               "sortable": true,
-              "isSearchable": true
+              "isSearchable": true,
+              "truncateAfter": 32
             }
           },
           {
@@ -17583,7 +17587,15 @@
             "attrs": {
               "name": "triggerType",
               "sortable": true,
-              "isSearchable": true
+              "isSearchable": true,
+              "viewWidget": "PillWidget",
+              "pillColorMap": {
+                "manual": "#ede9fe",
+                "schedule": "#e0f2fe",
+                "webhook": "#ccfbf1",
+                "api": "#dbeafe",
+                "default": "#e5e7eb"
+              }
             }
           },
           {
@@ -17611,7 +17623,8 @@
             "type": "field",
             "attrs": {
               "name": "errorSummary",
-              "isSearchable": true
+              "isSearchable": true,
+              "truncateAfter": 56
             }
           }
         ]

package/src/services/workflow/nodes/execution-fail.node.ts

@@ -0,0 +1,82 @@
+import { BadRequestException } from '@nestjs/common';
+import { WorkflowNodeProvider } from '../../../decorators/workflow-node-provider.decorator';
+import { WorkflowNodeHandler } from '../../../interfaces/workflow-node-handler.interface';
+import {
+  WorkflowNodeExecutionContext,
+  WorkflowNodeHandlerResult,
+} from '../../../types/workflow-dsl.types';
+
+@WorkflowNodeProvider({
+  type: 'execution.fail',
+  kind: 'task',
+  version: '1.0.0',
+  category: 'core',
+  subcategory: 'execution',
+  label: 'Fail Execution',
+  description: 'Fails intentionally with a configured message.',
+  tags: ['failure', 'error', 'testing'],
+  aliases: ['fail'],
+  configSchema: {
+    type: 'object',
+    properties: {
+      message: {
+        type: 'string',
+        default: 'Execution failed intentionally.',
+      },
+    },
+  },
+  authoring: {
+    defaultConfiguration: {
+      message: 'Execution failed intentionally.',
+    },
+    configurationFields: [
+      {
+        key: 'message',
+        label: 'Message',
+        description: 'Failure message. Expressions are allowed.',
+        valueType: 'string',
+        expressionAllowed: true,
+        group: 'General',
+      },
+    ],
+    supportsExpressions: true,
+    supportsDisableToggle: true,
+    supportsName: true,
+    supportsDescription: true,
+    searchableText: ['fail', 'failure', 'error', 'testing'],
+  },
+  runtime: {
+    emitsLogs: false,
+    emitsArtifacts: false,
+    deterministicOutputs: true,
+    executionMode: 'task',
+    successStatuses: [],
+  },
+  documentation: {
+    summary:
+      'Use this node in reference workflows and tests to intentionally exercise failure paths and error handlers.',
+  },
+  ui: {
+    icon: 'si-x-circle',
+    iconColor: '#dc2626',
+    iconBackgroundColor: '#fee2e2',
+    iconBorderColor: '#fecaca',
+    modalSize: 'lg',
+    layoutHints: {
+      groupOrder: ['General'],
+    },
+  },
+})
+export class ExecutionFailNode implements WorkflowNodeHandler {
+  async execute(
+    context: WorkflowNodeExecutionContext,
+  ): Promise<WorkflowNodeHandlerResult> {
+    const configuration = context.expression.interpolate(
+      context.node.configuration ?? {},
+      context,
+    );
+    throw new BadRequestException(
+      configuration.message ?? 'Execution failed intentionally.',
+    );
+  }
+}

package/src/services/workflow/nodes/for-each.node.ts

@@ -16,6 +16,8 @@ import {
   authoring: {
     defaultConfiguration: {
       items: '',
+      concurrencyLimit: 1,
+      aggregateOutputs: false,
     },
     configurationFields: [
       {
@@ -32,6 +34,35 @@ import {
           },
         },
       },
+      {
+        key: 'concurrencyLimit',
+        label: 'Concurrency Limit',
+        description:
+          'Maximum number of loop iterations to run at once. Use 1 for sequential execution and 0 for unlimited concurrency.',
+        valueType: 'number',
+        defaultValue: 1,
+        expressionAllowed: true,
+        group: 'General',
+      },
+      {
+        key: 'aggregateOutputs',
+        label: 'Aggregate Outputs',
+        description:
+          'Adds per-iteration child outputs to this forEach node output for downstream expressions.',
+        valueType: 'boolean',
+        defaultValue: false,
+        expressionAllowed: true,
+        group: 'General',
+      },
+      {
+        key: 'outputKey',
+        label: 'Output Key',
+        description:
+          'Optional expression used as the per-iteration key when aggregate outputs is enabled.',
+        valueType: 'string',
+        expressionAllowed: true,
+        group: 'General',
+      },
     ],
     childSlots: [
       {
@@ -42,6 +73,13 @@ import {
         layout: 'sequential',
         required: true,
       },
+      {
+        key: 'errors',
+        label: 'Errors',
+        description: 'Nodes that run sequentially if this loop fails.',
+        kind: 'sequence',
+        layout: 'sequential',
+      },
     ],
     supportsDescription: true,
     supportsName: true,
@@ -66,32 +104,128 @@ export class ForEachNode implements WorkflowNodeHandler {
   ): Promise<WorkflowNodeHandlerResult> {
     const configuration = context.node.configuration ?? {};
     const items = context.expression.interpolate(configuration.items ?? [], context);
+    const concurrencyLimit = this.resolveConcurrencyLimit(
+      context.expression.interpolate(configuration.concurrencyLimit ?? 1, context),
+    );
+    const aggregateOutputs = Boolean(
+      context.expression.interpolate(configuration.aggregateOutputs ?? false, context),
+    );
 
     if (!Array.isArray(items)) {
       throw new BadRequestException('forEach requires configuration.items array.');
     }
 
     const childNodes = context.node.tasks ?? [];
+    const iterationsByIndex: Record<number, any> = {};
+    const iterationsByKey: Record<string, any> = {};
+    const shouldAggregateByKey =
+      aggregateOutputs && configuration.outputKey !== undefined && configuration.outputKey !== null;
 
-    for (let index = 0; index < items.length; index++) {
+    await this.runIterations(items, concurrencyLimit, async (item, index) => {
       const inheritedOutputs = context.outputs ?? {};
       const iterationOutputs = { ...inheritedOutputs };
-
-      await context.runNodes(childNodes, {
-        item: items[index],
+      const parentLoops = context.loops ?? [];
+      const currentLoop = {
+        item,
+        index,
+        nodeId: context.node.id,
+        stepExecutionKey: context.stepExecution.stepExecutionKey,
+      };
+      const loopContext = {
+        item,
         index,
+        parent: parentLoops[parentLoops.length - 1],
+        parents: [...parentLoops].reverse(),
+        loops: [...parentLoops, currentLoop],
+      };
+      const outputKey = shouldAggregateByKey
+        ? String(context.expression.interpolate(configuration.outputKey, {
+            ...context,
+            ...loopContext,
+            outputs: iterationOutputs,
+          }))
+        : undefined;
+
+      const childOutputs = await context.runNodes(childNodes, {
+        ...loopContext,
         outputs: iterationOutputs,
       });
-    }
+
+      if (aggregateOutputs) {
+        const iterationResult = {
+          item,
+          index,
+          outputs: childOutputs,
+        };
+
+        iterationsByIndex[index] = iterationResult;
+        if (outputKey !== undefined) {
+          iterationsByKey[outputKey] = iterationResult;
+        }
+      }
+    });
 
     return {
       output: {
         count: items.length,
         childNodeIds: childNodes.map((childNode) => childNode.id),
+        concurrencyLimit,
         // Keep the control-node output intentionally small. Per-iteration
         // outputs are already stored on the child workflowStepExecution rows.
-        iterationOutputsStoredOnSteps: true,
+        iterationOutputsStoredOnSteps: !aggregateOutputs,
+        ...(aggregateOutputs
+          ? {
+              iterations: {
+                byIndex: iterationsByIndex,
+                ...(shouldAggregateByKey
+                  ? {
+                      byKey: iterationsByKey,
+                    }
+                  : {}),
+              },
+            }
+          : {}),
       },
     };
   }
+
+  private resolveConcurrencyLimit(value: any): number {
+    const parsed = Number(value === '' || value === null || value === undefined ? 1 : value);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+      throw new BadRequestException(
+        'forEach configuration.concurrencyLimit must be 0 or a positive number.',
+      );
+    }
+
+    return Math.floor(parsed);
+  }
+
+  private async runIterations<T>(
+    items: T[],
+    concurrencyLimit: number,
+    handler: (item: T, index: number) => Promise<void>,
+  ): Promise<void> {
+    if (concurrencyLimit === 1 || items.length <= 1) {
+      for (let index = 0; index < items.length; index++) {
+        await handler(items[index], index);
+      }
+      return;
+    }
+
+    const limit = concurrencyLimit === 0 ? items.length : concurrencyLimit;
+    let nextIndex = 0;
+
+    const workers = Array.from(
+      { length: Math.min(limit, items.length) },
+      async () => {
+        while (nextIndex < items.length) {
+          const index = nextIndex;
+          nextIndex += 1;
+          await handler(items[index], index);
+        }
+      },
+    );
+
+    await Promise.all(workers);
+  }
 }

package/src/services/workflow/nodes/if.node.ts

@@ -42,6 +42,13 @@ import {
         description: 'Nodes that run when the condition evaluates to false.',
         kind: 'sequence',
       },
+      {
+        key: 'errors',
+        label: 'Errors',
+        description: 'Nodes that run sequentially if the selected branch fails.',
+        kind: 'sequence',
+        layout: 'sequential',
+      },
     ],
     supportsDescription: true,
     supportsName: true,

package/src/services/workflow/nodes/log-write.node.ts

@@ -162,6 +162,7 @@ import {
         description: 'The resolved log level.',
         valueType: 'string',
         path: 'level',
+        includeInRuntimeContext: false,
       },
       {
         key: 'message',
@@ -169,6 +170,7 @@ import {
         description: 'The rendered log message.',
         valueType: 'string',
         path: 'message',
+        includeInRuntimeContext: false,
       },
     ],
     supportsExpressions: true,