@devops-flow/devops-flow-pipeline-detail 0.0.37

package/es/components/PipelineFlowEdit/FlowDocument/FlowJobEntry.d.ts

@@ -0,0 +1,21 @@
+import { Pair } from 'yaml';
+import { EntryNodeItem } from './FlowNodeBase';
+import { DefService } from './DefService';
+export declare class FlowJobEntry extends EntryNodeItem {
+    children: any[];
+    defService: DefService;
+    agentlessStepDefService?: DefService;
+    agentlessStepDef: any;
+    constructor(astNode: Pair, parent: any, ingredientsContextValue: any);
+    initChildren(): void;
+    bindDef(): void;
+    getAgentlessStep(): any;
+    /** 根据当前所写的 yaml 推断生效组件 */
+    getComponent(): {
+        componentItem: any;
+        isAgentlessJob: boolean;
+    };
+    getSchemaPropertyEntry(): Promise<{
+        [x: number]: any;
+    }>;
+}

package/es/components/PipelineFlowEdit/FlowDocument/FlowJobEntry.js

@@ -0,0 +1,388 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { isMap } from 'yaml';
+import produce from 'immer';
+import { EntryNodeItem } from "./FlowNodeBase";
+import { DefService } from "./DefService";
+import { FlowSteps } from "./FlowSteps";
+import { fetchWithCache } from "./cache";
+import { monacoYamlCompletionItemDescMark, getComponentName } from "../utils";
+import { getFeature } from "../../../utils";
+import intl from "../../../locale";
+export var FlowJobEntry = /*#__PURE__*/function (_EntryNodeItem) {
+  function FlowJobEntry(astNode, parent, ingredientsContextValue) {
+    var _this2;
+    _this2 = _EntryNodeItem.call(this, astNode, parent, ingredientsContextValue) || this;
+    _this2.children = [];
+    _this2.defService = null;
+    _this2.agentlessStepDefService = null;
+    _this2.agentlessStepDef = void 0;
+    _this2.bindDef();
+    _this2.initChildren();
+    // this.getSchema();
+    _this2.ingredientsContextValue = ingredientsContextValue;
+    return _this2;
+  }
+  _inheritsLoose(FlowJobEntry, _EntryNodeItem);
+  var _proto = FlowJobEntry.prototype;
+  _proto.initChildren = function initChildren() {
+    var jobValueNode = this.astNode.value;
+    if (isMap(jobValueNode)) {
+      var stepsPair = jobValueNode.items.find(function (v) {
+        return v.key.value === 'steps';
+      });
+      if (stepsPair) {
+        if (isMap(stepsPair.value)) {
+          this.children.push(new FlowSteps(stepsPair, this));
+        }
+      }
+    }
+  }
+  // children: {
+  //   name?: string;
+  //   component?: string;
+  //   with?: DefObject;
+  //   needs?: string | string[];
+  //   driven?: 'auto' | 'manual';
+  //   condition?: string;
+  //   plugins?: string;
+  //   // steps?: FlowStepState[];
+  // } & DefObject;
+  // 确定组件，找到 def
+  ;
+  _proto.bindDef = function bindDef() {
+    var _this$getComponent = this.getComponent(),
+      componentItem = _this$getComponent.componentItem,
+      isAgentlessJob = _this$getComponent.isAgentlessJob;
+
+    // runsOn 特殊处理
+    this.def = removeRunsOnDefIfNeeded(componentItem.defObj);
+    this.defService = new DefService(this.def);
+    if (isAgentlessJob) {
+      this.agentlessStepDef = this.getAgentlessStep().defObj;
+      this.agentlessStepDefService = new DefService(this.agentlessStepDef);
+    }
+  };
+  _proto.getAgentlessStep = function getAgentlessStep() {
+    var _this$getComponent2 = this.getComponent(),
+      componentItem = _this$getComponent2.componentItem,
+      isAgentlessJob = _this$getComponent2.isAgentlessJob;
+    if (!isAgentlessJob) {
+      return null;
+    }
+    var stepsList = this.getRoot().ingredientsContextValue.stepsList;
+    return stepsList.find(function (step) {
+      return step.sign === componentItem.sign;
+    });
+  }
+
+  /** 根据当前所写的 yaml 推断生效组件 */;
+  _proto.getComponent = function getComponent() {
+    var cpt = this.getValueFromAstNode(['component']);
+    var defCpt = cpt || 'ExecutionComponent';
+    var componentsList = this.getRoot().ingredientsContextValue.componentsList;
+    var componentItem = componentsList.find(function (item) {
+      return item.sign === defCpt;
+    });
+    return {
+      componentItem: componentItem,
+      isAgentlessJob: (componentItem === null || componentItem === void 0 ? void 0 : componentItem.isAgentlessJob) === 'Y'
+    };
+  };
+  _proto.getSchemaPropertyEntry = /*#__PURE__*/function () {
+    var _getSchemaPropertyEntry = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var _ref;
+      var componentFieldValue, stepsChild, childSchemaP, jobSchema, _this$getComponent3, _this$getComponent3$c, _this$getComponent3$c2, defSchema, defItems, runsOnDef, containerDef, _this$getComponent4, _this$getComponent4$c, _this$getComponent4$c2, _defItems, _runsOnDef, _containerDef, _defSchema;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            componentFieldValue = this.getValueFromAstNode(['component']);
+            stepsChild = this.children[0];
+            if (stepsChild) {
+              childSchemaP = stepsChild.getSchema();
+            }
+            if (componentFieldValue) {
+              _context.next = 21;
+              break;
+            }
+            _context.next = 6;
+            return this.defService.generateSchema();
+          case 6:
+            defSchema = _context.sent;
+            jobSchema = defSchema;
+            if (!childSchemaP) {
+              _context.next = 12;
+              break;
+            }
+            _context.next = 11;
+            return childSchemaP;
+          case 11:
+            jobSchema.properties.steps = _context.sent;
+          case 12:
+            defItems = ((_this$getComponent3 = this.getComponent()) === null || _this$getComponent3 === void 0 ? void 0 : (_this$getComponent3$c = _this$getComponent3.componentItem) === null || _this$getComponent3$c === void 0 ? void 0 : (_this$getComponent3$c2 = _this$getComponent3$c.defObj) === null || _this$getComponent3$c2 === void 0 ? void 0 : _this$getComponent3$c2.items) || [];
+            runsOnDef = defItems.find(function (v) {
+              return v.nameAlias === 'runsOn';
+            });
+            containerDef = defItems.find(function (v) {
+              return v.nameAlias === 'specifyContainerImageId';
+            });
+            _context.next = 17;
+            return generateRunsOnSchema({
+              runsOnDef: runsOnDef,
+              containerDef: containerDef,
+              isAgentLess: false
+            });
+          case 17:
+            jobSchema.properties.runsOn = _context.sent;
+            if (getFeature('build.timeoutMinutes')) {
+              jobSchema.properties.timeoutMinutes = {
+                type: 'number',
+                multipleOf: 1,
+                minimum: 1,
+                maximum: 1440
+              };
+            }
+            _context.next = 41;
+            break;
+          case 21:
+            if (!this.getComponent().isAgentlessJob) {
+              _context.next = 37;
+              break;
+            }
+            // agentless，用户不填写 steps 故去掉，实际 steps 参数填写在 with 字段中
+            this.defService = new DefService(produce(this.def, function (draft) {
+              draft.items = draft.items.filter(function (v) {
+                return v.name !== 'steps';
+              });
+            }));
+            _context.next = 25;
+            return this.defService.generateSchema();
+          case 25:
+            jobSchema = _context.sent;
+            _context.next = 28;
+            return this.agentlessStepDefService.generateSchema();
+          case 28:
+            jobSchema.properties["with"] = _context.sent;
+            _defItems = ((_this$getComponent4 = this.getComponent()) === null || _this$getComponent4 === void 0 ? void 0 : (_this$getComponent4$c = _this$getComponent4.componentItem) === null || _this$getComponent4$c === void 0 ? void 0 : (_this$getComponent4$c2 = _this$getComponent4$c.defObj) === null || _this$getComponent4$c2 === void 0 ? void 0 : _this$getComponent4$c2.items) || [];
+            _runsOnDef = _defItems.find(function (v) {
+              return v.nameAlias === 'runsOn';
+            });
+            _containerDef = _defItems.find(function (v) {
+              return v.nameAlias === 'specifyContainerImageId';
+            });
+            _context.next = 34;
+            return generateRunsOnSchema({
+              runsOnDef: _runsOnDef,
+              containerDef: _containerDef,
+              isAgentLess: true
+            });
+          case 34:
+            jobSchema.properties.runsOn = _context.sent;
+            _context.next = 41;
+            break;
+          case 37:
+            _context.next = 39;
+            return this.defService.generateSchema();
+          case 39:
+            _defSchema = _context.sent;
+            jobSchema = {
+              type: 'object',
+              properties: {
+                "with": _defSchema
+              }
+            };
+          case 41:
+            jobSchema = addComponentSchema(jobSchema, this);
+            console.log(jobSchema, 'jobSchema', this.astNode.key.value);
+            return _context.abrupt("return", (_ref = {}, _ref[this.astNode.key.value] = jobSchema, _ref));
+          case 44:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function getSchemaPropertyEntry() {
+      return _getSchemaPropertyEntry.apply(this, arguments);
+    }
+    return getSchemaPropertyEntry;
+  }();
+  return FlowJobEntry;
+}(EntryNodeItem);
+function addComponentSchema(jobSchema, _this) {
+  var astNode = _this.astNode,
+    ingredientsContextValue = _this.ingredientsContextValue;
+  var _ingredientsContextVa = ingredientsContextValue.userUseableComponents,
+    userUseableComponents = _ingredientsContextVa === void 0 ? [] : _ingredientsContextVa;
+  jobSchema.properties.component = {};
+  // 强行找runsOn
+  var runsOnNode = astNode.value.items.filter(function (a) {
+    return a.key.value === 'runsOn';
+  });
+  if (runsOnNode.length > 0 && runsOnNode[0].value.items) {
+    var vmNode = runsOnNode[0].value.items.filter(function (a) {
+      return a.key.value === 'vm';
+    });
+    var containerNode = runsOnNode[0].value.items.filter(function (a) {
+      return a.key.value === 'container';
+    });
+
+    // 当 vm 的值为 true  component 只能选择v2
+    if (vmNode[0] && vmNode[0].value.value) {
+      jobSchema.properties.component.oneOf = userUseableComponents.filter(function (item) {
+        return item.apiVersion === 'V2';
+      }).map(function (item) {
+        var name = getComponentName(item, ingredientsContextValue.stepsList);
+        if (!name) {
+          return null;
+        }
+        return {
+          "const": item.sign,
+          title: name,
+          description: monacoYamlCompletionItemDescMark(name)
+        };
+      }).filter(Boolean);
+      return jobSchema;
+    }
+    if (containerNode[0] && containerNode[0].value.value) {
+      jobSchema.properties.component.oneOf = userUseableComponents.filter(function (item) {
+        return item.apiVersion === 'V2';
+      }).map(function (item) {
+        var name = getComponentName(item, ingredientsContextValue.stepsList);
+        if (!name) {
+          return null;
+        }
+        return {
+          "const": item.sign,
+          title: name,
+          description: monacoYamlCompletionItemDescMark(name)
+        };
+      }).filter(Boolean);
+      return jobSchema;
+    }
+  }
+  jobSchema.properties.component.oneOf = userUseableComponents.filter(function (item) {
+    return item.apiVersion === 'V1';
+  }).map(function (item) {
+    var name = getComponentName(item, ingredientsContextValue.stepsList);
+    if (!name) {
+      return null;
+    }
+    return {
+      "const": item.sign,
+      title: name,
+      description: monacoYamlCompletionItemDescMark(name)
+    };
+  }).filter(Boolean);
+  return jobSchema;
+}
+/**
+  runsOn 相关的，由于yaml语法设计问题，有一些 hardcode 的逻辑
+  去掉 buildEnvironment， capabilities 字段
+  runsOn 补全不根据 def 实现。
+  runsOn 语法： https://aliyuque.antfin.com/aone/yunxiao/tp9xmo2wyu0gaqhe
+*/
+function removeRunsOnDefIfNeeded(defObj) {
+  var keys = ['runsOn', 'buildEnvironment', 'capabilities', 'specifyContainerImageId'];
+  return produce(defObj, function (draftDefObj) {
+    // 字段都存在的,才处理
+    var needProcess = keys.every(function (key) {
+      var defHasThisItem = !!draftDefObj.items.find(function (defItem) {
+        return defItem.nameAlias === key;
+      });
+      return defHasThisItem;
+    });
+    if (needProcess) {
+      // 删除字段
+      draftDefObj.items = draftDefObj.items.filter(function (v) {
+        return !keys.includes(v.nameAlias);
+      });
+    } else {
+      // 不处理
+    }
+  });
+}
+
+/**
+ * 这里描述 runsOn 在yaml里的语法结构
+ */
+function generateRunsOnSchema(_x) {
+  return _generateRunsOnSchema.apply(this, arguments);
+}
+function _generateRunsOnSchema() {
+  _generateRunsOnSchema = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref2) {
+    var _containerDef$datasou, _containerDef$datasou2, _window$YUNXIAO_COMMO;
+    var runsOnDef, containerDef, isAgentLess, resp, oneOfs, containerDefData;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          runsOnDef = _ref2.runsOnDef, containerDef = _ref2.containerDef, isAgentLess = _ref2.isAgentLess;
+          _context2.next = 3;
+          return fetchWithCache({
+            url: '/execution-component/buildNodeGroups',
+            crossOrigin: true,
+            withCredentials: true
+          });
+        case 3:
+          resp = _context2.sent;
+          oneOfs = resp.object.map(function (dataItem) {
+            return {
+              "const": dataItem.runsOnUid,
+              title: dataItem.name,
+              description: monacoYamlCompletionItemDescMark(dataItem.name)
+            };
+          });
+          containerDef === null || containerDef === void 0 ? void 0 : (_containerDef$datasou = containerDef.datasource) === null || _containerDef$datasou === void 0 ? void 0 : _containerDef$datasou.map(function (option) {
+            return {
+              // title: option.label,
+              "const": option.value
+              // description: monacoYamlCompletionItemDescMark(option.label),
+            };
+          });
+          containerDefData = containerDef !== null && containerDef !== void 0 && containerDef.datasource ? containerDef === null || containerDef === void 0 ? void 0 : (_containerDef$datasou2 = containerDef.datasource) === null || _containerDef$datasou2 === void 0 ? void 0 : _containerDef$datasou2.map(function (option) {
+            return {
+              // title: option.label,
+              "const": option.value
+              // description: monacoYamlCompletionItemDescMark(option.label),
+            };
+          }) : [];
+          return _context2.abrupt("return", {
+            title: runsOnDef.label,
+            description: runsOnDef.description,
+            oneOf: [].concat(oneOfs, [{
+              type: 'object',
+              properties: _extends({
+                vm: {
+                  type: 'boolean'
+                },
+                group: {
+                  oneOf: oneOfs
+                },
+                labels: {
+                  type: 'string'
+                },
+                container: {
+                  title: intl.get({
+                    id: 'rdc-tb-cd-assets.PipelineFlowEdit.FlowDocument.FlowJobEntry.SpecifyTheContainerEnvironment',
+                    defaultMessage: '指定容器环境'
+                  }),
+                  anyOf: [{
+                    type: 'string'
+                  }].concat(containerDefData)
+                }
+              }, !isAgentLess && ((_window$YUNXIAO_COMMO = window.YUNXIAO_COMMON) === null || _window$YUNXIAO_COMMO === void 0 ? void 0 : _window$YUNXIAO_COMMO.instanceTypeGrayRegion) === 'true' ? {
+                instanceType: {
+                  "enum": ['DEFAULT', 'SMALL_1C2G', 'MEDIUM_2C4G', 'LARGE_4C8G', 'XLARGE_8C16G']
+                }
+              } : {})
+            }])
+          });
+        case 8:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _generateRunsOnSchema.apply(this, arguments);
+}

