@flowgram.ai/runtime-js 0.4.12 → 0.4.15

package/dist/esm/index.js

@@ -187,6 +187,8 @@ var WorkflowVariableType = /* @__PURE__ */ ((WorkflowVariableType2) => {
   WorkflowVariableType2["Boolean"] = "boolean";
   WorkflowVariableType2["Object"] = "object";
   WorkflowVariableType2["Array"] = "array";
+  WorkflowVariableType2["Map"] = "map";
+  WorkflowVariableType2["DateTime"] = "date-time";
   WorkflowVariableType2["Null"] = "null";
   return WorkflowVariableType2;
 })(WorkflowVariableType || {});
@@ -207,23 +209,23 @@ var FlowGramNode = /* @__PURE__ */ ((FlowGramNode22) => {
   FlowGramNode22["Continue"] = "continue";
   return FlowGramNode22;
 })(FlowGramNode || {});
-var ConditionOperation = /* @__PURE__ */ ((ConditionOperation2) => {
-  ConditionOperation2["EQ"] = "eq";
-  ConditionOperation2["NEQ"] = "neq";
-  ConditionOperation2["GT"] = "gt";
-  ConditionOperation2["GTE"] = "gte";
-  ConditionOperation2["LT"] = "lt";
-  ConditionOperation2["LTE"] = "lte";
-  ConditionOperation2["IN"] = "in";
-  ConditionOperation2["NIN"] = "nin";
-  ConditionOperation2["CONTAINS"] = "contains";
-  ConditionOperation2["NOT_CONTAINS"] = "not_contains";
-  ConditionOperation2["IS_EMPTY"] = "is_empty";
-  ConditionOperation2["IS_NOT_EMPTY"] = "is_not_empty";
-  ConditionOperation2["IS_TRUE"] = "is_true";
-  ConditionOperation2["IS_FALSE"] = "is_false";
-  return ConditionOperation2;
-})(ConditionOperation || {});
+var ConditionOperator = /* @__PURE__ */ ((ConditionOperator22) => {
+  ConditionOperator22["EQ"] = "eq";
+  ConditionOperator22["NEQ"] = "neq";
+  ConditionOperator22["GT"] = "gt";
+  ConditionOperator22["GTE"] = "gte";
+  ConditionOperator22["LT"] = "lt";
+  ConditionOperator22["LTE"] = "lte";
+  ConditionOperator22["IN"] = "in";
+  ConditionOperator22["NIN"] = "nin";
+  ConditionOperator22["CONTAINS"] = "contains";
+  ConditionOperator22["NOT_CONTAINS"] = "not_contains";
+  ConditionOperator22["IS_EMPTY"] = "is_empty";
+  ConditionOperator22["IS_NOT_EMPTY"] = "is_not_empty";
+  ConditionOperator22["IS_TRUE"] = "is_true";
+  ConditionOperator22["IS_FALSE"] = "is_false";
+  return ConditionOperator22;
+})(ConditionOperator || {});
 var HTTPBodyType = /* @__PURE__ */ ((HTTPBodyType2) => {
   HTTPBodyType2["None"] = "none";
   HTTPBodyType2["FormData"] = "form-data";
@@ -280,6 +282,13 @@ var WorkflowRuntimeType;
       return WorkflowVariableType.Null;
     }
     if (typeof value === "string") {
+      const iso8601Regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?$/;
+      if (iso8601Regex.test(value)) {
+        const date = new Date(value);
+        if (!isNaN(date.getTime())) {
+          return WorkflowVariableType.DateTime;
+        }
+      }
       return WorkflowVariableType.String;
     }
     if (typeof value === "boolean") {
@@ -306,11 +315,11 @@ var WorkflowRuntimeType;
     }
     return workflowType === type;
   };
