@solidxai/core 0.1.12 → 0.1.13-beta.2

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

@@ -0,0 +1,93 @@
+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: 'if',
+  kind: 'control',
+  category: 'control-flow',
+  label: 'If',
+  description: 'Runs then or else child nodes based on a boolean expression.',
+  tags: ['branching', 'condition'],
+  authoring: {
+    defaultConfiguration: {
+      condition: '{{ input.shouldContinue === true }}',
+    },
+    configurationFields: [
+      {
+        key: 'condition',
+        label: 'Condition',
+        description: 'Boolean expression evaluated by the workflow expression engine.',
+        valueType: 'expression',
+        required: true,
+        expressionAllowed: true,
+        widgetHint: 'textarea',
+        group: 'General',
+      },
+    ],
+    childSlots: [
+      {
+        key: 'then',
+        label: 'Then',
+        description: 'Nodes that run when the condition evaluates to true.',
+        kind: 'sequence',
+        required: true,
+      },
+      {
+        key: 'else',
+        label: 'Else',
+        description: 'Nodes that run when the condition evaluates to false.',
+        kind: 'sequence',
+      },
+    ],
+    supportsDescription: true,
+    supportsName: true,
+  },
+  documentation: {
+    summary:
+      'Conditionally branches workflow execution into then or else node sequences. The node evaluates a boolean expression and executes either the then or else child sequence. Sequence order inside each branch remains implicit by array order.',
+  },
+  ui: {
+    icon: 'si-code',
+    iconColor: '#4f46e5',
+    iconBackgroundColor: '#eef2ff',
+    iconBorderColor: '#c7d2fe',
+    modalSize: 'lg',
+    layoutHints: {
+      groupOrder: ['General'],
+    },
+  },
+})
+export class IfNode implements WorkflowNodeHandler {
+  async execute(
+    context: WorkflowNodeExecutionContext,
+  ): Promise<WorkflowNodeHandlerResult> {
+    const condition =
+      context.node.configuration?.condition ??
+      context.node.configuration?.expression;
+    const matched = context.expression.evaluateCondition(condition, context);
+    const selectedNodes = matched
+      ? context.node.then ?? []
+      : context.node.else ?? [];
+
+    await context.emitLog({
+      level: 'info',
+      eventType: 'node.if.evaluated',
+      source: 'if',
+      message: `If node "${context.node.id}" evaluated to ${matched}.`,
+      context: { condition },
+    });
+
+    await context.runNodes(selectedNodes);
+
+    return {
+      output: {
+        matched,
+        branch: matched ? 'then' : 'else',
+      },
+    };
+  }
+}

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