package/es/components/PipelineFlowEdit/FlowDocument/FlowJobs.d.ts

@@ -0,0 +1,10 @@
+import { YAMLMap } from 'yaml';
+import { FlowNode } from './FlowNodeBase';
+export declare class FlowJobs extends FlowNode {
+    constructor(astNode: YAMLMap, parent: any, ingredientsContextValue: any);
+    initChildren(): void;
+    getSchema(): Promise<{
+        type: string;
+        properties: {};
+    }>;
+}

package/es/components/PipelineFlowEdit/FlowDocument/FlowJobs.js

@@ -0,0 +1,70 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _createForOfIteratorHelperLoose(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { FlowNode } from "./FlowNodeBase";
+import { FlowJobEntry } from "./FlowJobEntry";
+export var FlowJobs = /*#__PURE__*/function (_FlowNode) {
+  function FlowJobs(astNode, parent, ingredientsContextValue) {
+    var _this;
+    _this = _FlowNode.call(this, astNode, parent, ingredientsContextValue) || this;
+    _this.initChildren();
+    return _this;
+  }
+  _inheritsLoose(FlowJobs, _FlowNode);
+  var _proto = FlowJobs.prototype;
+  _proto.initChildren = function initChildren() {
+    var _this2 = this;
+    this.children = this.astNode.items.map(function (pairNode) {
+      return new FlowJobEntry(pairNode, _this2, _this2.ingredientsContextValue);
+    });
+  };
+  _proto.getSchema = /*#__PURE__*/function () {
+    var _getSchema = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var properties, schemasP, _iterator, _step, schemaP;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            properties = {};
+            schemasP = this.children.map(function (v) {
+              return v.getSchemaPropertyEntry();
+            });
+            _iterator = _createForOfIteratorHelperLoose(schemasP);
+          case 3:
+            if ((_step = _iterator()).done) {
+              _context.next = 14;
+              break;
+            }
+            schemaP = _step.value;
+            _context.t0 = _extends;
+            _context.t1 = {};
+            _context.t2 = properties;
+            _context.next = 10;
+            return schemaP;
+          case 10:
+            _context.t3 = _context.sent;
+            properties = (0, _context.t0)(_context.t1, _context.t2, _context.t3);
+          case 12:
+            _context.next = 3;
+            break;
+          case 14:
+            return _context.abrupt("return", {
+              type: 'object',
+              properties: properties
+            });
+          case 15:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function getSchema() {
+      return _getSchema.apply(this, arguments);
+    }
+    return getSchema;
+  }();
+  return FlowJobs;
+}(FlowNode);

package/es/components/PipelineFlowEdit/FlowDocument/FlowNodeBase.d.ts

@@ -0,0 +1,17 @@
+import { Node, Pair } from 'yaml';
+export declare class FlowNode {
+    constructor(node?: any, parent?: any, ingredientsContextValue?: any);
+    astNode: Node;
+    parent: FlowNode;
+    children: any;
+    ingredientsContextValue: any;
+    getValueFromAstNode(path: string[]): any;
+    getRoot(): this;
+}
+export declare class EntryNodeItem extends FlowNode {
+    constructor(astNode: Pair, parent: any, ingredientsContextValue: any);
+    key: string;
+}
+export declare class EntryNodesParent extends FlowNode {
+    getEntryItems(nodeCreator: any): any[];
+}

package/es/components/PipelineFlowEdit/FlowDocument/FlowNodeBase.js

@@ -0,0 +1,86 @@
+import _inheritsLoose from "@babel/runtime/helpers/inheritsLoose";
+import { isMap, isPair } from 'yaml';
+export var FlowNode = /*#__PURE__*/function () {
+  function FlowNode(node, parent, ingredientsContextValue) {
+    this.astNode = void 0;
+    this.parent = void 0;
+    this.children = null;
+    this.ingredientsContextValue = void 0;
+    this.astNode = node;
+    this.parent = parent;
+    this.ingredientsContextValue = ingredientsContextValue;
+  }
+  var _proto = FlowNode.prototype;
+  // todo 这里没有完整实现
+  _proto.getValueFromAstNode = function getValueFromAstNode(path) {
+    var valueNode = this.astNode;
+    if (isPair(valueNode)) {
+      valueNode = valueNode.value;
+    }
+    var value = getV(valueNode, path);
+    return value;
+    function getV(node, path) {
+      var _node$get;
+      var currPath = path[0],
+        restPath = path.slice(1);
+      // if (isMap(node)) {
+      //   const currNode_Pair = node.items.find((v) => v.key.value === currPath);
+      //   if (!restPath.length) {
+      //     return currNode_Pair?.value?.value;
+      // }
+      var curr = node === null || node === void 0 ? void 0 : (_node$get = node.get) === null || _node$get === void 0 ? void 0 : _node$get.call(node, currPath);
+      if (!restPath.length) {
+        return curr !== null && curr !== void 0 && curr.toJSON ? curr.toJSON() : curr;
+      } else {
+        return getV(curr, restPath);
+      }
+    }
+  };
+  _proto.getRoot = function getRoot() {
+    var curr = this;
+    while (curr.parent) {
+      curr = curr.parent;
+    }
+    return curr;
+  };
+  return FlowNode;
+}();
+
+// 一项 kv： stage， job
+export var EntryNodeItem = /*#__PURE__*/function (_FlowNode2) {
+  function EntryNodeItem(astNode, parent, ingredientsContextValue) {
+    var _this;
+    _this = _FlowNode2.call(this, astNode, parent, ingredientsContextValue) || this;
+    _this.key = void 0;
+    _this.key = astNode.key.value;
+    return _this;
+  }
+  _inheritsLoose(EntryNodeItem, _FlowNode2);
+  return EntryNodeItem;
+}(FlowNode);
+export var EntryNodesParent = /*#__PURE__*/function (_FlowNode3) {
+  function EntryNodesParent() {
+    return _FlowNode3.apply(this, arguments) || this;
+  }
+  _inheritsLoose(EntryNodesParent, _FlowNode3);
+  var _proto2 = EntryNodesParent.prototype;
+  // constructor(astNode, parent) {
+  //   super(astNode, parent);
+  // }
+  _proto2.getEntryItems = function getEntryItems(nodeCreator) {
+    if (!isPair(this.astNode)) {
+      console.warn('unexpected type');
+    } else {
+      var stagesValueNode = this.astNode.value;
+      if (!isMap(stagesValueNode)) {
+        // todo
+      } else {
+        return stagesValueNode.items.map(function (pairNode) {
+          // new FlowStageEntry(pairNode, this);
+          return nodeCreator(pairNode);
+        });
+      }
+    }
+  };
+  return EntryNodesParent;
+}(FlowNode);