gitlab-radiator 3.4.0 → 3.4.2

package/public/client.js.LICENSE.txt

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/**
+ * @license React
+ * react-dom.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * @license React
+ * scheduler.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */

package/src/app.js

@@ -1,100 +1,147 @@
-import {basicAuth} from './auth'
-import compression from 'compression'
-import {config} from './config'
-import express from 'express'
-import {fetchOfflineRunners} from './gitlab/runners'
-import http from 'http'
-import lessMiddleware from 'less-middleware'
-import os from 'os'
-import path from 'path'
-import socketIo from 'socket.io'
-import {update} from './gitlab'
-
-const cacheDir = path.join(os.tmpdir(), 'gitlab-radiator-css-cache')
-
-const app = express()
-const httpServer = http.Server(app)
-const socketIoServer = socketIo(httpServer)
+"use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _auth = require("./auth");
+var _compression = _interopRequireDefault(require("compression"));
+var _config = require("./config");
+var _express = _interopRequireDefault(require("express"));
+var _runners = require("./gitlab/runners");
+var _http = _interopRequireDefault(require("http"));
+var _lessMiddleware = _interopRequireDefault(require("less-middleware"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _socket = _interopRequireDefault(require("socket.io"));
+var _gitlab = require("./gitlab");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var cacheDir = _path.default.join(_os.default.tmpdir(), 'gitlab-radiator-css-cache');
+var app = (0, _express.default)();
+var httpServer = _http.default.Server(app);
+var socketIoServer = (0, _socket.default)(httpServer);
 if (process.env.NODE_ENV !== 'production') {
   // eslint-disable-next-line global-require
-  const {bindDevAssets} = require('./dev-assets')
-  bindDevAssets(app)
+  var _require = require('./dev-assets'),
+    bindDevAssets = _require.bindDevAssets;
+  bindDevAssets(app);
 }
-
-app.disable('x-powered-by')
-app.use(lessMiddleware(`${__dirname}/../public`, {
-    dest: cacheDir,
-    preprocess: {
-      less: (src) => {
-        let colorLess = ''
-        Object.keys(config.colors).forEach((stateName) => {
-          colorLess += `@${stateName}-color:${config.colors[stateName]};`
-        })
-        return src + colorLess
-      }
+app.disable('x-powered-by');
+app.use((0, _lessMiddleware.default)("".concat(__dirname, "/../public"), {
+  dest: cacheDir,
+  preprocess: {
+    less: src => {
+      var colorLess = '';
+      Object.keys(_config.config.colors).forEach(stateName => {
+        colorLess += "@".concat(stateName, "-color:").concat(_config.config.colors[stateName], ";");
+      });
+      return src + colorLess;
     }
   }
-))
-app.use(express.static(cacheDir))
-app.use(express.static(`${__dirname}/../public`))
-app.use(compression())
-app.use(basicAuth(config.auth))
-
-httpServer.listen(config.port, () => {
+}));
+app.use(_express.default.static(cacheDir));
+app.use(_express.default.static("".concat(__dirname, "/../public")));
+app.use((0, _compression.default)());
+app.use((0, _auth.basicAuth)(_config.config.auth));
+httpServer.listen(_config.config.port, () => {
   // eslint-disable-next-line no-console
-  console.log(`Listening on port *:${config.port}`)
-})
-
-const globalState = {
+  console.log("Listening on port *:".concat(_config.config.port));
+});
+var globalState = {
   projects: null,
   error: null,
-  zoom: config.zoom,
-  projectsOrder: config.projectsOrder,
-  columns: config.columns,
-  groupSuccessfulProjects: config.groupSuccessfulProjects
+  zoom: _config.config.zoom,
+  projectsOrder: _config.config.projectsOrder,
+  columns: _config.config.columns,
+  groupSuccessfulProjects: _config.config.groupSuccessfulProjects
+};
+socketIoServer.on('connection', socket => {
+  socket.emit('state', withDate(globalState));
+});
+function runUpdate() {
+  return _runUpdate.apply(this, arguments);
 }
-
-socketIoServer.on('connection', (socket) => {
-  socket.emit('state', withDate(globalState))
-})
-
-async function runUpdate() {
-  try {
-    globalState.projects = await update(config)
-    globalState.error = await errorIfRunnerOffline()
-    socketIoServer.emit('state', withDate(globalState))
-  } catch (error) {
-    // eslint-disable-next-line no-console
-    console.error(error.message)
-    globalState.error = `Failed to communicate with GitLab API: ${error.message}`
-    socketIoServer.emit('state', withDate(globalState))
-  }
-  setTimeout(runUpdate, config.interval)
+function _runUpdate() {
+  _runUpdate = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.prev = 0;
+            _context.next = 3;
+            return (0, _gitlab.update)(_config.config);
+          case 3:
+            globalState.projects = _context.sent;
+            _context.next = 6;
+            return errorIfRunnerOffline();
+          case 6:
+            globalState.error = _context.sent;
+            socketIoServer.emit('state', withDate(globalState));
+            _context.next = 15;
+            break;
+          case 10:
+            _context.prev = 10;
+            _context.t0 = _context["catch"](0);
+            // eslint-disable-next-line no-console
+            console.error(_context.t0.message);
+            globalState.error = "Failed to communicate with GitLab API: ".concat(_context.t0.message);
+            socketIoServer.emit('state', withDate(globalState));
+          case 15:
+            setTimeout(runUpdate, _config.config.interval);
+          case 16:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[0, 10]]);
+  }));
+  return _runUpdate.apply(this, arguments);
 }
-
-async function errorIfRunnerOffline() {
-  const offlineRunnersPerGitlab = await Promise.all(config.gitlabs.map(fetchOfflineRunners))
-  const {offline, totalCount} = offlineRunnersPerGitlab.reduce((acc, runner) => {
-    return {
-      offline: acc.offline.concat(runner.offline),
-      totalCount: acc.totalCount + runner.totalCount
-    }
-  }, {offline: [], totalCount: 0})
-
-  if (offline.length > 0) {
-    const names = offline.map(r => r.name).sort().join(', ')
-    const counts = offline.length === totalCount ? 'All' : `${offline.length}/${totalCount}`
-    return `${counts} runners offline: ${names}`
-  }
-  return null
+function errorIfRunnerOffline() {
+  return _errorIfRunnerOffline.apply(this, arguments);
 }
-
-runUpdate()
-
+function _errorIfRunnerOffline() {
+  _errorIfRunnerOffline = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+    var offlineRunnersPerGitlab, _offlineRunnersPerGit, offline, totalCount, names, counts;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return Promise.all(_config.config.gitlabs.map(_runners.fetchOfflineRunners));
+          case 2:
+            offlineRunnersPerGitlab = _context2.sent;
+            _offlineRunnersPerGit = offlineRunnersPerGitlab.reduce((acc, runner) => {
+              return {
+                offline: acc.offline.concat(runner.offline),
+                totalCount: acc.totalCount + runner.totalCount
+              };
+            }, {
+              offline: [],
+              totalCount: 0
+            }), offline = _offlineRunnersPerGit.offline, totalCount = _offlineRunnersPerGit.totalCount;
+            if (!(offline.length > 0)) {
+              _context2.next = 8;
+              break;
+            }
+            names = offline.map(r => r.name).sort().join(', ');
+            counts = offline.length === totalCount ? 'All' : "".concat(offline.length, "/").concat(totalCount);
+            return _context2.abrupt("return", "".concat(counts, " runners offline: ").concat(names));
+          case 8:
+            return _context2.abrupt("return", null);
+          case 9:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _errorIfRunnerOffline.apply(this, arguments);
+}
+runUpdate();
 function withDate(state) {
-  return {
-    ...state,
+  return _objectSpread(_objectSpread({}, state), {}, {
     now: Date.now()
-  }
-}
+  });
+}

package/src/auth.js

@@ -1,21 +1,29 @@
-import authenticate from 'basic-auth'
+"use strict";
 
-export function basicAuth(auth) {
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.basicAuth = basicAuth;
+var _basicAuth = _interopRequireDefault(require("basic-auth"));
+function basicAuth(auth) {
   if (!auth || !auth.username || !auth.password) {
     // eslint-disable-next-line no-console
-    console.log('No authentication configured')
-    return (req, res, next) => next()
+    console.log('No authentication configured');
+    return (req, res, next) => next();
   }
 
   // eslint-disable-next-line no-console
-  console.log('HTTP basic auth enabled')
+  console.log('HTTP basic auth enabled');
   return (req, res, next) => {
-    const {name, pass} = authenticate(req) || {}
+    var _ref = (0, _basicAuth.default)(req) || {},
+      name = _ref.name,
+      pass = _ref.pass;
     if (auth.username === name && auth.password === pass) {
-      next()
+      next();
     } else {
-      res.setHeader('WWW-Authenticate', 'Basic realm="gitlab-radiator"')
-      res.status(401).end()
+      res.setHeader('WWW-Authenticate', 'Basic realm="gitlab-radiator"');
+      res.status(401).end();
     }
-  }
-}
+  };
+}