@@ -0,0 +1,232 @@
+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: 'log.write',
+  kind: 'task',
+  version: '1.0.0',
+  category: 'core',
+  subcategory: 'observability',
+  label: 'Write Log',
+  description: 'Writes an execution log entry and returns the rendered message.',
+  tags: ['log', 'debug', 'observability'],
+  aliases: ['log'],
+  configSchema: {
+    type: 'object',
+    required: ['message'],
+    properties: {
+      level: {
+        type: 'string',
+        enum: ['debug', 'info', 'warn', 'error'],
+        default: 'info',
+      },
+      message: {
+        type: 'string',
+      },
+      context: {
+        type: 'object',
+        default: {},
+      },
+      metadata: {
+        type: 'object',
+        default: {},
+      },
+    },
+  },
+  uiSchema: {
+    'ui:order': ['level', 'message', 'context', 'metadata'],
+  },
+  outputSchema: {
+    type: 'object',
+    properties: {
+      level: { type: 'string' },
+      message: { type: 'string' },
+    },
+  },
+  examples: [
+    {
+      key: 'simple-message',
+      label: 'Simple log message',
+      description: 'Write a simple interpolated log line.',
+      language: 'yaml',
+      snippet:
+        'message: "Hello {{ input.name }}"\nlevel: info\n',
+      configurationOnly: true,
+    },
+  ],
+  metrics: [
+    {
+      key: 'workflow.node.log.count',
+      label: 'Log writes',
+      description: 'Counts how many times the log node executes.',
+      type: 'counter',
+      tags: ['log', 'workflow'],
+    },
+  ],
+  definitions: [
+    {
+      key: 'log-levels',
+      label: 'Supported log levels',
+      content:
+        'The node supports debug, info, warn, and error. The chosen level is stored alongside the log message.',
+    },
+  ],
+  authoring: {
+    defaultConfiguration: {
+      level: 'info',
+      context: {},
+      metadata: {},
+    },
+    configurationLayout: {
+      type: 'tabs',
+      tabs: [
+        {
+          key: 'message',
+          label: 'Message',
+          groups: ['Message'],
+        },
+        {
+          key: 'context',
+          label: 'Context',
+          fields: ['context'],
+        },
+        {
+          key: 'metadata',
+          label: 'Metadata',
+          fields: ['metadata'],
+        },
+      ],
+    },
+    configurationFields: [
+      {
+        key: 'level',
+        label: 'Level',
+        description: 'The severity used for the emitted workflow log entry.',
+        valueType: 'string',
+        defaultValue: 'info',
+        enumValues: ['debug', 'info', 'warn', 'error'],
+        group: 'Message',
+      },
+      {
+        key: 'message',
+        label: 'Message',
+        description: 'The text to log. Expressions are allowed.',
+        valueType: 'string',
+        required: true,
+        expressionAllowed: true,
+        group: 'Message',
+      },
+      {
+        key: 'context',
+        label: 'Context',
+        description: 'Optional structured context attached to the log entry.',
+        valueType: 'object',
+        expressionAllowed: true,
+        group: 'Advanced',
+        widgetHint: 'yaml-editor',
+        uiSchema: {
+          layout: {
+            width: 'full',
+          },
+          editor: {
+            height: 'min(420px, calc(90vh - 330px))',
+          },
+        },
+      },
+      {
+        key: 'metadata',
+        label: 'Metadata',
+        description: 'Optional metadata attached to the log entry.',
+        valueType: 'object',
+        expressionAllowed: true,
+        group: 'Advanced',
+        widgetHint: 'yaml-editor',
+        uiSchema: {
+          layout: {
+            width: 'full',
+          },
+          editor: {
+            height: 'min(420px, calc(90vh - 330px))',
+          },
+        },
+      },
+    ],
+    outputs: [
+      {
+        key: 'level',
+        label: 'Level',
+        description: 'The resolved log level.',
+        valueType: 'string',
+        path: 'level',
+      },
+      {
+        key: 'message',
+        label: 'Message',
+        description: 'The rendered log message.',
+        valueType: 'string',
+        path: 'message',
+      },
+    ],
+    supportsExpressions: true,
+    supportsDisableToggle: true,
+    supportsName: true,
+    supportsDescription: true,
+    searchableText: ['log', 'message', 'debug', 'observability'],
+  },
+  runtime: {
+    emitsLogs: true,
+    emitsArtifacts: false,
+    deterministicOutputs: true,
+    executionMode: 'task',
+    successStatuses: ['success'],
+  },
+  documentation: {
+    summary:
+      'Use this node for debug messages, execution breadcrumbs, and quick expression verification.',
+  },
+  ui: {
+    icon: 'si-file',
+    iconColor: '#0284c7',
+    iconBackgroundColor: '#e0f2fe',
+    iconBorderColor: '#bae6fd',
+    defaultEditorMode: 'schema',
+    modalSize: 'xl',
+    layoutHints: {
+      preferredPanel: 'flow',
+      groupOrder: ['Message', 'Advanced'],
+      stickySummary: true,
+    },
+  },
+})
+export class LogWriteNode implements WorkflowNodeHandler {
+  async execute(
+    context: WorkflowNodeExecutionContext,
+  ): Promise<WorkflowNodeHandlerResult> {
+    const configuration = context.expression.interpolate(
+      context.node.configuration ?? {},
+      context,
+    );
+    const level = configuration.level ?? 'info';
+    const message = configuration.message ?? context.node.name ?? context.node.id;
+
+    await context.emitLog({
+      level,
+      message,
+      eventType: 'node.log',
+      source: 'log.write',
+      context: configuration.context,
+      metadata: configuration.metadata,
+    });
+
+    return {
+      output: {
+        level,
+        message,
+      },
+    };
+  }
+}

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

@@ -0,0 +1,81 @@
+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: 'parallel',
+  kind: 'control',
+  category: 'control-flow',
+  label: 'Parallel',
+  description: 'Runs child tasks concurrently and returns task outputs.',
+  tags: ['parallel', 'concurrency'],
+  authoring: {
+    defaultConfiguration: {},
+    childSlots: [
+      {
+        key: 'tasks',
+        label: 'Tasks',
+        description: 'Child tasks that run concurrently.',
+        kind: 'sequence',
+        layout: 'parallel',
+        required: true,
+      },
+    ],
+    supportsDescription: true,
+    supportsName: true,
+  },
+  documentation: {
+    summary: 'Runs child tasks concurrently and returns their outputs.',
+  },
+  ui: {
+    icon: 'si-objects-column',
+    iconColor: '#2563eb',
+    iconBackgroundColor: '#dbeafe',
+    iconBorderColor: '#bfdbfe',
+    modalSize: 'lg',
+  },
+})
+export class ParallelNode implements WorkflowNodeHandler {
+  async execute(
+    context: WorkflowNodeExecutionContext,
+  ): Promise<WorkflowNodeHandlerResult> {
+    const childTasks = context.node.tasks ?? [];
+
+    const taskResults = await Promise.all(
+      childTasks.map(async (task) => {
+        const inheritedOutputs = context.outputs ?? {};
+        const inheritedOutputKeys = new Set(Object.keys(inheritedOutputs));
+        const outputs = { ...inheritedOutputs };
+
+        await context.runNodes([task], {
+          outputs,
+        });
+
+        const branchOutputs = Object.entries(outputs).reduce(
+          (acc, [key, value]) => {
+            if (!inheritedOutputKeys.has(key)) {
+              acc[key] = value;
+            }
+            return acc;
+          },
+          {} as Record<string, any>,
+        );
+
+        return {
+          id: task.id,
+          name: task.name,
+          outputs: branchOutputs,
+        };
+      }),
+    );
+
+    return {
+      output: {
+        tasks: taskResults,
+      },
+    };
+  }
+}