@gadmin2n/schematics 0.0.144 → 0.0.145

package/dist/lib/application/files/gadmin2-game-angle-demo/server/seed/workflow-node-types.ts

@@ -19,12 +19,15 @@ type NodeTypeSeed = BaseNodeTypeSeed & {
   instancePolicy: 'REQUIRED' | 'OPTIONAL' | 'INLINE_ONLY';
 };
 
-const inlineNode = (definition: BaseNodeTypeSeed): NodeTypeSeed => ({
+const templatableNode = (definition: BaseNodeTypeSeed): NodeTypeSeed => ({
   ...definition,
   runtimeKey: definition.type,
   schemaVersion: 1,
-  instancePolicy: 'INLINE_ONLY',
-  uiSchema: {},
+  instancePolicy: 'OPTIONAL',
+  uiSchema:
+    definition.type === 'manual_trigger'
+      ? { widget: 'manual-trigger-config' }
+      : {},
 });
 
 const PARAMETER_BINDING_SCHEMA = {
@@ -34,7 +37,7 @@ const PARAMETER_BINDING_SCHEMA = {
       properties: {
         source: {
           type: 'string',
-          enum: ['INPUT', 'WORKFLOW', 'SYSTEM'],
+          enum: ['INPUT', 'WORKFLOW'],
         },
         path: { type: 'string', minLength: 1 },
       },
@@ -57,36 +60,62 @@ const PARAMETER_BINDING_SCHEMA = {
   ],
 };
 
+const APPROVAL_PARAMETER_BINDING_SCHEMA = {
+  ...PARAMETER_BINDING_SCHEMA,
+  oneOf: [
+    {
+      ...PARAMETER_BINDING_SCHEMA.oneOf[0],
+      properties: {
+        ...PARAMETER_BINDING_SCHEMA.oneOf[0].properties,
+        source: {
+          type: 'string',
+          enum: ['INPUT', 'WORKFLOW', 'APPROVAL'],
+        },
+      },
+    },
+    PARAMETER_BINDING_SCHEMA.oneOf[1],
+  ],
+};
+
 const PARAMETER_BINDINGS_SCHEMA = {
   type: 'object',
   additionalProperties: PARAMETER_BINDING_SCHEMA,
 };
 
-const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
+const HTTP_PARAMETER_BINDINGS_SCHEMA = {
+  ...PARAMETER_BINDINGS_SCHEMA,
+  propertyNames: { minLength: 1, pattern: '\\S' },
+};
+
+const NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
   // ─── TRIGGER ───────────────────────────────────────────────────────────────
   {
     type: 'cron_trigger',
     category: 'TRIGGER',
-    label: 'Cron Trigger',
+    label: '定时触发',
     icon: 'ClockCircleOutlined',
-    description: 'Trigger workflow on a cron schedule',
+    description: '按照配置的时间计划自动启动 Workflow',
     configSchema: {
       type: 'object',
+      additionalProperties: false,
       properties: {
-        cron: {
-          type: 'string',
-          description: 'Cron expression (6-field with seconds supported)',
+        cronExpressions: {
+          type: 'array',
+          minItems: 1,
+          uniqueItems: true,
+          items: { type: 'string', minLength: 1 },
+          description: '一个或多个 Temporal Schedule Cron 表达式',
         },
         timezone: {
           type: 'string',
-          description: 'IANA timezone, e.g. Asia/Shanghai',
+          description: 'IANA 时区，例如 Asia/Shanghai',
         },
       },
-      required: ['cron'],
+      required: ['cronExpressions'],
     },
     inputSchema: { type: 'object', properties: {} },
     outputSchema: {
-      description: 'Workflow start data supplied by the schedule trigger',
+      description: '定时启动 Workflow 时提供的启动数据',
     },
     outputs: [],
   },
@@ -101,41 +130,27 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
       properties: {
         path: {
           type: 'string',
+          minLength: 1,
+          pattern: '^[A-Za-z0-9](?:[A-Za-z0-9_-]*[A-Za-z0-9])?$',
           description:
-            'Webhook endpoint path segment, e.g. "order-paid". Final URL: POST /api/workflow/webhook/{path}',
+            '外部调用路径，例如 order-paid；界面会显示最终可访问地址',
         },
         method: {
           type: 'string',
           enum: ['POST'],
           default: 'POST',
-          description: 'External requests use POST',
+          description: '外部请求统一使用 POST',
         },
         verificationMode: {
           type: 'string',
           enum: ['HMAC', 'NONE'],
           default: 'HMAC',
-          description:
-            'HMAC verifies signed callers. NONE directly accepts systems that cannot sign requests.',
+          description: 'HMAC 校验调用方签名；NONE 用于无法签名的可信系统',
         },
         secret: {
           type: 'string',
           description:
-            'HMAC-SHA256 secret. Caller must send X-Workflow-Signature: sha256=HEX(HMAC(secret, "{ts}.{rawBody}")) and X-Workflow-Timestamp.',
-        },
-        responseMode: {
-          type: 'string',
-          enum: ['IMMEDIATE', 'WAIT_FOR_RESULT'],
-          default: 'IMMEDIATE',
-          description:
-            'Immediately acknowledge the request or wait for a Return Result node.',
-        },
-        responseTimeoutSeconds: {
-          type: 'integer',
-          minimum: 1,
-          maximum: 300,
-          default: 60,
-          description:
-            'Maximum time to keep the HTTP request open in WAIT_FOR_RESULT mode.',
+            '用于 HMAC-SHA256 验签的密钥；调用方需传入 X-Workflow-Signature 和 X-Workflow-Timestamp',
         },
       },
       required: ['path', 'method'],
@@ -151,21 +166,24 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
           else: { required: ['secret'] },
         },
       ],
+      additionalProperties: false,
     },
     inputSchema: {
       type: 'object',
       properties: {
-        body: { type: 'object' },
+        body: { description: '请求体原始内容' },
         headers: { type: 'object' },
         query: { type: 'object' },
+        receivedAt: { type: 'string' },
       },
     },
     outputSchema: {
       type: 'object',
       properties: {
-        body: { type: 'object', description: 'Unmodified request body' },
-        headers: { type: 'object', description: 'Request headers' },
-        query: { type: 'object', description: 'Query parameters' },
+        body: { description: '请求体原始内容' },
+        headers: { type: 'object', description: '请求头' },
+        query: { type: 'object', description: 'URL 查询参数' },
+        receivedAt: { type: 'string', description: '收到请求的时间' },
       },
     },
     outputs: [],
@@ -173,52 +191,157 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
   {
     type: 'event_trigger',
     category: 'TRIGGER',
-    label: 'Event Trigger',
+    label: '业务事件触发',
     icon: 'ThunderboltOutlined',
-    description: '收到内部业务事件（Outbox）后启动 Workflow',
+    description: '业务数据发生变化后自动启动 Workflow',
     configSchema: {
       type: 'object',
       properties: {
-        eventName: {
+        registrationCode: {
+          type: 'string',
+          minLength: 1,
+          description: '前端登记的 PostgreSQL 表字段监听标识',
+        },
+        match: {
+          type: 'object',
+          properties: {
+            combineOperation: {
+              type: 'string',
+              enum: ['AND', 'OR'],
+            },
+            conditions: {
+              type: 'array',
+              minItems: 1,
+              items: {
+                type: 'object',
+                properties: {
+                  id: { type: 'string', minLength: 1 },
+                  left: {
+                    type: 'object',
+                    properties: {
+                      source: { const: 'WORKFLOW' },
+                      path: { type: 'string', minLength: 1 },
+                    },
+                    required: ['source', 'path'],
+                    additionalProperties: false,
+                  },
+                  operator: {
+                    type: 'string',
+                    enum: ['EQ', 'NEQ', 'EMPTY', 'NOT_EMPTY'],
+                  },
+                  right: {
+                    type: 'object',
+                    properties: {
+                      source: { const: 'FIXED' },
+                      valueType: {
+                        type: 'string',
+                        enum: ['STRING', 'NUMBER', 'BOOLEAN'],
+                      },
+                      value: { type: 'string' },
+                    },
+                    required: ['source', 'valueType', 'value'],
+                    additionalProperties: false,
+                  },
+                },
+                required: ['id', 'left', 'operator'],
+                allOf: [
+                  {
+                    if: {
+                      properties: {
+                        operator: { enum: ['EQ', 'NEQ'] },
+                      },
+                      required: ['operator'],
+                    },
+                    then: { required: ['right'] },
+                  },
+                ],
+                additionalProperties: false,
+              },
+            },
+          },
+          required: ['combineOperation', 'conditions'],
+          additionalProperties: false,
+        },
+        processingMode: {
           type: 'string',
-          description: 'Internal event/signal name to listen for',
+          enum: ['PARALLEL', 'SERIAL_BY_KEY'],
+          default: 'PARALLEL',
+          description: '事件的并发处理方式',
         },
-        filterExpression: {
+        concurrencyKeyPath: {
           type: 'string',
-          description: 'Optional expression to filter events',
+          minLength: 1,
+          description: '需要保持顺序的业务对象字段',
+        },
+        maxConcurrency: {
+          type: 'integer',
+          minimum: 1,
+          maximum: 100,
+          default: 20,
+          description: '顺序调度器最多同时处理的业务对象数量',
         },
       },
-      required: ['eventName'],
-    },
-    inputSchema: {
-      type: 'object',
-      properties: { payload: { type: 'object' } },
+      required: ['registrationCode', 'processingMode'],
+      allOf: [
+        {
+          if: {
+            properties: { processingMode: { const: 'SERIAL_BY_KEY' } },
+            required: ['processingMode'],
+          },
+          then: {
+            required: ['concurrencyKeyPath', 'maxConcurrency'],
+          },
+        },
+      ],
+      additionalProperties: false,
     },
+    inputSchema: { description: 'PostgreSQL 行变化的标准 before/after 数据' },
     outputSchema: {
       type: 'object',
-      properties: { payload: { type: 'object' } },
+      properties: {
+        operation: { type: 'string', enum: ['INSERT', 'UPDATE', 'DELETE'] },
+        table: {
+          type: 'object',
+          properties: {
+            schema: { type: 'string' },
+            name: { type: 'string' },
+          },
+        },
+        primaryKey: { type: 'object' },
+        before: { type: ['object', 'null'] },
+        after: { type: ['object', 'null'] },
+        changedFields: { type: 'array', items: { type: 'string' } },
+      },
+      required: [
+        'operation',
+        'table',
+        'primaryKey',
+        'before',
+        'after',
+        'changedFields',
+      ],
     },
     outputs: [],
   },
   {
     type: 'manual_trigger',
     category: 'TRIGGER',
-    label: 'Manual Trigger',
+    label: '手动触发',
     icon: 'PlayCircleOutlined',
-    description: 'Trigger workflow manually for testing or one-time execution',
+    description: '由用户手动启动 Workflow，适合测试或一次性执行',
     configSchema: {
       type: 'object',
       properties: {
         inputSchema: {
           type: 'object',
-          description: 'JSON Schema defining expected manual input',
+          description: '手动运行时需要填写的启动参数',
         },
       },
       required: [],
     },
-    inputSchema: { type: 'object', properties: { data: { type: 'object' } } },
+    inputSchema: { description: '手动触发节点没有上一个节点输入' },
     outputSchema: {
-      description: 'Workflow start data supplied for the manual run',
+      description: '用户手动启动时提供的数据',
     },
     outputs: [],
   },
@@ -227,20 +350,20 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
   {
     type: 'http_request',
     category: 'ACTION',
-    label: 'HTTP Request',
+    label: 'HTTP 请求',
     icon: 'GlobalOutlined',
-    description: 'Call an external API through a reusable Connection',
+    description: '通过已注册的连接调用外部 HTTP 接口',
     configSchema: {
       type: 'object',
       properties: {
         connectionRef: {
           type: 'string',
-          description: 'Immutable code of a reusable Connection',
+          description: '要使用的连接编码',
         },
         method: {
           type: 'string',
           enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD'],
-          description: 'HTTP method',
+          description: 'HTTP 请求方法',
         },
         path: {
           type: 'string',
@@ -248,39 +371,32 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
             'Relative API path. Supports explicit {{input.path}} and {{workflow.path}} references.',
         },
         queryBindings: {
-          ...PARAMETER_BINDINGS_SCHEMA,
-          description: 'Direct value sources for query parameters',
+          ...HTTP_PARAMETER_BINDINGS_SCHEMA,
+          description: 'URL 查询参数及其取值来源',
         },
         headerBindings: {
-          ...PARAMETER_BINDINGS_SCHEMA,
-          description: 'Direct value sources for request headers',
+          ...HTTP_PARAMETER_BINDINGS_SCHEMA,
+          description: '请求头及其取值来源',
         },
         bodyMode: {
           type: 'string',
           enum: ['FIELDS', 'JSON'],
-          description: 'Request body editing mode',
+          description: '请求体编辑方式',
         },
         bodyBindings: {
-          ...PARAMETER_BINDINGS_SCHEMA,
-          description: 'Direct value sources for request body fields',
+          ...HTTP_PARAMETER_BINDINGS_SCHEMA,
+          description: '请求体字段及其取值来源',
         },
         body: {
           description:
-            'Advanced JSON body with explicit {{input.path}}, {{workflow.path}}, and {{system.path}} references',
+            '高级 JSON 请求体，可明确引用上一个节点结果或 Workflow 启动数据',
         },
         timeoutSeconds: {
           type: 'integer',
           minimum: 1,
           maximum: 300,
-          description: 'Request timeout in seconds',
-        },
-        retryOnFail: { type: 'boolean', description: 'Retry on failure' },
-        maxRetries: { type: 'integer', minimum: 0, maximum: 10 },
-        retryInterval: {
-          type: 'integer',
-          minimum: 0,
-          maximum: 60000,
-          description: 'Interval between retries in milliseconds',
+          default: 30,
+          description: '请求超时时间（秒）',
         },
       },
       required: ['connectionRef', 'method', 'path', 'bodyMode'],
@@ -291,89 +407,51 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
       type: 'object',
       properties: {
         status: { type: 'number' },
-        data: { description: 'Unmodified response body' },
+        data: { description: '响应体原始内容' },
         headers: { type: 'object' },
       },
     },
     outputs: [],
   },
-  {
-    type: 'db_query',
-    category: 'ACTION',
-    label: 'Database Query',
-    icon: 'DatabaseOutlined',
-    description: 'Execute a database read query (SELECT)',
-    configSchema: {
-      type: 'object',
-      properties: {
-        query: { type: 'string', description: 'SQL statement' },
-        params: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Parameterized values ($1, $2...)',
-        },
-        datasource: {
-          type: 'string',
-          description: 'Database connection identifier',
-        },
-        timeout: {
-          type: 'number',
-          description: 'Query timeout in milliseconds',
-        },
-      },
-      required: ['query'],
-    },
-    inputSchema: { type: 'object', properties: {} },
-    outputSchema: {
-      type: 'object',
-      properties: { rows: { type: 'array' }, rowCount: { type: 'number' } },
-    },
-    outputs: [],
-  },
   {
     type: 'db_execute',
     category: 'ACTION',
-    label: 'Database Execute',
+    label: '数据库操作',
     icon: 'ConsoleSqlOutlined',
-    description: 'Execute a database write operation (INSERT/UPDATE/DELETE)',
+    description: '使用 SQL 查询或修改当前服务注册的数据库',
     configSchema: {
       type: 'object',
       properties: {
-        operation: {
-          type: 'string',
-          enum: ['insert', 'update', 'delete', 'raw'],
-          description: 'Write operation type',
+        allowWrite: {
+          type: 'boolean',
+          description: '是否允许新增、更新或删除数据',
         },
-        table: { type: 'string', description: 'Target table name' },
-        data: { type: 'object', description: 'Data to insert/update (JSON)' },
-        where: {
+        sql: {
           type: 'string',
-          description: 'WHERE condition for update/delete',
+          minLength: 1,
+          description: '要执行的单条 SQL',
         },
-        rawSql: {
-          type: 'string',
-          description: 'Raw SQL for complex writes (when operation=raw)',
-        },
-        params: {
+        parameters: {
           type: 'array',
-          items: { type: 'string' },
-          description: 'Parameterized values',
-        },
-        datasource: {
-          type: 'string',
-          description: 'Database connection identifier',
+          items: PARAMETER_BINDING_SCHEMA,
+          description: 'SQL 中参数占位符对应的值',
         },
-        timeout: {
-          type: 'number',
-          description: 'Execution timeout in milliseconds',
+        timeoutSeconds: {
+          type: 'integer',
+          minimum: 1,
+          maximum: 300,
+          description: '执行超时时间（秒）',
         },
       },
-      required: ['operation'],
+      required: ['allowWrite', 'sql'],
+      additionalProperties: false,
     },
-    inputSchema: { type: 'object', properties: { data: { type: 'object' } } },
+    inputSchema: { description: '上一个节点的完整结果' },
     outputSchema: {
       type: 'object',
       properties: {
+        rows: { type: 'array' },
+        rowCount: { type: 'number' },
         affectedRows: { type: 'number' },
         insertedId: { type: 'string' },
       },
@@ -383,32 +461,32 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
   {
     type: 'code',
     category: 'ACTION',
-    label: 'Code',
+    label: '代码处理',
     icon: 'CodeOutlined',
-    description: 'Execute custom JavaScript code for data transformation',
+    description: '使用 JavaScript 处理或转换上一个节点的结果',
     configSchema: {
       type: 'object',
       properties: {
-        script: { type: 'string', description: 'JavaScript code to execute' },
+        script: { type: 'string', description: '要执行的 JavaScript 代码' },
         mode: {
           type: 'string',
-          enum: ['runOnceForAll', 'runOnceForEach'],
-          description: 'Execution mode: run once for all items or per item',
+          enum: ['runOnceForAll'],
+          default: 'runOnceForAll',
+          description: '对完整输入执行一次',
         },
         timeout: {
-          type: 'number',
-          description: 'Script execution timeout (ms)',
+          type: 'integer',
+          minimum: 1,
+          maximum: 5000,
+          default: 5000,
+          description: '代码执行超时时间（毫秒）',
         },
       },
       required: ['script'],
     },
-    inputSchema: {
-      type: 'object',
-      properties: { data: { type: 'object' }, items: { type: 'array' } },
-    },
+    inputSchema: { description: '上一个节点的完整结果' },
     outputSchema: {
-      type: 'object',
-      properties: { result: { type: 'object' } },
+      description: '代码中 return 的完整结果',
     },
     outputs: [],
   },
@@ -417,71 +495,105 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
   {
     type: 'if_else',
     category: 'CONDITION',
-    label: 'If/Else',
+    label: '条件分支',
     icon: 'BranchesOutlined',
-    description: 'Branch workflow based on a condition',
+    description: '根据一个或多个条件选择满足或不满足分支',
     configSchema: {
       type: 'object',
       properties: {
         conditions: {
           type: 'array',
+          minItems: 1,
           items: {
             type: 'object',
             properties: {
-              field: { type: 'string' },
-              operator: { type: 'string' },
-              value: { type: 'string' },
+              id: { type: 'string', minLength: 1 },
+              left: PARAMETER_BINDING_SCHEMA,
+              operator: {
+                type: 'string',
+                enum: [
+                  'EQ',
+                  'NEQ',
+                  'GT',
+                  'GTE',
+                  'LT',
+                  'LTE',
+                  'CONTAINS',
+                  'NOT_CONTAINS',
+                  'EMPTY',
+                  'NOT_EMPTY',
+                ],
+              },
+              right: PARAMETER_BINDING_SCHEMA,
             },
+            required: ['id', 'left', 'operator'],
+            allOf: [
+              {
+                if: {
+                  properties: {
+                    operator: { enum: ['EMPTY', 'NOT_EMPTY'] },
+                  },
+                  required: ['operator'],
+                },
+                then: {},
+                else: { required: ['right'] },
+              },
+            ],
+            additionalProperties: false,
           },
-          description: 'Condition rules (field + operator + value)',
+          description: '使用结构化数据来源配置的判断条件',
         },
         combineOperation: {
           type: 'string',
           enum: ['AND', 'OR'],
-          description: 'How to combine multiple conditions',
+          description: '多个条件之间使用并且或或者',
         },
       },
-      required: [],
+      required: ['conditions', 'combineOperation'],
+      additionalProperties: false,
     },
-    inputSchema: { type: 'object', properties: { data: { type: 'object' } } },
+    inputSchema: { description: '上一个节点的完整结果' },
     outputSchema: {
-      type: 'object',
-      properties: { branch: { type: 'string', enum: ['true', 'false'] } },
+      description: '原样传递上一个节点的完整结果',
     },
     outputs: ['true', 'false'],
   },
   {
     type: 'switch',
     category: 'CONDITION',
-    label: 'Switch',
+    label: '多路分支',
     icon: 'PartitionOutlined',
-    description: 'Multi-way branch based on a field value',
+    description: '根据一个字段值匹配多个分支，未匹配时进入其他情况',
     configSchema: {
       type: 'object',
       properties: {
-        field: { type: 'string', description: 'Field to evaluate' },
+        valueBinding: PARAMETER_BINDING_SCHEMA,
         cases: {
           type: 'array',
+          minItems: 1,
           items: {
             type: 'object',
             properties: {
+              id: { type: 'string', minLength: 1, not: { const: 'default' } },
               value: { type: 'string' },
-              label: { type: 'string' },
+              valueType: {
+                type: 'string',
+                enum: ['STRING', 'NUMBER', 'BOOLEAN'],
+              },
+              label: { type: 'string', minLength: 1 },
             },
+            required: ['id', 'value', 'valueType', 'label'],
+            additionalProperties: false,
           },
-          description: 'Case branches (value → output handle)',
-        },
-        defaultCase: {
-          type: 'string',
-          description: 'Default branch label when no case matches',
+          description: '多路匹配项；稳定标识用于保持画布连线',
         },
       },
-      required: ['field', 'cases'],
+      required: ['valueBinding', 'cases'],
+      additionalProperties: false,
     },
-    inputSchema: { type: 'object', properties: { data: { type: 'object' } } },
+    inputSchema: { description: '上一个节点的完整结果' },
     outputSchema: {
-      type: 'object',
-      properties: { matchedCase: { type: 'string' } },
+      description: '原样传递上一个节点的完整结果',
     },
     outputs: null,
   },
@@ -490,38 +602,84 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
   {
     type: 'for_each',
     category: 'FLOW_CONTROL',
-    label: 'For Each',
+    label: '循环处理',
     icon: 'RetweetOutlined',
-    description: 'Iterate over an array field',
+    description: '逐项处理数组数据，并在全部完成后继续流程',
     configSchema: {
       type: 'object',
       properties: {
-        iteratorField: {
-          type: 'string',
-          description: 'Path to the array field to iterate',
-        },
-        concurrency: {
-          type: 'number',
-          description: 'Parallel concurrency (1 = sequential)',
+        itemsBinding: PARAMETER_BINDING_SCHEMA,
+        execution: {
+          type: 'object',
+          properties: {
+            mode: {
+              type: 'string',
+              enum: ['SEQUENTIAL', 'PARALLEL'],
+              default: 'SEQUENTIAL',
+            },
+            concurrency: {
+              type: 'integer',
+              minimum: 2,
+              maximum: 20,
+              default: 3,
+            },
+          },
+          required: ['mode'],
+          allOf: [
+            {
+              if: {
+                properties: { mode: { const: 'PARALLEL' } },
+                required: ['mode'],
+              },
+              then: { required: ['concurrency'] },
+            },
+            {
+              if: {
+                properties: { mode: { const: 'SEQUENTIAL' } },
+                required: ['mode'],
+              },
+              then: { not: { required: ['concurrency'] } },
+            },
+          ],
+          additionalProperties: false,
         },
         errorPolicy: {
           type: 'string',
-          enum: ['stop', 'continue', 'collect'],
-          description:
-            'Behavior on item failure: stop all, continue, or collect errors',
+          enum: ['STOP', 'CONTINUE'],
+          default: 'STOP',
         },
       },
-      required: ['iteratorField'],
+      required: ['itemsBinding', 'execution', 'errorPolicy'],
+      additionalProperties: false,
     },
-    inputSchema: { type: 'object', properties: { items: { type: 'array' } } },
+    inputSchema: { description: '包含待循环数组的上一个节点结果' },
     outputSchema: {
       type: 'object',
       properties: {
-        results: { type: 'array' },
-        errors: { type: 'array' },
-        totalProcessed: { type: 'number' },
-        error: { type: 'string' },
+        results: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              index: { type: 'number' },
+              status: {
+                type: 'string',
+                enum: ['SUCCEEDED', 'FAILED'],
+              },
+              output: {},
+              error: {
+                type: 'object',
+                properties: { message: { type: 'string' } },
+              },
+            },
+            required: ['index', 'status'],
+          },
+        },
+        total: { type: 'number' },
+        succeeded: { type: 'number' },
+        failed: { type: 'number' },
       },
+      required: ['results', 'total', 'succeeded', 'failed'],
     },
     outputs: [],
   },
@@ -530,69 +688,89 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
     category: 'FLOW_CONTROL',
     label: '定时等待',
     icon: 'HourglassOutlined',
-    description:
-      'Pause workflow execution for a specified duration (Temporal Timer)',
+    description: '等待一段时间或等待到指定时间后继续执行',
     configSchema: {
       type: 'object',
       properties: {
-        delayType: {
+        mode: {
           type: 'string',
-          enum: ['fixedDuration', 'untilTime'],
-          description: 'Type of delay',
+          enum: ['DURATION', 'UNTIL'],
+          description: '等待一段时间或等待到指定时间',
         },
         duration: {
-          type: 'number',
-          description: 'Delay duration in seconds (for fixedDuration)',
+          type: 'object',
+          properties: {
+            value: { type: 'integer', minimum: 1 },
+            unit: {
+              type: 'string',
+              enum: ['SECONDS', 'MINUTES', 'HOURS', 'DAYS'],
+            },
+          },
+          required: ['value', 'unit'],
+          additionalProperties: false,
         },
         untilTime: {
           type: 'string',
-          description: 'Resume at ISO datetime (for untilTime)',
+          format: 'date-time',
+          description: '恢复执行的时间',
         },
       },
-      required: ['delayType'],
+      required: ['mode'],
+      allOf: [
+        {
+          if: { properties: { mode: { const: 'DURATION' } } },
+          then: { required: ['duration'] },
+        },
+        {
+          if: { properties: { mode: { const: 'UNTIL' } } },
+          then: { required: ['untilTime'] },
+        },
+      ],
+      additionalProperties: false,
     },
-    inputSchema: { type: 'object', properties: {} },
+    inputSchema: { description: '上一个节点的完整结果' },
     outputSchema: {
-      type: 'object',
-      properties: {
-        resumedAt: { type: 'string' },
-        resumeReason: { type: 'string' },
-      },
+      description: '原样传递上一个节点的完整结果',
     },
     outputs: [],
   },
   {
     type: 'parallel',
     category: 'FLOW_CONTROL',
-    label: 'Parallel',
+    label: '并行执行',
     icon: 'ForkOutlined',
-    description:
-      'Execute multiple branches in parallel and wait for all to complete',
+    description: '同时执行画布连接的多个分支',
     configSchema: {
       type: 'object',
       properties: {
         branches: {
           type: 'array',
+          minItems: 2,
           items: {
             type: 'object',
             properties: {
-              label: { type: 'string' },
+              id: { type: 'string', minLength: 1 },
+              label: { type: 'string', minLength: 1 },
             },
+            required: ['id', 'label'],
+            additionalProperties: false,
           },
-          description: 'Named parallel branches',
-        },
-        waitMode: {
-          type: 'string',
-          enum: ['all', 'any'],
-          description: 'Wait for all branches or any one branch to complete',
         },
       },
       required: ['branches'],
+      additionalProperties: false,
     },
-    inputSchema: { type: 'object', properties: { data: { type: 'object' } } },
+    inputSchema: { description: '上一个节点的完整结果' },
     outputSchema: {
       type: 'object',
-      properties: { completedBranches: { type: 'number' } },
+      properties: {
+        branch: {
+          type: 'array',
+          description: '按分支配置顺序汇总的最终结果，数组索引从 0 开始',
+          items: {},
+        },
+      },
+      required: ['branch'],
     },
     outputs: [],
   },
@@ -602,9 +780,9 @@ const INLINE_NODE_DEFINITIONS: BaseNodeTypeSeed[] = [
 const approvalDefinition: BaseNodeTypeSeed = {
   type: 'approval',
   category: 'APPROVAL',
-  label: 'Human Approval',
+  label: '人工审批',
   icon: 'CheckCircleOutlined',
-  description: 'Pause workflow and wait for human approval (Temporal Signal)',
+  description: '创建审批请求并等待审批人通过、拒绝或超时',
   configSchema: {
     type: 'object',
     properties: {
@@ -618,54 +796,61 @@ const approvalDefinition: BaseNodeTypeSeed = {
           },
           required: ['type', 'id'],
         },
-        description:
-          'Approvers — mix of individual users (type=user, id=userid) and reusable groups (type=group, id=UserGroup.code)',
+        description: '可以处理本次审批的用户或可复用用户组',
       },
       approvalMode: {
         type: 'string',
         enum: ['any', 'all', 'percentage'],
-        description: 'any = one approver, all = unanimous, percentage = quorum',
+        description: '任意一人、全部通过或达到指定比例',
       },
       minApprovalCount: {
         type: 'number',
-        description: 'Minimum approvals needed (for percentage mode)',
+        description: '达到通过条件所需的最少人数',
       },
-      timeout: { type: 'number', description: 'Approval timeout in seconds' },
+      timeout: { type: 'number', description: '审批超时时间（秒）' },
       timeoutAction: {
         type: 'string',
         enum: ['auto_approve', 'auto_reject', 'escalate'],
-        description: 'Action when approval times out',
+        description: '审批超时后的处理动作',
       },
       escalateTo: {
         type: 'array',
         items: { type: 'string' },
-        description: 'Escalation targets (when timeoutAction=escalate)',
+        description: '审批超时后的升级处理人',
       },
       reminderInterval: {
         type: 'number',
-        description: 'Reminder interval in hours (0 = no reminder)',
+        description: '提醒间隔（小时），0 表示不提醒',
       },
       allowDelegate: {
         type: 'boolean',
-        description: 'Allow approvers to delegate to others',
+        description: '是否允许审批人转交给其他人',
       },
     },
     required: ['approvers'],
   },
-  inputSchema: {
-    type: 'object',
-    properties: { requestData: { type: 'object' } },
-  },
+  inputSchema: { description: '上一个节点的完整结果' },
   outputSchema: {
     type: 'object',
     properties: {
-      requestId: { type: 'string' },
-      nodeId: { type: 'string' },
-      result: { type: 'string', enum: ['APPROVED', 'REJECTED'] },
-      reason: { type: 'string' },
-      decidedAt: { type: 'string' },
-      approved: { type: 'boolean' },
+      previous: {
+        description: '进入人工审批前收到的完整数据',
+      },
+      result: {
+        type: 'object',
+        properties: {
+          requestId: { type: 'string' },
+          result: {
+            type: 'string',
+            enum: ['APPROVED', 'REJECTED'],
+          },
+          reason: { type: 'string' },
+          decidedAt: { type: 'string' },
+          approved: { type: 'boolean' },
+        },
+      },
     },
+    required: ['previous', 'result'],
   },
   outputs: [],
 };
@@ -682,63 +867,136 @@ const subWorkflowDefinition: BaseNodeTypeSeed = {
     properties: {
       workflowId: {
         type: 'string',
-        description: 'Target workflow ID to invoke',
+        description: '要调用的 Workflow ID',
+      },
+      workflowVersionId: {
+        type: 'string',
+        description: '要调用的 Workflow 版本 ID',
       },
       inputBindings: {
         ...PARAMETER_BINDINGS_SCHEMA,
-        description:
-          'Bind child inputs to the previous node, Workflow data, or fixed values',
+        description: '从上一个节点的结果、Workflow 启动数据或固定值传入参数',
       },
     },
-    required: ['workflowId'],
+    required: ['workflowId', 'workflowVersionId'],
+    additionalProperties: false,
   },
-  inputSchema: { type: 'object', properties: { data: { type: 'object' } } },
+  inputSchema: { description: '上一个节点的完整结果' },
   outputSchema: {
-    description: 'Unmodified result returned by the called Workflow',
+    description: '被调用 Workflow 返回的完整结果',
   },
   outputs: [],
 };
 
-const HUMAN_APPROVAL_CONFIG_SCHEMA: NodeTypeSeed['configSchema'] = {
+const HTTP_REQUEST_CONFIG_SCHEMA = NODE_DEFINITIONS.find(
+  (definition) => definition.type === 'http_request',
+)!.configSchema as any;
+
+const APPROVAL_HTTP_REQUEST_CONFIG_SCHEMA = {
+  ...HTTP_REQUEST_CONFIG_SCHEMA,
+  properties: {
+    ...HTTP_REQUEST_CONFIG_SCHEMA.properties,
+    queryBindings: {
+      ...HTTP_REQUEST_CONFIG_SCHEMA.properties.queryBindings,
+      additionalProperties: APPROVAL_PARAMETER_BINDING_SCHEMA,
+    },
+    headerBindings: {
+      ...HTTP_REQUEST_CONFIG_SCHEMA.properties.headerBindings,
+      additionalProperties: APPROVAL_PARAMETER_BINDING_SCHEMA,
+    },
+    bodyBindings: {
+      ...HTTP_REQUEST_CONFIG_SCHEMA.properties.bodyBindings,
+      additionalProperties: APPROVAL_PARAMETER_BINDING_SCHEMA,
+    },
+  },
+};
+
+const EMBEDDED_CODE_CONFIG_SCHEMA = {
   type: 'object',
   properties: {
-    approvalWorkflowId: {
+    script: { type: 'string', minLength: 1 },
+    mode: {
       type: 'string',
-      title: 'Approval Workflow',
-      description:
-        'Optional callable Workflow that dispatches the request, waits for the external result, and returns the decision.',
+      enum: ['runOnceForAll'],
+      default: 'runOnceForAll',
     },
-    approvalWorkflowInputBindings: {
-      ...PARAMETER_BINDINGS_SCHEMA,
-      title: 'Approval document fields',
-      description:
-        'Bind the selected approval Workflow inputs to input, Workflow data, or fixed values.',
+    timeout: {
+      type: 'integer',
+      minimum: 1,
+      maximum: 5000,
+      default: 5000,
     },
-    approverSources: {
-      type: 'array',
-      title: '自动找审批人',
-      items: {
-        type: 'object',
-        properties: {
-          workflowId: { type: 'string' },
-          inputBindings: PARAMETER_BINDINGS_SCHEMA,
+  },
+  required: ['script'],
+  additionalProperties: false,
+};
+
+const HUMAN_APPROVAL_CONFIG_SCHEMA: NodeTypeSeed['configSchema'] = {
+  type: 'object',
+  properties: {
+    external: {
+      type: 'object',
+      title: '外部审批',
+      properties: {
+        request: APPROVAL_HTTP_REQUEST_CONFIG_SCHEMA,
+        creationResult: EMBEDDED_CODE_CONFIG_SCHEMA,
+        callbackResult: EMBEDDED_CODE_CONFIG_SCHEMA,
+      },
+      required: ['request', 'creationResult', 'callbackResult'],
+      additionalProperties: false,
+    },
+    task: {
+      type: 'object',
+      title: '审批任务',
+      properties: {
+        title: PARAMETER_BINDING_SCHEMA,
+        description: PARAMETER_BINDING_SCHEMA,
+        details: {
+          type: 'array',
+          default: [],
+          items: {
+            type: 'object',
+            properties: {
+              key: { type: 'string', minLength: 1 },
+              label: { type: 'string', minLength: 1 },
+              value: PARAMETER_BINDING_SCHEMA,
+            },
+            required: ['key', 'label', 'value'],
+            additionalProperties: false,
+          },
         },
-        required: ['workflowId', 'inputBindings'],
       },
+      required: ['title', 'description', 'details'],
+      additionalProperties: false,
     },
     subjects: {
       type: 'array',
-      title: 'Approvers',
-      description: 'Users and reusable groups that may decide this request.',
-      minItems: 0,
+      title: '审批人',
+      description: '可以处理本次审批的用户和可复用用户组',
+      minItems: 1,
+      default: [],
       'x-gadmin-capability': 'subject-references',
       items: {
         type: 'object',
         properties: {
           source: { type: 'string', enum: ['STATIC', 'DYNAMIC'] },
           provider: { type: 'string', enum: ['USER', 'USER_GROUP'] },
-          refs: { type: 'array', items: { type: 'string' } },
-          inputKey: { type: 'string' },
+          refs: {
+            type: 'array',
+            minItems: 1,
+            items: { type: 'string', minLength: 1 },
+          },
+          inputKey: { type: 'string', minLength: 1 },
+          label: { type: 'string', minLength: 1 },
+          lookup: {
+            type: 'object',
+            properties: {
+              request: HTTP_REQUEST_CONFIG_SCHEMA,
+              result: EMBEDDED_CODE_CONFIG_SCHEMA,
+            },
+            required: ['request', 'result'],
+            additionalProperties: false,
+          },
         },
         required: ['source', 'provider'],
         allOf: [
@@ -748,36 +1006,64 @@ const HUMAN_APPROVAL_CONFIG_SCHEMA: NodeTypeSeed['configSchema'] = {
           },
           {
             if: { properties: { source: { const: 'DYNAMIC' } } },
-            then: { required: ['inputKey'] },
+            then: { required: ['inputKey', 'label', 'lookup'] },
           },
         ],
+        additionalProperties: false,
       },
     },
     approvalRule: {
       type: 'object',
-      title: 'Approval rule',
+      title: '通过规则',
       properties: {
         mode: { type: 'string', enum: ['ANY', 'ALL', 'COUNT', 'PERCENTAGE'] },
         count: { type: 'integer', minimum: 1 },
         percentage: { type: 'integer', minimum: 1, maximum: 100 },
       },
       required: ['mode'],
+      allOf: [
+        {
+          if: { properties: { mode: { const: 'COUNT' } } },
+          then: { required: ['count'] },
+        },
+        {
+          if: { properties: { mode: { const: 'PERCENTAGE' } } },
+          then: { required: ['percentage'] },
+        },
+      ],
+      additionalProperties: false,
       default: { mode: 'ANY' },
     },
     rejectionRule: {
       type: 'object',
-      title: 'Rejection rule',
+      title: '拒绝规则',
       properties: {
         mode: { type: 'string', enum: ['ANY', 'ALL', 'COUNT', 'PERCENTAGE'] },
         count: { type: 'integer', minimum: 1 },
         percentage: { type: 'integer', minimum: 1, maximum: 100 },
       },
       required: ['mode'],
+      allOf: [
+        {
+          if: { properties: { mode: { const: 'COUNT' } } },
+          then: { required: ['count'] },
+        },
+        {
+          if: { properties: { mode: { const: 'PERCENTAGE' } } },
+          then: { required: ['percentage'] },
+        },
+      ],
+      additionalProperties: false,
       default: { mode: 'ANY' },
     },
+    blockCancellationOnResolved: {
+      type: 'boolean',
+      title: '审批完成后禁止取消',
+      default: false,
+    },
     timeout: {
       type: 'object',
-      title: 'Timeout',
+      title: '审批超时',
       properties: {
         durationSeconds: {
           type: 'integer',
@@ -794,7 +1080,8 @@ const HUMAN_APPROVAL_CONFIG_SCHEMA: NodeTypeSeed['configSchema'] = {
       default: { durationSeconds: 0, action: 'REJECTED' },
     },
   },
-  required: ['subjects', 'approvalRule', 'rejectionRule', 'timeout'],
+  required: ['task', 'subjects', 'approvalRule', 'rejectionRule', 'timeout'],
+  additionalProperties: false,
 };
 
 const HUMAN_APPROVAL_UI_SCHEMA: NodeTypeSeed['uiSchema'] = {
@@ -806,14 +1093,14 @@ const humanApprovalNode: NodeTypeSeed = {
   configSchema: HUMAN_APPROVAL_CONFIG_SCHEMA,
   outputs: ['true', 'false'],
   runtimeKey: 'human_approval',
-  schemaVersion: 7,
-  instancePolicy: 'REQUIRED',
+  schemaVersion: 20,
+  instancePolicy: 'OPTIONAL',
   uiSchema: HUMAN_APPROVAL_UI_SCHEMA,
 };
 
 const callableTriggerNode: NodeTypeSeed = {
   type: 'callable_trigger',
-  category: 'SUB_WORKFLOW',
+  category: 'TRIGGER',
   label: '接收内部调用',
   icon: 'ImportOutlined',
   description: '接收其他地方传入的 Workflow 启动数据',
@@ -837,12 +1124,12 @@ const callableTriggerNode: NodeTypeSeed = {
   },
   inputSchema: { type: 'object' },
   outputSchema: {
-    description: 'Workflow start data supplied by the caller',
+    description: '调用方传入的 Workflow 启动数据',
   },
   outputs: [],
   runtimeKey: 'callable_trigger',
   schemaVersion: 2,
-  instancePolicy: 'INLINE_ONLY',
+  instancePolicy: 'OPTIONAL',
   uiSchema: {
     fields: {
       inputParameters: { widget: 'callable-input-parameters' },
@@ -850,26 +1137,6 @@ const callableTriggerNode: NodeTypeSeed = {
   },
 };
 
-const returnResultNode: NodeTypeSeed = {
-  type: 'return_result',
-  category: 'SUB_WORKFLOW',
-  label: '返回调用',
-  icon: 'ExportOutlined',
-  description: '结束当前 Workflow，并把上一个节点的结果返回给调用方',
-  configSchema: {
-    type: 'object',
-    properties: {},
-    additionalProperties: false,
-  },
-  inputSchema: { type: 'object' },
-  outputSchema: { type: 'object' },
-  outputs: [],
-  runtimeKey: 'return_result',
-  schemaVersion: 5,
-  instancePolicy: 'INLINE_ONLY',
-  uiSchema: { widget: 'return-result-config' },
-};
-
 const externalWaitNode: NodeTypeSeed = {
   type: 'external_wait',
   category: 'FLOW_CONTROL',
@@ -891,6 +1158,42 @@ const externalWaitNode: NodeTypeSeed = {
           deadlineBinding: PARAMETER_BINDING_SCHEMA,
         },
         required: ['mode'],
+        allOf: [
+          {
+            if: {
+              properties: { mode: { const: 'DURATION' } },
+              required: ['mode'],
+            },
+            then: {
+              required: ['durationSeconds'],
+              not: { required: ['deadlineBinding'] },
+            },
+          },
+          {
+            if: {
+              properties: { mode: { const: 'DEADLINE' } },
+              required: ['mode'],
+            },
+            then: {
+              required: ['deadlineBinding'],
+              not: { required: ['durationSeconds'] },
+            },
+          },
+          {
+            if: {
+              properties: { mode: { const: 'NONE' } },
+              required: ['mode'],
+            },
+            then: {
+              not: {
+                anyOf: [
+                  { required: ['durationSeconds'] },
+                  { required: ['deadlineBinding'] },
+                ],
+              },
+            },
+          },
+        ],
         additionalProperties: false,
       },
     },
@@ -903,48 +1206,56 @@ const externalWaitNode: NodeTypeSeed = {
   outputSchema: {
     type: 'object',
     properties: {
-      callbackToken: { type: 'string' },
-      nodeId: { type: 'string' },
-      eventId: { type: 'string' },
-      outcome: { type: 'string' },
-      operatorId: { type: 'string' },
-      data: { type: 'object' },
-      completedAt: { type: 'string' },
-      reason: { type: 'string' },
+      previous: {
+        description: '进入等待节点前收到的完整数据',
+      },
+      result: {
+        type: 'object',
+        properties: {
+          callbackToken: { type: 'string' },
+          eventId: { type: 'string' },
+          outcome: { type: 'string' },
+          operatorId: { type: 'string' },
+          data: { type: 'object' },
+          completedAt: { type: 'string' },
+          reason: { type: 'string' },
+        },
+        required: ['callbackToken'],
+      },
     },
-    required: ['callbackToken'],
+    required: ['previous', 'result'],
   },
   outputs: ['RECEIVED', 'TIMEOUT'],
   runtimeKey: 'external_wait',
-  schemaVersion: 2,
-  instancePolicy: 'INLINE_ONLY',
+  schemaVersion: 6,
+  instancePolicy: 'OPTIONAL',
   uiSchema: { widget: 'external-wait-config' },
 };
 
-const httpRequestDefinition = INLINE_NODE_DEFINITIONS.find(
+const httpRequestDefinition = NODE_DEFINITIONS.find(
   (definition) => definition.type === 'http_request',
 )!;
 
-const webhookDefinition = INLINE_NODE_DEFINITIONS.find(
+const webhookDefinition = NODE_DEFINITIONS.find(
   (definition) => definition.type === 'webhook_trigger',
 )!;
 
 const webhookNode: NodeTypeSeed = {
-  ...inlineNode(webhookDefinition),
+  ...templatableNode(webhookDefinition),
   runtimeKey: 'webhook_trigger',
-  schemaVersion: 4,
+  schemaVersion: 5,
   uiSchema: { widget: 'external-request-config' },
 };
 
 const httpRequestNode: NodeTypeSeed = {
   ...httpRequestDefinition,
   runtimeKey: 'http_request',
-  schemaVersion: 5,
+  schemaVersion: 8,
   instancePolicy: 'OPTIONAL',
   uiSchema: { widget: 'http-request-config' },
 };
 
-const codeDefinition = INLINE_NODE_DEFINITIONS.find(
+const codeDefinition = NODE_DEFINITIONS.find(
   (definition) => definition.type === 'code',
 )!;
 
@@ -955,58 +1266,114 @@ const codeNode: NodeTypeSeed = {
     properties: {
       script: {
         type: 'string',
-        description: 'JavaScript function body. Return the transformed value.',
+        description: 'JavaScript 函数体，通过 return 返回处理结果',
         default: 'return input;',
       },
       mode: {
         type: 'string',
-        enum: ['runOnceForAll', 'runOnceForEach'],
+        enum: ['runOnceForAll'],
         default: 'runOnceForAll',
       },
       timeout: {
         type: 'integer',
         minimum: 1,
         maximum: 5000,
-        default: 1000,
-        description: 'Maximum script execution time in milliseconds',
+        default: 5000,
+        description: '代码执行的最长时间（毫秒）',
       },
     },
     required: ['script'],
   },
-  inputSchema: { description: 'Any JSON value from the previous node' },
+  inputSchema: { description: '上一个节点返回的任意 JSON 值' },
   outputSchema: {
-    description: 'Any JSON value returned by the script',
+    description: '代码通过 return 返回的任意 JSON 值',
   },
   runtimeKey: 'code',
-  schemaVersion: 4,
+  schemaVersion: 6,
   instancePolicy: 'OPTIONAL',
   uiSchema: { widget: 'code-config' },
 };
 
+const forEachDefinition = NODE_DEFINITIONS.find(
+  (definition) => definition.type === 'for_each',
+)!;
+
+const forEachNode: NodeTypeSeed = {
+  ...templatableNode(forEachDefinition),
+  schemaVersion: 6,
+  uiSchema: { widget: 'for-each-config' },
+};
+
 const subWorkflowNode: NodeTypeSeed = {
-  ...inlineNode(subWorkflowDefinition),
-  schemaVersion: 2,
+  ...templatableNode(subWorkflowDefinition),
+  schemaVersion: 5,
+  uiSchema: { widget: 'sub-workflow-config' },
 };
 
+const dedicatedEditorNodes: NodeTypeSeed[] = [
+  ['event_trigger', 'event-trigger-config'],
+  ['db_execute', 'db-execute-config'],
+  ['delay', 'delay-config'],
+  ['parallel', 'parallel-config'],
+  ['if_else', 'if-else-config'],
+  ['switch', 'switch-config'],
+].map(([type, widget]) => ({
+  ...templatableNode(
+    NODE_DEFINITIONS.find((definition) => definition.type === type)!,
+  ),
+  schemaVersion:
+    type === 'event_trigger'
+      ? 4
+      : type === 'db_execute'
+      ? 4
+      : type === 'parallel'
+      ? 6
+      : ['if_else', 'switch'].includes(type)
+      ? 3
+      : 2,
+  uiSchema: {
+    widget,
+    ...(type === 'db_execute' && {
+      options: { validationErrors: 'widget' },
+    }),
+  },
+}));
+
 export const NODE_TYPES: NodeTypeSeed[] = [
-  ...INLINE_NODE_DEFINITIONS.filter(
+  ...NODE_DEFINITIONS.filter(
     (definition) =>
       definition.type !== 'http_request' &&
       definition.type !== 'code' &&
+      definition.type !== 'for_each' &&
+      !dedicatedEditorNodes.some((node) => node.type === definition.type) &&
       definition.type !== 'webhook_trigger',
-  ).map(inlineNode),
+  ).map(templatableNode),
   webhookNode,
   httpRequestNode,
   codeNode,
+  forEachNode,
+  ...dedicatedEditorNodes,
   humanApprovalNode,
   callableTriggerNode,
-  returnResultNode,
   externalWaitNode,
   subWorkflowNode,
 ];
 
 export async function seedNodeTypes(prisma: PrismaClient) {
   console.log('Seeding workflow node types...');
+  for (const removedType of ['return_result', 'db_query']) {
+    const removedNodeType = await prisma.workflowNodeType.findUnique({
+      where: { type: removedType },
+      select: { id: true },
+    });
+    if (!removedNodeType) continue;
+    await prisma.workflowNodeInstance.deleteMany({
+      where: { nodeTypeId: removedNodeType.id },
+    });
+    await prisma.workflowNodeType.delete({
+      where: { id: removedNodeType.id },
+    });
+  }
   for (const nodeType of NODE_TYPES) {
     // Json? null requires Prisma.DbNull (SQL NULL) — literal null is rejected at type level.
     const outputsValue =