package/src/config.js

@@ -1,43 +1,47 @@
-import assert from 'assert'
-import fs from 'fs'
-import os from 'os'
-import yaml from 'js-yaml'
+"use strict";
 
-const configFile = expandTilde(process.env.GITLAB_RADIATOR_CONFIG || '~/.gitlab-radiator.yml')
-const yamlContent = fs.readFileSync(configFile, 'utf8')
-export const config = validate(yaml.load(yamlContent))
-
-config.interval = Number(config.interval || 10) * 1000
-config.port = Number(config.port || 3000)
-config.zoom = Number(config.zoom || 1.0)
-config.columns = Number(config.columns || 1)
-config.groupSuccessfulProjects = config.groupSuccessfulProjects || false
-config.projectsOrder = config.projectsOrder || ['name']
-config.gitlabs = config.gitlabs.map((gitlab) => {
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.config = void 0;
+var _assert = _interopRequireDefault(require("assert"));
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _jsYaml = _interopRequireDefault(require("js-yaml"));
+var configFile = expandTilde(process.env.GITLAB_RADIATOR_CONFIG || '~/.gitlab-radiator.yml');
+var yamlContent = _fs.default.readFileSync(configFile, 'utf8');
+var config = validate(_jsYaml.default.load(yamlContent));
+exports.config = config;
+config.interval = Number(config.interval || 10) * 1000;
+config.port = Number(config.port || 3000);
+config.zoom = Number(config.zoom || 1.0);
+config.columns = Number(config.columns || 1);
+config.groupSuccessfulProjects = config.groupSuccessfulProjects || false;
+config.projectsOrder = config.projectsOrder || ['name'];
+config.gitlabs = config.gitlabs.map(gitlab => {
   return {
     url: gitlab.url,
     ignoreArchived: gitlab.ignoreArchived === undefined ? true : gitlab.ignoreArchived,
     maxNonFailedJobsVisible: Number(gitlab.maxNonFailedJobsVisible || 999999),
-    ca: gitlab.caFile && fs.existsSync(gitlab.caFile, 'utf-8') ? fs.readFileSync(gitlab.caFile) : undefined,
+    ca: gitlab.caFile && _fs.default.existsSync(gitlab.caFile, 'utf-8') ? _fs.default.readFileSync(gitlab.caFile) : undefined,
     'access-token': gitlab['access-token'] || process.env.GITLAB_ACCESS_TOKEN,
     projects: {
       excludePipelineStatus: (gitlab.projects || {}).excludePipelineStatus || [],
       include: (gitlab.projects || {}).include || '',
       exclude: (gitlab.projects || {}).exclude || ''
     }
-  }
-})
-config.colors = config.colors || {}
-
+  };
+});
+config.colors = config.colors || {};
 function expandTilde(path) {
-  return path.replace(/^~($|\/|\\)/, `${os.homedir()}$1`)
+  return path.replace(/^~($|\/|\\)/, "".concat(_os.default.homedir(), "$1"));
 }