-  WorkflowRuntimeType2.isTypeEqual = (leftType, rightType) => {
-    if (leftType === WorkflowVariableType.Number && rightType === WorkflowVariableType.Integer || leftType === WorkflowVariableType.Integer && rightType === WorkflowVariableType.Number) {
+  WorkflowRuntimeType2.isTypeEqual = (typeA, typeB) => {
+    if (typeA === WorkflowVariableType.Number && typeB === WorkflowVariableType.Integer || typeA === WorkflowVariableType.Integer && typeB === WorkflowVariableType.Number) {
       return true;
     }
-    return leftType === rightType;
+    return typeA === typeB;
   };
   WorkflowRuntimeType2.getArrayItemsType = (types) => {
     const expectedType = types[0];
@@ -1045,66 +1054,80 @@ var ContinueExecutor = class {
 };
 
 // src/nodes/condition/index.ts
-import { isNil as isNil9 } from "lodash-es";
+import { isNil as isNil11 } from "lodash-es";
 
 // src/nodes/condition/rules.ts
 var conditionRules = {
   [WorkflowVariableType.String]: {
-    [ConditionOperation.EQ]: WorkflowVariableType.String,
-    [ConditionOperation.NEQ]: WorkflowVariableType.String,
-    [ConditionOperation.CONTAINS]: WorkflowVariableType.String,
-    [ConditionOperation.NOT_CONTAINS]: WorkflowVariableType.String,
-    [ConditionOperation.IN]: WorkflowVariableType.Array,
-    [ConditionOperation.NIN]: WorkflowVariableType.Array,
-    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.String,
-    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.String
+    [ConditionOperator.EQ]: WorkflowVariableType.String,
+    [ConditionOperator.NEQ]: WorkflowVariableType.String,
+    [ConditionOperator.CONTAINS]: WorkflowVariableType.String,
+    [ConditionOperator.NOT_CONTAINS]: WorkflowVariableType.String,
+    [ConditionOperator.IN]: WorkflowVariableType.Array,
+    [ConditionOperator.NIN]: WorkflowVariableType.Array,
+    [ConditionOperator.IS_EMPTY]: WorkflowVariableType.String,
+    [ConditionOperator.IS_NOT_EMPTY]: WorkflowVariableType.String
   },
   [WorkflowVariableType.Number]: {
-    [ConditionOperation.EQ]: WorkflowVariableType.Number,
-    [ConditionOperation.NEQ]: WorkflowVariableType.Number,
-    [ConditionOperation.GT]: WorkflowVariableType.Number,
-    [ConditionOperation.GTE]: WorkflowVariableType.Number,
-    [ConditionOperation.LT]: WorkflowVariableType.Number,
-    [ConditionOperation.LTE]: WorkflowVariableType.Number,
-    [ConditionOperation.IN]: WorkflowVariableType.Array,
-    [ConditionOperation.NIN]: WorkflowVariableType.Array,
-    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
-    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
+    [ConditionOperator.EQ]: WorkflowVariableType.Number,
+    [ConditionOperator.NEQ]: WorkflowVariableType.Number,
+    [ConditionOperator.GT]: WorkflowVariableType.Number,
+    [ConditionOperator.GTE]: WorkflowVariableType.Number,
+    [ConditionOperator.LT]: WorkflowVariableType.Number,
+    [ConditionOperator.LTE]: WorkflowVariableType.Number,
+    [ConditionOperator.IN]: WorkflowVariableType.Array,
+    [ConditionOperator.NIN]: WorkflowVariableType.Array,
+    [ConditionOperator.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperator.IS_NOT_EMPTY]: WorkflowVariableType.Null
   },
   [WorkflowVariableType.Integer]: {
-    [ConditionOperation.EQ]: WorkflowVariableType.Integer,
-    [ConditionOperation.NEQ]: WorkflowVariableType.Integer,
-    [ConditionOperation.GT]: WorkflowVariableType.Integer,
-    [ConditionOperation.GTE]: WorkflowVariableType.Integer,
-    [ConditionOperation.LT]: WorkflowVariableType.Integer,
-    [ConditionOperation.LTE]: WorkflowVariableType.Integer,
-    [ConditionOperation.IN]: WorkflowVariableType.Array,
-    [ConditionOperation.NIN]: WorkflowVariableType.Array,
-    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
-    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
+    [ConditionOperator.EQ]: WorkflowVariableType.Integer,
+    [ConditionOperator.NEQ]: WorkflowVariableType.Integer,
+    [ConditionOperator.GT]: WorkflowVariableType.Integer,
+    [ConditionOperator.GTE]: WorkflowVariableType.Integer,
+    [ConditionOperator.LT]: WorkflowVariableType.Integer,
+    [ConditionOperator.LTE]: WorkflowVariableType.Integer,
+    [ConditionOperator.IN]: WorkflowVariableType.Array,
+    [ConditionOperator.NIN]: WorkflowVariableType.Array,
+    [ConditionOperator.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperator.IS_NOT_EMPTY]: WorkflowVariableType.Null
   },
   [WorkflowVariableType.Boolean]: {
-    [ConditionOperation.EQ]: WorkflowVariableType.Boolean,
-    [ConditionOperation.NEQ]: WorkflowVariableType.Boolean,
-    [ConditionOperation.IS_TRUE]: WorkflowVariableType.Null,
-    [ConditionOperation.IS_FALSE]: WorkflowVariableType.Null,
-    [ConditionOperation.IN]: WorkflowVariableType.Array,
-    [ConditionOperation.NIN]: WorkflowVariableType.Array,
-    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
-    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
+    [ConditionOperator.EQ]: WorkflowVariableType.Boolean,
+    [ConditionOperator.NEQ]: WorkflowVariableType.Boolean,
+    [ConditionOperator.IS_TRUE]: WorkflowVariableType.Null,
+    [ConditionOperator.IS_FALSE]: WorkflowVariableType.Null,
+    [ConditionOperator.IN]: WorkflowVariableType.Array,
+    [ConditionOperator.NIN]: WorkflowVariableType.Array,
+    [ConditionOperator.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperator.IS_NOT_EMPTY]: WorkflowVariableType.Null
   },
   [WorkflowVariableType.Object]: {
-    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
-    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
+    [ConditionOperator.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperator.IS_NOT_EMPTY]: WorkflowVariableType.Null
+  },
+  [WorkflowVariableType.Map]: {
+    [ConditionOperator.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperator.IS_NOT_EMPTY]: WorkflowVariableType.Null
+  },
+  [WorkflowVariableType.DateTime]: {
+    [ConditionOperator.EQ]: WorkflowVariableType.DateTime,
+    [ConditionOperator.NEQ]: WorkflowVariableType.DateTime,
+    [ConditionOperator.GT]: WorkflowVariableType.DateTime,
+    [ConditionOperator.GTE]: WorkflowVariableType.DateTime,
+    [ConditionOperator.LT]: WorkflowVariableType.DateTime,
+    [ConditionOperator.LTE]: WorkflowVariableType.DateTime,
+    [ConditionOperator.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperator.IS_NOT_EMPTY]: WorkflowVariableType.Null
   },
   [WorkflowVariableType.Array]: {
-    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
-    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
+    [ConditionOperator.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperator.IS_NOT_EMPTY]: WorkflowVariableType.Null
   },
   [WorkflowVariableType.Null]: {
-    [ConditionOperation.EQ]: WorkflowVariableType.Null,
-    [ConditionOperation.IS_EMPTY]: WorkflowVariableType.Null,
-    [ConditionOperation.IS_NOT_EMPTY]: WorkflowVariableType.Null
+    [ConditionOperator.EQ]: WorkflowVariableType.Null,
+    [ConditionOperator.IS_EMPTY]: WorkflowVariableType.Null,
+    [ConditionOperator.IS_NOT_EMPTY]: WorkflowVariableType.Null
   }
 };
 
@@ -1113,34 +1136,34 @@ import { isNil as isNil3 } from "lodash-es";
 var conditionStringHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === ConditionOperation.EQ) {
+  if (operator === ConditionOperator.EQ) {
     const rightValue = condition.rightValue;
     return leftValue === rightValue;
   }
-  if (operator === ConditionOperation.NEQ) {
+  if (operator === ConditionOperator.NEQ) {
     const rightValue = condition.rightValue;
     return leftValue !== rightValue;
   }
-  if (operator === ConditionOperation.CONTAINS) {
+  if (operator === ConditionOperator.CONTAINS) {
     const rightValue = condition.rightValue;
     return leftValue.includes(rightValue);
   }
-  if (operator === ConditionOperation.NOT_CONTAINS) {
+  if (operator === ConditionOperator.NOT_CONTAINS) {
     const rightValue = condition.rightValue;
     return !leftValue.includes(rightValue);
   }
-  if (operator === ConditionOperation.IN) {
+  if (operator === ConditionOperator.IN) {
     const rightValue = condition.rightValue;
     return rightValue.includes(leftValue);
   }
-  if (operator === ConditionOperation.NIN) {
+  if (operator === ConditionOperator.NIN) {
     const rightValue = condition.rightValue;
     return !rightValue.includes(leftValue);
   }
-  if (operator === ConditionOperation.IS_EMPTY) {
+  if (operator === ConditionOperator.IS_EMPTY) {
     return isNil3(leftValue);
   }
-  if (operator === ConditionOperation.IS_NOT_EMPTY) {
+  if (operator === ConditionOperator.IS_NOT_EMPTY) {
     return !isNil3(leftValue);
   }
   return false;
@@ -1151,10 +1174,10 @@ import { isNil as isNil4 } from "lodash-es";
 var conditionObjectHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === ConditionOperation.IS_EMPTY) {
+  if (operator === ConditionOperator.IS_EMPTY) {
     return isNil4(leftValue);
   }
-  if (operator === ConditionOperation.IS_NOT_EMPTY) {
+  if (operator === ConditionOperator.IS_NOT_EMPTY) {
     return !isNil4(leftValue);
   }
   return false;
@@ -1165,42 +1188,42 @@ import { isNil as isNil5 } from "lodash-es";
 var conditionNumberHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === ConditionOperation.EQ) {
+  if (operator === ConditionOperator.EQ) {
     const rightValue = condition.rightValue;
     return leftValue === rightValue;
   }
-  if (operator === ConditionOperation.NEQ) {
+  if (operator === ConditionOperator.NEQ) {
     const rightValue = condition.rightValue;
     return leftValue !== rightValue;
   }
-  if (operator === ConditionOperation.GT) {
+  if (operator === ConditionOperator.GT) {
     const rightValue = condition.rightValue;
     return leftValue > rightValue;
   }
-  if (operator === ConditionOperation.GTE) {
+  if (operator === ConditionOperator.GTE) {
     const rightValue = condition.rightValue;
     return leftValue >= rightValue;
   }
-  if (operator === ConditionOperation.LT) {
+  if (operator === ConditionOperator.LT) {
     const rightValue = condition.rightValue;
     return leftValue < rightValue;
   }
-  if (operator === ConditionOperation.LTE) {
+  if (operator === ConditionOperator.LTE) {
     const rightValue = condition.rightValue;
     return leftValue <= rightValue;
   }
-  if (operator === ConditionOperation.IN) {
+  if (operator === ConditionOperator.IN) {
     const rightValue = condition.rightValue;
     return rightValue.includes(leftValue);
   }
-  if (operator === ConditionOperation.NIN) {
+  if (operator === ConditionOperator.NIN) {
     const rightValue = condition.rightValue;
     return !rightValue.includes(leftValue);
   }
-  if (operator === ConditionOperation.IS_EMPTY) {
+  if (operator === ConditionOperator.IS_EMPTY) {
     return isNil5(leftValue);
   }
-  if (operator === ConditionOperation.IS_NOT_EMPTY) {
+  if (operator === ConditionOperator.IS_NOT_EMPTY) {
     return !isNil5(leftValue);
   }
   return false;
@@ -1211,64 +1234,119 @@ import { isNil as isNil6 } from "lodash-es";
 var conditionNullHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === ConditionOperation.EQ) {
+  if (operator === ConditionOperator.EQ) {
     return isNil6(leftValue) && isNil6(condition.rightValue);
   }
-  if (operator === ConditionOperation.IS_EMPTY) {
+  if (operator === ConditionOperator.IS_EMPTY) {
     return isNil6(leftValue);
   }
-  if (operator === ConditionOperation.IS_NOT_EMPTY) {
+  if (operator === ConditionOperator.IS_NOT_EMPTY) {
     return !isNil6(leftValue);
   }
   return false;
 };
 
-// src/nodes/condition/handlers/boolean.ts
+// src/nodes/condition/handlers/map.ts
 import { isNil as isNil7 } from "lodash-es";
+var conditionMapHandler = (condition) => {
+  const { operator } = condition;
+  const leftValue = condition.leftValue;
+  if (operator === ConditionOperator.IS_EMPTY) {
+    return isNil7(leftValue);
+  }
+  if (operator === ConditionOperator.IS_NOT_EMPTY) {
+    return !isNil7(leftValue);
+  }
+  return false;
+};
+
+// src/nodes/condition/handlers/datetime.ts
+import { isNil as isNil8 } from "lodash-es";
+var parseDateTime = (value) => {
+  if (value instanceof Date) {
+    return value;
+  }
+  return new Date(value);
+};
+var conditionDateTimeHandler = (condition) => {
+  const { operator } = condition;
+  const leftValue = condition.leftValue;
+  if (operator === ConditionOperator.IS_EMPTY) {
+    return isNil8(leftValue);
+  }
+  if (operator === ConditionOperator.IS_NOT_EMPTY) {
+    return !isNil8(leftValue);
+  }
+  const leftTime = parseDateTime(leftValue).getTime();
+  const rightValue = condition.rightValue;
+  const rightTime = parseDateTime(rightValue).getTime();
+  if (operator === ConditionOperator.EQ) {
+    return leftTime === rightTime;
+  }
+  if (operator === ConditionOperator.NEQ) {
+    return leftTime !== rightTime;
+  }
+  if (operator === ConditionOperator.GT) {
+    return leftTime > rightTime;
+  }
+  if (operator === ConditionOperator.GTE) {
+    return leftTime >= rightTime;
+  }
+  if (operator === ConditionOperator.LT) {
+    return leftTime < rightTime;
+  }
+  if (operator === ConditionOperator.LTE) {
+    return leftTime <= rightTime;
+  }
+  return false;
+};
+
+// src/nodes/condition/handlers/boolean.ts
+import { isNil as isNil9 } from "lodash-es";
 var conditionBooleanHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === ConditionOperation.EQ) {
+  if (operator === ConditionOperator.EQ) {
     const rightValue = condition.rightValue;
     return leftValue === rightValue;
   }
-  if (operator === ConditionOperation.NEQ) {
+  if (operator === ConditionOperator.NEQ) {
     const rightValue = condition.rightValue;
     return leftValue !== rightValue;
   }
-  if (operator === ConditionOperation.IS_TRUE) {
+  if (operator === ConditionOperator.IS_TRUE) {
     return leftValue === true;
   }
-  if (operator === ConditionOperation.IS_FALSE) {
+  if (operator === ConditionOperator.IS_FALSE) {
     return leftValue === false;
   }
-  if (operator === ConditionOperation.IN) {
+  if (operator === ConditionOperator.IN) {
     const rightValue = condition.rightValue;
     return rightValue.includes(leftValue);
   }
-  if (operator === ConditionOperation.NIN) {
+  if (operator === ConditionOperator.NIN) {
     const rightValue = condition.rightValue;
     return !rightValue.includes(leftValue);
   }
-  if (operator === ConditionOperation.IS_EMPTY) {
-    return isNil7(leftValue);
+  if (operator === ConditionOperator.IS_EMPTY) {
+    return isNil9(leftValue);
   }
-  if (operator === ConditionOperation.IS_NOT_EMPTY) {
-    return !isNil7(leftValue);
+  if (operator === ConditionOperator.IS_NOT_EMPTY) {
+    return !isNil9(leftValue);
   }
   return false;
 };
 
 // src/nodes/condition/handlers/array.ts
-import { isNil as isNil8 } from "lodash-es";
+import { isNil as isNil10 } from "lodash-es";
 var conditionArrayHandler = (condition) => {
   const { operator } = condition;
   const leftValue = condition.leftValue;
-  if (operator === ConditionOperation.IS_EMPTY) {
-    return isNil8(leftValue);
+  if (operator === ConditionOperator.IS_EMPTY) {
+    return isNil10(leftValue);
   }
-  if (operator === ConditionOperation.IS_NOT_EMPTY) {
-    return !isNil8(leftValue);
+  if (operator === ConditionOperator.IS_NOT_EMPTY) {
+    return !isNil10(leftValue);
   }
   return false;
 };
@@ -1280,7 +1358,9 @@ var conditionHandlers = {
   [WorkflowVariableType.Integer]: conditionNumberHandler,
   [WorkflowVariableType.Boolean]: conditionBooleanHandler,
   [WorkflowVariableType.Object]: conditionObjectHandler,
+  [WorkflowVariableType.Map]: conditionMapHandler,
   [WorkflowVariableType.Array]: conditionArrayHandler,
+  [WorkflowVariableType.DateTime]: conditionDateTimeHandler,
   [WorkflowVariableType.Null]: conditionNullHandler
 };
 
@@ -1299,7 +1379,10 @@ var ConditionExecutor = class {
     const parsedConditions = conditions.map((item) => this.parseCondition(item, context)).filter((item) => this.checkCondition(item));
     const activatedCondition = parsedConditions.find((item) => this.handleCondition(item));
     if (!activatedCondition) {
-      throw new Error("No condition is activated");
+      return {
+        outputs: {},
+        branch: "else"
+      };
     }
     return {
       outputs: {},
@@ -1312,7 +1395,11 @@ var ConditionExecutor = class {
     const parsedLeft = context.runtime.state.parseRef(left);
     const leftValue = parsedLeft?.value ?? null;
     const leftType = parsedLeft?.type ?? WorkflowVariableType.Null;
-    const parsedRight = Boolean(right) ? context.runtime.state.parseValue(right) : null;
+    const expectedRightType = this.getRuleType({ leftType, operator });
+    const parsedRight = Boolean(right) ? context.runtime.state.parseFlowValue({
+      flowValue: right,
+      declareType: expectedRightType
+    }) : null;
     const rightValue = parsedRight?.value ?? null;
     const rightType = parsedRight?.type ?? WorkflowVariableType.Null;
     return {
@@ -1326,11 +1413,11 @@ var ConditionExecutor = class {
   }
   checkCondition(condition) {
     const rule = conditionRules[condition.leftType];
-    if (isNil9(rule)) {
+    if (isNil11(rule)) {
       throw new Error(`Condition left type "${condition.leftType}" is not supported`);
     }
     const ruleType = rule[condition.operator];
-    if (isNil9(ruleType)) {
+    if (isNil11(ruleType)) {
       throw new Error(
         `Condition left type "${condition.leftType}" has no operator "${condition.operator}"`
       );
@@ -1348,6 +1435,18 @@ var ConditionExecutor = class {
     const isActive = handler(condition);
     return isActive;
   }
+  getRuleType(params) {
+    const { leftType, operator } = params;
+    const rule = conditionRules[leftType];
+    if (isNil11(rule)) {
+      return WorkflowVariableType.Null;
+    }
+    const ruleType = rule[operator];
+    if (isNil11(ruleType)) {
+      return WorkflowVariableType.Null;
+    }
+    return ruleType;
+  }
 };
 
 // src/nodes/code/index.ts
@@ -2089,13 +2188,14 @@ var WorkflowRuntimeStatusCenter = class {
 };
 
 // src/domain/state/index.ts
-import { isNil as isNil10 } from "lodash-es";
+import { isNil as isNil12 } from "lodash-es";
 var WorkflowRuntimeState = class {
   constructor(variableStore) {
     this.variableStore = variableStore;
     this.id = uuid();
   }
-  init() {
+  init(schema) {
+    this.setGlobalVariable(schema?.globalVariable);
     this.executedNodes = /* @__PURE__ */ new Set();
   }
   dispose() {
@@ -2112,16 +2212,17 @@ var WorkflowRuntimeState = class {
   setNodeOutputs(params) {
     const { node, outputs } = params;
     const outputsDeclare = node.declare.outputs;
-    if (!outputsDeclare) {
+    if (outputsDeclare?.type !== "object" || !outputsDeclare.properties) {
       return;
     }
-    Object.entries(outputs).forEach(([key, value]) => {
-      const typeInfo = outputsDeclare.properties?.[key];
-      if (!typeInfo) {
+    Object.entries(outputsDeclare.properties).forEach(([key, typeInfo]) => {
+      if (!key || !typeInfo) {
         return;
       }
       const type = typeInfo.type;
       const itemsType = typeInfo.items?.type;
+      const defaultValue = this.parseJSONContent(typeInfo.default, type);
+      const value = outputs[key] ?? defaultValue;
       this.variableStore.setVariable({
         nodeID: node.id,
         key,
@@ -2136,18 +2237,18 @@ var WorkflowRuntimeState = class {
     if (!declare || !values) {
       return {};
     }
-    return Object.entries(values).reduce((prev, [key, inputValue]) => {
+    return Object.entries(values).reduce((prev, [key, flowValue]) => {
       const typeInfo = declare.properties?.[key];
       if (!typeInfo) {
         return prev;
       }
-      const expectType = typeInfo.type;
-      const result = this.parseValue(inputValue);
+      const declareType = typeInfo.type;
+      const result = this.parseFlowValue({ flowValue, declareType });
       if (!result) {
         return prev;
       }
       const { value, type } = result;
-      if (!WorkflowRuntimeType.isTypeEqual(type, expectType)) {
+      if (!WorkflowRuntimeType.isTypeEqual(type, declareType)) {
         return prev;
       }
       prev[key] = value;
@@ -2198,14 +2299,15 @@ var WorkflowRuntimeState = class {
       value: parsedValue
     };
   }
-  parseValue(flowValue) {
+  parseFlowValue(params) {
+    const { flowValue, declareType } = params;
     if (!flowValue?.type) {
       throw new Error(`Invalid flow value type: ${flowValue.type}`);
     }
     if (flowValue.type === "constant") {
-      const value = flowValue.content;
-      const type = WorkflowRuntimeType.getWorkflowType(value);
-      if (isNil10(value) || !type) {
+      const value = this.parseJSONContent(flowValue.content, declareType);
+      const type = declareType ?? WorkflowRuntimeType.getWorkflowType(value);
+      if (isNil12(value) || !type) {
         return null;
       }
       return {
@@ -2227,6 +2329,41 @@ var WorkflowRuntimeState = class {
   addExecutedNode(node) {
     this.executedNodes.add(node.id);
   }
+  parseJSONContent(jsonContent, declareType) {
+    const JSONTypes = [
+      WorkflowVariableType.Object,
+      WorkflowVariableType.Array,
+      WorkflowVariableType.Map
+    ];
+    if (declareType && JSONTypes.includes(declareType) && typeof jsonContent === "string") {
+      try {
+        return JSON.parse(jsonContent);
+      } catch (e) {
+        return jsonContent;
+      }
+    }
+    return jsonContent;
+  }
+  setGlobalVariable(globalVariableDeclare) {
+    if (globalVariableDeclare?.type !== "object" || !globalVariableDeclare.properties) {
+      return;
+    }
+    Object.entries(globalVariableDeclare.properties).forEach(([key, typeInfo]) => {
+      if (!key || !typeInfo) {
+        return;
+      }
+      const type = typeInfo.type;
+      const itemsType = typeInfo.items?.type;
+      const defaultValue = this.parseJSONContent(typeInfo.default, type);
+      this.variableStore.setVariable({
+        nodeID: "global",
+        key,
+        value: defaultValue,
+        type,
+        itemsType
+      });
+    });
+  }
 };
 
 // src/domain/snapshot/snapshot-entity/index.ts
@@ -2702,7 +2839,7 @@ var WorkflowRuntimeContext = class _WorkflowRuntimeContext {
     this.cache.init();
     this.document.init(schema);
     this.variableStore.init();
-    this.state.init();
+    this.state.init(schema);
     this.ioCenter.init(inputs);
     this.snapshotCenter.init();
     this.statusCenter.init();
@@ -2888,7 +3025,7 @@ var WorkflowRuntimeEngine = class {
     }
     const targetPort = node.ports.outputs.find((port) => port.id === branch);
     if (!targetPort) {
-      throw new Error(`Engine branch ${branch} not found`);
+      throw new Error(`Branch "${branch}" not found`);
     }
     const nextNodeIDs = new Set(targetPort.edges.map((edge) => edge.to.id));
     const nextNodes = allNextNodes.filter((nextNode) => nextNodeIDs.has(nextNode.id));
@@ -2913,7 +3050,7 @@ var WorkflowRuntimeEngine = class {
       return;
     }
     if (nextNodes.length === 0) {
-      throw new Error(`Node ${node.id} has no next nodes`);
+      throw new Error(`Node "${node.id}" has no next nodes`);
     }
     await Promise.all(
       nextNodes.map(