@nocobase/plugin-workflow 0.7.0-alpha.9 → 0.7.1-alpha.6

package/lib/triggers/schedule.js

@@ -0,0 +1,672 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SCHEDULE_MODE = void 0;
+
+function _cronParser() {
+  const data = _interopRequireDefault(require("cron-parser"));
+
+  _cronParser = function _cronParser() {
+    return data;
+  };
+
+  return data;
+}
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+var _ = require("..");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _asyncIterator(iterable) { var method, async, sync, retry = 2; for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) { if (async && null != (method = iterable[async])) return method.call(iterable); if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable)); async = "@@asyncIterator", sync = "@@iterator"; } throw new TypeError("Object is not async iterable"); }
+
+function AsyncFromSyncIterator(s) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var done = r.done; return Promise.resolve(r.value).then(function (value) { return { value: value, done: done }; }); } return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) { this.s = s, this.n = s.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, return: function _return(value) { var ret = this.s.return; return void 0 === ret ? Promise.resolve({ value: value, done: !0 }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments)); }, throw: function _throw(value) { var thr = this.s.return; return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(s); }
+
+const SCHEDULE_MODE = {
+  CONSTANT: 0,
+  COLLECTION_FIELD: 1
+};
+exports.SCHEDULE_MODE = SCHEDULE_MODE;
+const ScheduleModes = new Map();
+ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
+  shouldCache(workflow, now) {
+    const _workflow$config = workflow.config,
+          startsOn = _workflow$config.startsOn,
+          endsOn = _workflow$config.endsOn,
+          repeat = _workflow$config.repeat;
+    const timestamp = now.getTime();
+
+    if (startsOn) {
+      const startTime = Date.parse(startsOn);
+
+      if (!startTime || startTime > timestamp + this.cacheCycle) {
+        return false;
+      }
+
+      if (typeof repeat === 'number' && repeat > this.cacheCycle && (timestamp - startTime) % repeat > this.cacheCycle) {
+        return false;
+      }
+    }
+
+    if (endsOn) {
+      const endTime = Date.parse(endsOn);
+
+      if (!endTime || endTime <= timestamp) {
+        return false;
+      }
+    }
+
+    return true;
+  },
+
+  trigger(workflow, date) {
+    const _workflow$config2 = workflow.config,
+          startsOn = _workflow$config2.startsOn,
+          endsOn = _workflow$config2.endsOn,
+          repeat = _workflow$config2.repeat;
+
+    if (startsOn && typeof repeat === 'number') {
+      const startTime = Date.parse(startsOn);
+
+      if ((startTime - date.getTime()) % repeat) {
+        return;
+      }
+    }
+
+    return this.plugin.trigger(workflow, {
+      date
+    });
+  }
+
+});
+
+function getDateRangeFilter(on, now, dir) {
+  const timestamp = now.getTime();
+  const op = dir < 0 ? _sequelize().Op.lt : _sequelize().Op.gte;
+
+  switch (typeof on) {
+    case 'string':
+      const time = Date.parse(on);
+
+      if (!time || (dir < 0 ? timestamp < time : time <= timestamp)) {
+        return null;
+      }
+
+      break;
+
+    case 'object':
+      const field = on.field,
+            _on$offset = on.offset,
+            offset = _on$offset === void 0 ? 0 : _on$offset,
+            _on$unit = on.unit,
+            unit = _on$unit === void 0 ? 1000 : _on$unit;
+
+      if (!field) {
+        return {};
+      }
+
+      return {
+        [field]: {
+          [op]: new Date(timestamp + offset * unit * dir)
+        }
+      };
+
+    default:
+      break;
+  }
+
+  return {};
+}
+
+function getDataOptionTime(data, on, dir = 1) {
+  switch (typeof on) {
+    case 'string':
+      const time = Date.parse(on);
+      return time ? time : null;
+
+    case 'object':
+      const field = on.field,
+            _on$offset2 = on.offset,
+            offset = _on$offset2 === void 0 ? 0 : _on$offset2,
+            _on$unit2 = on.unit,
+            unit = _on$unit2 === void 0 ? 1000 : _on$unit2;
+      return data[field] ? data[field].getTime() - offset * unit * dir : null;
+
+    default:
+      return null;
+  }
+}
+
+function getHookId(workflow, type) {
+  return `${type}#${workflow.id}`;
+}
+
+const DialectTimestampFnMap = {
+  postgres(col) {
+    return `CAST(FLOOR(extract(epoch from "${col}")) AS INTEGER)`;
+  },
+
+  mysql(col) {
+    return `CAST(FLOOR(UNIX_TIMESTAMP(\`${col}\`)) AS SIGNED INTEGER)`;
+  },
+
+  sqlite(col) {
+    return `CAST(FLOOR(unixepoch(${col})) AS INTEGER)`;
+  }
+
+};
+DialectTimestampFnMap.mariadb = DialectTimestampFnMap.mysql;
+ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
+  on(workflow) {
+    var _this = this;
+
+    const _workflow$config3 = workflow.config,
+          collection = _workflow$config3.collection,
+          startsOn = _workflow$config3.startsOn,
+          endsOn = _workflow$config3.endsOn,
+          repeat = _workflow$config3.repeat;
+    const event = `${collection}.afterSave`;
+    const name = getHookId(workflow, event);
+
+    if (!this.events.has(name)) {
+      // NOTE: toggle cache depends on new date
+      const listener = /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator(function* (data, options) {
+          const now = new Date();
+          now.setMilliseconds(0);
+          const timestamp = now.getTime();
+          const startTime = getDataOptionTime(data, startsOn);
+          const endTime = getDataOptionTime(data, endsOn, -1);
+
+          if (!startTime && !repeat) {
+            return;
+          }
+
+          if (startTime && startTime > timestamp + _this.cacheCycle) {
+            return;
+          }
+
+          if (endTime && endTime <= timestamp) {
+            return;
+          }
+
+          if (!nextInCycle.call(_this, workflow, now)) {
+            return;
+          }
+
+          if (typeof repeat === 'number' && repeat > _this.cacheCycle && (timestamp - startTime) % repeat > _this.cacheCycle) {
+            return;
+          }
+
+          console.log('set cache', now);
+
+          _this.setCache(workflow);
+        });
+
+        return function listener(_x, _x2) {
+          return _ref.apply(this, arguments);
+        };
+      }();
+
+      this.events.set(name, listener);
+      this.plugin.app.db.on(`${collection}.afterSave`, listener);
+    }
+  },
+
+  off(workflow) {
+    const collection = workflow.config.collection;
+    const event = `${collection}.afterSave`;
+    const name = getHookId(workflow, event);
+
+    if (this.events.has(name)) {
+      const listener = this.events.get(name);
+      this.events.delete(name);
+      this.plugin.app.db.off(`${collection}.afterSave`, listener);
+    }
+  },
+
+  shouldCache(workflow, now) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      const _workflow$config4 = workflow.config,
+            startsOn = _workflow$config4.startsOn,
+            endsOn = _workflow$config4.endsOn,
+            repeat = _workflow$config4.repeat,
+            collection = _workflow$config4.collection;
+      const starts = getDateRangeFilter(startsOn, now, -1);
+
+      if (!starts || !Object.keys(starts).length) {
+        return false;
+      }
+
+      const ends = getDateRangeFilter(endsOn, now, 1);
+
+      if (!ends) {
+        return false;
+      }
+
+      const conditions = [starts, ends].filter(item => Boolean(Object.keys(item).length)); // when repeat is number, means repeat after startsOn
+      // (now - startsOn) % repeat <= cacheCycle
+
+      const db = _this2.plugin.app.db;
+      const tsFn = DialectTimestampFnMap[db.options.dialect];
+
+      if (repeat && typeof repeat === 'number' && repeat > _this2.cacheCycle && tsFn) {
+        const uts = now.getTime();
+        conditions.push((0, _sequelize().where)((0, _sequelize().fn)('MOD', (0, _sequelize().literal)(`${Math.round(uts / 1000)} - ${tsFn(startsOn.field)}`), Math.round(repeat / 1000)), {
+          [_sequelize().Op.lt]: Math.round(_this2.cacheCycle / 1000)
+        })); // conditions.push(literal(`mod(${uts} - ${tsFn(startsOn.field)} * 1000, ${repeat}) < ${this.cacheCycle}`));
+      }
+
+      const _db$getCollection = db.getCollection(collection),
+            model = _db$getCollection.model;
+
+      const count = yield model.count({
+        where: {
+          [_sequelize().Op.and]: conditions
+        }
+      });
+      return Boolean(count);
+    })();
+  },
+
+  trigger(workflow, date) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      var _startsOn$offset, _startsOn$unit;
+
+      const _workflow$config5 = workflow.config,
+            collection = _workflow$config5.collection,
+            startsOn = _workflow$config5.startsOn,
+            endsOn = _workflow$config5.endsOn,
+            repeat = _workflow$config5.repeat;
+
+      if (typeof startsOn !== 'object') {
+        return;
+      }
+
+      const timestamp = date.getTime();
+      const startTimestamp = timestamp - ((_startsOn$offset = startsOn.offset) !== null && _startsOn$offset !== void 0 ? _startsOn$offset : 0) * ((_startsOn$unit = startsOn.unit) !== null && _startsOn$unit !== void 0 ? _startsOn$unit : 1000);
+      const conditions = [];
+
+      if (!repeat) {
+        // startsOn exactly equal to now in 1s
+        conditions.push({
+          [startsOn.field]: {
+            [_sequelize().Op.gte]: new Date(startTimestamp),
+            [_sequelize().Op.lt]: new Date(startTimestamp + 1000)
+          }
+        });
+      } else {
+        // startsOn not after now
+        conditions.push({
+          [startsOn.field]: {
+            [_sequelize().Op.lt]: new Date(startTimestamp)
+          }
+        });
+        const tsFn = DialectTimestampFnMap[_this3.plugin.app.db.options.dialect];
+
+        if (typeof repeat === 'number' && tsFn) {
+          conditions.push((0, _sequelize().where)((0, _sequelize().fn)('MOD', (0, _sequelize().literal)(`${Math.round(timestamp / 1000)} - ${tsFn(startsOn.field)}`), Math.round(repeat / 1000)), {
+            [_sequelize().Op.eq]: 0
+          })); // conditions.push(literal(`MOD(CAST(${timestamp} AS BIGINT) - CAST((FLOOR(${tsFn(startsOn.field)}) AS BIGINT) * 1000), ${repeat}) = 0`));
+        }
+
+        switch (typeof endsOn) {
+          case 'string':
+            const endTime = Date.parse(endsOn);
+
+            if (!endTime || endTime <= timestamp) {
+              return;
+            }
+
+            break;
+
+          case 'object':
+            if (endsOn.field) {
+              var _endsOn$offset, _endsOn$unit;
+
+              conditions.push({
+                [endsOn.field]: {
+                  [_sequelize().Op.gte]: new Date(timestamp - ((_endsOn$offset = endsOn.offset) !== null && _endsOn$offset !== void 0 ? _endsOn$offset : 0) * ((_endsOn$unit = endsOn.unit) !== null && _endsOn$unit !== void 0 ? _endsOn$unit : 1000) + 1000)
+                }
+              });
+            }
+
+            break;
+
+          default:
+            break;
+        }
+      }
+
+      const _this3$plugin$app$db$ = _this3.plugin.app.db.getCollection(collection),
+            model = _this3$plugin$app$db$.model;
+
+      const instances = yield model.findAll({
+        where: {
+          [_sequelize().Op.and]: conditions
+        }
+      });
+
+      if (instances.length) {
+        console.log(instances.length, 'rows trigger at', date);
+      }
+
+      instances.forEach(item => {
+        _this3.plugin.trigger(workflow, {
+          date,
+          data: item.get()
+        });
+      });
+    })();
+  }
+
+});
+
+function nextInCycle(workflow, now) {
+  const repeat = workflow.config.repeat; // no repeat means no need to rerun
+  // but if in current cycle, should be put in cache
+  // no repeat but in current cycle means startsOn has been configured
+  // so we need to more info to determine if necessary config items
+
+  if (!repeat) {
+    return true;
+  }
+
+  switch (typeof repeat) {
+    case 'string':
+      break;
+
+    default:
+      return true;
+  }
+
+  const currentDate = new Date(now);
+  currentDate.setMilliseconds(-1);
+  const timestamp = now.getTime();
+
+  const interval = _cronParser().default.parseExpression(repeat, {
+    currentDate
+  });
+
+  let next = interval.next(); // NOTE: cache all workflows will be matched in current cycle
+
+  if (next.getTime() - timestamp <= this.cacheCycle) {
+    return true;
+  }
+
+  return false;
+}
+
+class ScheduleTrigger extends _.Trigger {
+  // running interval, default to 1s
+  // caching workflows in range, default to 1min
+  constructor(plugin) {
+    super(plugin);
+    this.events = new Map();
+    this.timer = null;
+    this.cache = new Map();
+    this.interval = 1000;
+    this.cacheCycle = 60000;
+
+    this.run = () => {
+      const now = new Date();
+      now.setMilliseconds(0); // NOTE: trigger `onTick` for high interval jobs which are cached in last 1 min
+
+      this.onTick(now); // NOTE: reload when second match cache cycle
+
+      if (!(now.getTime() % this.cacheCycle)) {
+        this.reload();
+      }
+    };
+
+    plugin.app.on('beforeStop', () => {
+      if (this.timer) {
+        clearInterval(this.timer);
+      }
+    });
+  }
+
+  init() {
+    if (!this.timer) {
+      const now = new Date(); // NOTE: assign to this.timer to avoid duplicated initialization
+
+      this.timer = setTimeout(() => {
+        this.timer = setInterval(this.run, this.interval); // initially trigger
+        // this.onTick(now);
+      }, // NOTE:
+      //  try to align to system time on each second starts,
+      //  after at least 1 second initialized for anything to get ready.
+      //  so jobs in 2 seconds will be missed at first start.
+      1000 - now.getMilliseconds());
+    }
+  }
+
+  onTick(now) {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      // NOTE: trigger workflows in sequence when sqlite due to only one transaction
+      const isSqlite = _this4.plugin.app.db.options.dialect === 'sqlite';
+      return Array.from(_this4.cache.values()).reduce((prev, workflow) => {
+        if (!_this4.shouldTrigger(workflow, now)) {
+          return prev;
+        }
+
+        if (isSqlite) {
+          return prev.then(() => _this4.trigger(workflow, now));
+        }
+
+        _this4.trigger(workflow, now);
+
+        return null;
+      }, isSqlite ? Promise.resolve() : null);
+    })();
+  }
+
+  reload() {
+    var _this5 = this;
+
+    return _asyncToGenerator(function* () {
+      const WorkflowModel = _this5.plugin.app.db.getCollection('workflows').model;
+
+      const workflows = yield WorkflowModel.findAll({
+        where: {
+          enabled: true,
+          type: 'schedule'
+        },
+        include: [{
+          association: 'executions',
+          attributes: ['id', 'createdAt'],
+          separate: true,
+          limit: 1,
+          order: [['createdAt', 'DESC']]
+        }],
+        group: ['id']
+      }); // NOTE: clear cached jobs in last cycle
+
+      _this5.cache = new Map();
+
+      _this5.inspect(workflows);
+    })();
+  }
+
+  inspect(workflows) {
+    var _this6 = this;
+
+    const now = new Date();
+    now.setMilliseconds(0);
+    workflows.forEach( /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(function* (workflow) {
+        const should = yield _this6.shouldCache(workflow, now);
+
+        _this6.setCache(workflow, !should);
+      });
+
+      return function (_x3) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
+  }
+
+  setCache(workflow, out = false) {
+    out ? this.cache.delete(workflow.id) : this.cache.set(workflow.id, workflow);
+  }
+
+  shouldCache(workflow, now) {
+    var _this7 = this;
+
+    return _asyncToGenerator(function* () {
+      var _iteratorAbruptCompletion = false;
+      var _didIteratorError = false;
+
+      var _iteratorError;
+
+      try {
+        for (var _iterator = _asyncIterator(_this7.constructor.CacheRules), _step; _iteratorAbruptCompletion = !(_step = yield _iterator.next()).done; _iteratorAbruptCompletion = false) {
+          const rule = _step.value;
+
+          if (!(yield rule.call(_this7, workflow, now))) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (_iteratorAbruptCompletion && _iterator.return != null) {
+            yield _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+
+      return true;
+    })();
+  }
+
+  shouldTrigger(workflow, now) {
+    var _iterator2 = _createForOfIteratorHelper(this.constructor.TriggerRules),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        const rule = _step2.value;
+
+        if (!rule.call(this, workflow, now)) {
+          return false;
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+
+    return true;
+  }
+
+  trigger(workflow, date) {
+    var _this8 = this;
+
+    return _asyncToGenerator(function* () {
+      const mode = workflow.config.mode;
+      const modeHandlers = ScheduleModes.get(mode);
+      return modeHandlers.trigger.call(_this8, workflow, date);
+    })();
+  }
+
+  on(workflow) {
+    // NOTE: lazy initialization
+    this.init();
+    const mode = workflow.config.mode;
+    const modeHandlers = ScheduleModes.get(mode);
+
+    if (modeHandlers && modeHandlers.on) {
+      modeHandlers.on.call(this, workflow);
+    }
+
+    this.inspect([workflow]);
+  }
+
+  off(workflow) {
+    const mode = workflow.config.mode;
+    const modeHandlers = ScheduleModes.get(mode);
+
+    if (modeHandlers && modeHandlers.off) {
+      modeHandlers.off.call(this, workflow);
+    }
+
+    this.cache.delete(workflow.id);
+  }
+
+}
+
+exports.default = ScheduleTrigger;
+ScheduleTrigger.CacheRules = [// ({ enabled }) => enabled,
+({
+  config,
+  allExecuted
+}) => config.limit ? allExecuted < config.limit : true, ({
+  config
+}) => ['repeat', 'startsOn'].some(key => config[key]), nextInCycle, function (workflow, now) {
+  const mode = workflow.config.mode;
+  const modeHandlers = ScheduleModes.get(mode);
+  return modeHandlers.shouldCache.call(this, workflow, now);
+}];
+ScheduleTrigger.TriggerRules = [({
+  config,
+  allExecuted
+}) => config.limit ? allExecuted < config.limit : true, ({
+  config
+}) => ['repeat', 'startsOn'].some(key => config[key]), function (workflow, now) {
+  const repeat = workflow.config.repeat;
+
+  if (typeof repeat !== 'string') {
+    return true;
+  }
+
+  const currentDate = new Date(now);
+  currentDate.setMilliseconds(-1);
+  const timestamp = now.getTime();
+
+  const interval = _cronParser().default.parseExpression(repeat, {
+    currentDate
+  });
+
+  let next = interval.next();
+
+  if (next.getTime() === timestamp) {
+    return true;
+  }
+
+  return false;
+}];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/plugin-workflow",
-  "version": "0.7.0-alpha.9",
+  "version": "0.7.1-alpha.6",
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "licenses": [
@@ -9,20 +9,16 @@
       "url": "http://www.apache.org/licenses/LICENSE-2.0"
     }
   ],
-  "scripts": {
-    "build": "rimraf -rf lib esm dist && npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc --project tsconfig.build.json",
-    "build:esm": "tsc --project tsconfig.build.json --module es2015 --outDir esm"
-  },
   "dependencies": {
-    "@nocobase/actions": "0.7.0-alpha.9",
-    "@nocobase/database": "0.7.0-alpha.9",
-    "@nocobase/server": "0.7.0-alpha.9",
-    "@nocobase/utils": "0.7.0-alpha.9",
+    "@nocobase/actions": "0.7.1-alpha.6",
+    "@nocobase/database": "0.7.1-alpha.6",
+    "@nocobase/server": "0.7.1-alpha.6",
+    "@nocobase/utils": "0.7.1-alpha.6",
+    "cron-parser": "4.4.0",
     "json-templates": "^4.2.0"
   },
   "devDependencies": {
-    "@nocobase/test": "0.7.0-alpha.9"
+    "@nocobase/test": "0.7.1-alpha.6"
   },
-  "gitHead": "79d5b309fb92148162bfedfb7e304b4673faf568"
+  "gitHead": "b6f96c97020d278ae597bf05553442d7516b2216"
 }