-
 function validate(cfg) {
-  assert.ok(cfg.gitlabs, 'Mandatory gitlab properties missing from configuration file')
-  cfg.gitlabs.forEach((gitlab) => {
-    assert.ok(gitlab.url, 'Mandatory gitlab url missing from configuration file')
-    assert.ok(gitlab['access-token'] || process.env.GITLAB_ACCESS_TOKEN, 'Mandatory gitlab access token missing from configuration (and none present at GITLAB_ACCESS_TOKEN env variable)')
-  })
-  return cfg
-}
+  _assert.default.ok(cfg.gitlabs, 'Mandatory gitlab properties missing from configuration file');
+  cfg.gitlabs.forEach(gitlab => {
+    _assert.default.ok(gitlab.url, 'Mandatory gitlab url missing from configuration file');
+    _assert.default.ok(gitlab['access-token'] || process.env.GITLAB_ACCESS_TOKEN, 'Mandatory gitlab access token missing from configuration (and none present at GITLAB_ACCESS_TOKEN env variable)');
+  });
+  return cfg;
+}

package/src/gitlab/client.js

@@ -1,27 +1,38 @@
-import axios from 'axios'
-import https from 'https'
-import url from 'url'
+"use strict";
 
-export function gitlabRequest(path, params, gitlab) {
-  return lazyClient(gitlab).get(path, {params})
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gitlabRequest = gitlabRequest;
+var _axios = _interopRequireDefault(require("axios"));
+var _https = _interopRequireDefault(require("https"));
+var _url = _interopRequireDefault(require("url"));
+function gitlabRequest(path, params, gitlab) {
+  return lazyClient(gitlab).get(path, {
+    params
+  });
 }
-
-const clients = new Map()
-
+var clients = new Map();
 function lazyClient(gitlab) {
-  const gitlabUrl = gitlab.url
+  var gitlabUrl = gitlab.url;
   if (gitlabUrl === undefined) {
     // eslint-disable-next-line no-console
-    console.log('Got undefined url for ' + JSON.stringify(gitlab))
+    console.log('Got undefined url for ' + JSON.stringify(gitlab));
   }
   if (!clients.get(gitlabUrl)) {
-    const client = axios.create({
-        baseURL: url.resolve(gitlabUrl, '/api/v4/'),
-        headers: {'PRIVATE-TOKEN': gitlab['access-token']},
-        httpsAgent: new https.Agent({keepAlive: true, ca: gitlab.ca}),
-        timeout: 30 * 1000
-      })
-    clients.set(gitlabUrl, client)
+    var client = _axios.default.create({
+      baseURL: _url.default.resolve(gitlabUrl, '/api/v4/'),
+      headers: {
+        'PRIVATE-TOKEN': gitlab['access-token']
+      },
+      httpsAgent: new _https.default.Agent({
+        keepAlive: true,
+        ca: gitlab.ca
+      }),
+      timeout: 30 * 1000
+    });
+    clients.set(gitlabUrl, client);
   }
-  return clients.get(gitlabUrl)
-}
+  return clients.get(gitlabUrl);
+}

package/src/gitlab/index.js

@@ -1,53 +1,139 @@
-import _ from 'lodash'
-import {fetchLatestPipelines} from './pipelines'
-import {fetchProjects} from './projects'
+"use strict";
 
-export async function update(config) {
-  const projectsWithPipelines = await loadProjectsWithPipelines(config)
-  return projectsWithPipelines
-    .filter(project => project.pipelines.length > 0)
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.update = update;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _pipelines = require("./pipelines");
+var _projects = require("./projects");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function update(_x) {
+  return _update.apply(this, arguments);
 }
-
-async function loadProjectsWithPipelines(config) {
-  const allProjectsWithPipelines = []
-  await Promise.all(config.gitlabs.map(async (gitlab) => {
-    const projects = await fetchProjects(gitlab)
-    projects.forEach((project) => {
-      project.maxNonFailedJobsVisible = gitlab.maxNonFailedJobsVisible
-    })
-    const projectsWithPipelines = await Promise.all(projects.map(project => projectWithPipelines(project, gitlab)))
-    allProjectsWithPipelines.push(...projectsWithPipelines)
-  }))
-  return allProjectsWithPipelines
+function _update() {
+  _update = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(config) {
+    var projectsWithPipelines;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return loadProjectsWithPipelines(config);
+          case 2:
+            projectsWithPipelines = _context.sent;
+            return _context.abrupt("return", projectsWithPipelines.filter(project => project.pipelines.length > 0));
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _update.apply(this, arguments);
 }
-
-async function projectWithPipelines(project, config) {
-  const pipelines = filterOutEmpty(await fetchLatestPipelines(project.id, config))
-    .filter(excludePipelineStatusFilter(config))
-  const status = defaultBranchStatus(project, pipelines)
-  return {
-    ...project,
-    pipelines,
-    status
-  }
+function loadProjectsWithPipelines(_x2) {
+  return _loadProjectsWithPipelines.apply(this, arguments);
+}
+function _loadProjectsWithPipelines() {
+  _loadProjectsWithPipelines = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(config) {
+    var allProjectsWithPipelines;
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            allProjectsWithPipelines = [];
+            _context3.next = 3;
+            return Promise.all(config.gitlabs.map( /*#__PURE__*/function () {
+              var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(gitlab) {
+                var projects, projectsWithPipelines;
+                return _regenerator.default.wrap(function _callee2$(_context2) {
+                  while (1) {
+                    switch (_context2.prev = _context2.next) {
+                      case 0:
+                        _context2.next = 2;
+                        return (0, _projects.fetchProjects)(gitlab);
+                      case 2:
+                        projects = _context2.sent;
+                        projects.forEach(project => {
+                          project.maxNonFailedJobsVisible = gitlab.maxNonFailedJobsVisible;
+                        });
+                        _context2.next = 6;
+                        return Promise.all(projects.map(project => projectWithPipelines(project, gitlab)));
+                      case 6:
+                        projectsWithPipelines = _context2.sent;
+                        allProjectsWithPipelines.push.apply(allProjectsWithPipelines, (0, _toConsumableArray2.default)(projectsWithPipelines));
+                      case 8:
+                      case "end":
+                        return _context2.stop();
+                    }
+                  }
+                }, _callee2);
+              }));
+              return function (_x5) {
+                return _ref.apply(this, arguments);
+              };
+            }()));
+          case 3:
+            return _context3.abrupt("return", allProjectsWithPipelines);
+          case 4:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _loadProjectsWithPipelines.apply(this, arguments);
+}
+function projectWithPipelines(_x3, _x4) {
+  return _projectWithPipelines.apply(this, arguments);
+}
+function _projectWithPipelines() {
+  _projectWithPipelines = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(project, config) {
+    var pipelines, status;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.t0 = filterOutEmpty;
+            _context4.next = 3;
+            return (0, _pipelines.fetchLatestPipelines)(project.id, config);
+          case 3:
+            _context4.t1 = _context4.sent;
+            pipelines = (0, _context4.t0)(_context4.t1).filter(excludePipelineStatusFilter(config));
+            status = defaultBranchStatus(project, pipelines);
+            return _context4.abrupt("return", _objectSpread(_objectSpread({}, project), {}, {
+              pipelines,
+              status
+            }));
+          case 7:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _projectWithPipelines.apply(this, arguments);
 }
-
 function defaultBranchStatus(project, pipelines) {
-  return _(pipelines)
-    .filter({ref: project.default_branch})
-    .map('status')
-    .head()
+  return (0, _lodash.default)(pipelines).filter({
+    ref: project.default_branch
+  }).map('status').head();
 }
-
 function filterOutEmpty(pipelines) {
-  return pipelines.filter(pipeline => pipeline.stages)
+  return pipelines.filter(pipeline => pipeline.stages);
 }
-
 function excludePipelineStatusFilter(config) {
   return pipeline => {
     if (config.projects && config.projects.excludePipelineStatus) {
-      return !config.projects.excludePipelineStatus.includes(pipeline.status)
+      return !config.projects.excludePipelineStatus.includes(pipeline.status);
     }
-    return true
-  }
-}
+    return true;
+  };
+}