gitlab-radiator 4.4.5 → 5.1.0

package/src/gitlab/pipelines.js

@@ -1,119 +1,125 @@
-import _ from 'lodash'
-import {gitlabRequest} from './client.js'
-
-export async function fetchLatestPipelines(projectId, gitlab) {
-  const pipelines = await fetchLatestAndMasterPipeline(projectId, gitlab)
-
-  const pipelinesWithStages = []
-  for (const {id, ref, status} of pipelines) {
-    const {commit, stages} = await fetchJobs(projectId, id, gitlab)
-    const downstreamStages = await fetchDownstreamJobs(projectId, id, gitlab)
-    pipelinesWithStages.push({
-      id,
-      ref,
-      status,
-      commit,
-      stages: stages.concat(downstreamStages)
-    })
-  }
-  return pipelinesWithStages
+import { gitlabRequest } from "./client.js";
+export async function fetchLatestPipelines(projectId, gitlab, prioritizeRunningPipelines) {
+    const pipelines = await fetchLatestAndMasterPipeline(projectId, gitlab, prioritizeRunningPipelines);
+    const pipelinesWithStages = [];
+    for (const { id, ref, status } of pipelines) {
+        const { commit, stages } = await fetchJobs(projectId, id, gitlab);
+        const downstreamStages = await fetchDownstreamJobs(projectId, id, gitlab);
+        pipelinesWithStages.push({
+            id,
+            ref,
+            status,
+            commit,
+            stages: stages.concat(downstreamStages)
+        });
+    }
+    return pipelinesWithStages;
 }
-
- 
-async function fetchLatestAndMasterPipeline(projectId, config) {
-  const pipelines = await fetchPipelines(projectId, config, {per_page: 100})
-  if (pipelines.length === 0) {
-    return []
-  }
-  const latestPipeline = _.take(pipelines, 1)
-  if (latestPipeline[0].ref === 'master') {
-    return latestPipeline
-  }
-  const latestMasterPipeline = _(pipelines).filter({ref: 'master'}).take(1).value()
-  if (latestMasterPipeline.length > 0) {
-    return latestPipeline.concat(latestMasterPipeline)
-  }
-  const masterPipelines = await fetchPipelines(projectId, config, {per_page: 50, ref: 'master'})
-  return latestPipeline.concat(_.take(masterPipelines, 1))
+async function fetchLatestAndMasterPipeline(projectId, gitlab, prioritizeRunningPipelines) {
+    const options = {
+        per_page: 100,
+        ...(gitlab.branch ? { ref: gitlab.branch } : {})
+    };
+    const pipelines = await fetchPipelines(projectId, gitlab, options);
+    if (pipelines.length === 0) {
+        return [];
+    }
+    const runningPipelines = pipelines.filter(pipeline => pipeline.status === 'running');
+    if (runningPipelines.length > 1 && prioritizeRunningPipelines) {
+        return runningPipelines;
+    }
+    const latestPipeline = pipelines.slice(0, 1);
+    if (latestPipeline[0].ref === 'master') {
+        return latestPipeline;
+    }
+    const latestMasterPipeline = pipelines.filter(p => p.ref === 'master').slice(0, 1);
+    if (latestMasterPipeline.length > 0) {
+        return latestPipeline.concat(latestMasterPipeline);
+    }
+    const masterPipelines = await fetchPipelines(projectId, gitlab, { per_page: 50, ref: 'master' });
+    return latestPipeline.concat(masterPipelines.slice(0, 1));
 }
-
-async function fetchPipelines(projectId, config, options) {
-  const {data: pipelines} = await gitlabRequest(`/projects/${projectId}/pipelines`, options, config)
-  return pipelines.filter(pipeline => pipeline.status !== 'skipped')
+async function fetchPipelines(projectId, gitlab, params) {
+    const { data: pipelines } = await gitlabRequest(`/projects/${projectId}/pipelines`, params, gitlab);
+    return pipelines.filter(pipeline => pipeline.status !== 'skipped');
 }
-
-async function fetchDownstreamJobs(projectId, pipelineId, config) {
-  const {data: gitlabBridgeJobs} = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/bridges`, {per_page: 100}, config)
-  const childPipelines = gitlabBridgeJobs.filter(bridge => bridge.downstream_pipeline !== null && bridge.downstream_pipeline.status !== 'skipped')
-
-  const downstreamStages = []
-  for(const childPipeline of childPipelines) {
-    const {stages} = await fetchJobs(childPipeline.downstream_pipeline.project_id, childPipeline.downstream_pipeline.id, config)
-    downstreamStages.push(stages.map(stage => ({
-      ...stage,
-      name: `${childPipeline.stage}:${stage.name}`
-    })))
-  }
-  return downstreamStages.flat()
+async function fetchDownstreamJobs(projectId, pipelineId, gitlab) {
+    const { data: gitlabBridgeJobs } = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/bridges`, { per_page: 100 }, gitlab);
+    const childPipelines = gitlabBridgeJobs.filter((bridge) => bridge.downstream_pipeline !== null && bridge.downstream_pipeline.status !== 'skipped');
+    const downstreamStages = [];
+    for (const childPipeline of childPipelines) {
+        const { stages } = await fetchJobs(childPipeline.downstream_pipeline.project_id, childPipeline.downstream_pipeline.id, gitlab);
+        downstreamStages.push(stages.map((stage) => ({
+            ...stage,
+            name: `${childPipeline.stage}:${stage.name}`
+        })));
+    }
+    return downstreamStages.flat();
 }
-
-async function fetchJobs(projectId, pipelineId, config) {
-  const {data: gitlabJobs} = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/jobs?include_retried=true`, {per_page: 100}, config)
-  if (gitlabJobs.length === 0) {
-    return {commit: undefined, stages: []}
-  }
-
-  const commit = findCommit(gitlabJobs)
-  const stages = _(gitlabJobs)
-    .map(job => ({
-      id: job.id,
-      status: job.status,
-      stage: job.stage,
-      name: job.name,
-      startedAt: job.started_at,
-      finishedAt: job.finished_at,
-      url: job.web_url
+async function fetchJobs(projectId, pipelineId, gitlab) {
+    const { data: gitlabJobs } = await gitlabRequest(`/projects/${projectId}/pipelines/${pipelineId}/jobs?include_retried=true`, { per_page: 100 }, gitlab);
+    if (gitlabJobs.length === 0) {
+        return { commit: null, stages: [] };
+    }
+    const commit = findCommit(gitlabJobs);
+    // Map jobs and sort by id
+    const mappedJobs = gitlabJobs
+        .map(job => ({
+        id: job.id,
+        status: job.status,
+        stage: job.stage,
+        name: job.name,
+        startedAt: job.started_at,
+        finishedAt: job.finished_at,
+        url: job.web_url
     }))
-    .orderBy('id')
-    .groupBy('stage')
-    .mapValues(mergeRetriedJobs)
-    .mapValues(cleanup)
-    .toPairs()
-    .map(([name, jobs]) => ({name, jobs: _.sortBy(jobs, 'name')}))
-    .value()
-
-  return {
-    commit,
-    stages
-  }
+        .sort((a, b) => a.id - b.id);
+    // Group by stage
+    const jobsByStage = new Map();
+    for (const job of mappedJobs) {
+        const stageJobs = jobsByStage.get(job.stage) || [];
+        stageJobs.push(job);
+        jobsByStage.set(job.stage, stageJobs);
+    }
+    // Convert to stages array
+    const stages = Array.from(jobsByStage.entries()).map(([name, jobs]) => ({
+        name,
+        jobs: mergeRetriedJobs(removeStageProperty(jobs)).sort(byName)
+    }));
+    return {
+        commit,
+        stages
+    };
+}
+function byName(a, b) {
+    return a.name.localeCompare(b.name);
 }
-
 function findCommit(jobs) {
-  const [job] = jobs.filter(j => j.commit)
-  if (!job) {
-    return null
-  }
-  return {
-    title: job.commit.title,
-    author: job.commit.author_name
-  }
+    const [job] = jobs.filter(j => j.commit);
+    if (!job || !job.commit) {
+        return null;
+    }
+    return {
+        title: job.commit.title,
+        author: job.commit.author_name
+    };
 }
-
 function mergeRetriedJobs(jobs) {
-  return jobs.reduce((mergedJobs, job) => {
-    const index = mergedJobs.findIndex(mergedJob => mergedJob.name === job.name)
-    if (index >= 0) {
-      mergedJobs[index] = job
-    } else {
-      mergedJobs.push(job)
-    }
-    return mergedJobs
-  }, [])
+    return jobs.reduce((mergedJobs, job) => {
+        const index = mergedJobs.findIndex(mergedJob => mergedJob.name === job.name);
+        if (index >= 0) {
+            mergedJobs[index] = job;
+        }
+        else {
+            mergedJobs.push(job);
+        }
+        return mergedJobs;
+    }, []);
 }
-
-function cleanup(jobs) {
-  return _(jobs)
-    .map(job => _.omitBy(job, _.isNull))
-    .map(job => _.omit(job, 'stage'))
-    .value()
+function removeStageProperty(jobs) {
+    return jobs.map(job => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { stage, ...rest } = job;
+        return rest;
+    });
 }

package/src/gitlab/projects.js

@@ -1,73 +1,65 @@
-import {gitlabRequest} from './client.js'
-
+import { gitlabRequest } from "./client.js";
 export async function fetchProjects(gitlab) {
-  const projects = await fetchOwnProjects(gitlab)
-  return projects
-    // Ignore projects for which CI/CD is not enabled
-    .filter(project => project.jobs_enabled)
-    .map(projectMapper)
-    .filter(includeRegexFilter(gitlab))
-    .filter(excludeRegexFilter(gitlab))
-    .filter(archivedFilter(gitlab))
+    const projects = await fetchOwnProjects(gitlab);
+    return projects
+        // Ignore projects for which CI/CD is not enabled
+        .filter(project => project.jobs_enabled)
+        .map(projectMapper)
+        .filter(includeRegexFilter(gitlab))
+        .filter(excludeRegexFilter(gitlab))
+        .filter(archivedFilter(gitlab));
 }
-
 async function fetchOwnProjects(gitlab) {
-  const projects = []
-  const SAFETY_MAX_PAGE = 10
-  for (let page = 1; page <= SAFETY_MAX_PAGE; page += 1) {
-     
-    const {data, headers} = await gitlabRequest('/projects', {page, per_page: 100, membership: true}, gitlab)
-    projects.push(data)
-    if (data.length === 0 || !headers['x-next-page']) {
-      break
+    const projects = [];
+    const SAFETY_MAX_PAGE = 10;
+    for (let page = 1; page <= SAFETY_MAX_PAGE; page += 1) {
+        const { data, headers } = await gitlabRequest('/projects', { page, per_page: 100, membership: true }, gitlab);
+        projects.push(...data);
+        if (data.length === 0 || !headers['x-next-page']) {
+            break;
+        }
     }
-  }
-  return projects.flat()
+    return projects;
 }
-
 function projectMapper(project) {
-  return {
-    id: project.id,
-    name: project.path_with_namespace,
-    nameWithoutNamespace: project.path,
-    group: getGroupName(project),
-    archived: project.archived,
-    default_branch: project.default_branch || 'master',
-    url: project.web_url,
-    tags: (project.tag_list || []).map(t => t.toLowerCase())
-  }
+    return {
+        id: project.id,
+        name: project.path_with_namespace,
+        nameWithoutNamespace: project.path,
+        group: getGroupName(project),
+        archived: project.archived,
+        default_branch: project.default_branch || 'master',
+        url: project.web_url,
+        topics: (project.topics || []).map((t) => t.toLowerCase())
+    };
 }
-
 function getGroupName(project) {
-  const pathWithNameSpace = project.path_with_namespace
-  return pathWithNameSpace.split('/')[0]
+    const pathWithNameSpace = project.path_with_namespace;
+    return pathWithNameSpace.split('/')[0];
 }
-
-function includeRegexFilter(config) {
-  return project => {
-    if (config.projects && config.projects.include) {
-      const includeRegex = new RegExp(config.projects.include, "i")
-      return includeRegex.test(project.name)
-    }
-    return true
-  }
+function includeRegexFilter(gitlab) {
+    return (project) => {
+        if (gitlab.projects?.include) {
+            const includeRegex = new RegExp(gitlab.projects.include, "i");
+            return includeRegex.test(project.name);
+        }
+        return true;
+    };
 }
-
-function excludeRegexFilter(config) {
-  return project => {
-    if (config.projects && config.projects.exclude) {
-      const excludeRegex = new RegExp(config.projects.exclude, "i")
-      return !excludeRegex.test(project.name)
-    }
-    return true
-  }
+function excludeRegexFilter(gitlab) {
+    return (project) => {
+        if (gitlab.projects?.exclude) {
+            const excludeRegex = new RegExp(gitlab.projects.exclude, "i");
+            return !excludeRegex.test(project.name);
+        }
+        return true;
+    };
 }
-
-function archivedFilter(config) {
-  return project => {
-    if (config.ignoreArchived) {
-      return !project.archived
-    }
-    return true
-  }
+function archivedFilter(gitlab) {
+    return (project) => {
+        if (gitlab.ignoreArchived) {
+            return !project.archived;
+        }
+        return true;
+    };
 }

package/src/gitlab/runners.js

@@ -1,18 +1,23 @@
-import {gitlabRequest} from './client.js'
-
+import { gitlabRequest } from "./client.js";
 export async function fetchOfflineRunners(gitlab) {
-  const runners = await fetchRunners(gitlab)
-  const offline = runners.filter(r => r.status === 'offline')
-  return {
-    offline,
-    totalCount: runners.length
-  }
+    if (gitlab.offlineRunners === 'none') {
+        return {
+            offline: [],
+            totalCount: 0
+        };
+    }
+    const runners = await fetchRunners(gitlab);
+    const offline = runners.filter(r => r.status === 'offline');
+    return {
+        offline,
+        totalCount: runners.length
+    };
 }
-
 async function fetchRunners(gitlab) {
-  const {data: runners} = await gitlabRequest('/runners', {}, gitlab)
-  return runners.map(r => ({
-    name: r.description || r.id,
-    status: r.status
-  }))
+    const runnersApi = gitlab.offlineRunners === 'all' ? '/runners/all' : '/runners';
+    const { data: runners } = await gitlabRequest(runnersApi, null, gitlab);
+    return runners.map(r => ({
+        name: r.description || r.id.toString(),
+        status: r.status
+    }));
 }

package/src/less.js

@@ -1,26 +1,28 @@
-import {config} from './config.js'
-import fs from 'fs'
-import less from 'less'
-import path from 'path'
-
-const filename = path.join('public', 'client.less')
-
-export async function serveLessAsCss(req, res) {
-  try {
-    const source = await fs.promises.readFile(filename, 'utf-8')
-    const {css} = await less.render(withColorOverrides(source), {filename})
-    res.setHeader('content-type', 'text/css')
-    res.send(css)
-  } catch (err) {
-    console.error('Failed to render client.less', err)
-    res.sendStatus(500)
-  }
+import fs from 'fs';
+import less from 'less';
+import path from 'path';
+import { config } from "./config.js";
+const filename = path.join('public', 'client.less');
+export async function serveLessAsCss(_req, res) {
+    try {
+        const source = await fs.promises.readFile(filename, 'utf-8');
+        const { css } = await less.render(withColorOverrides(source), { filename });
+        res.setHeader('content-type', 'text/css');
+        res.send(css);
+    }
+    catch (err) {
+        console.error('Failed to render client.less', err);
+        res.sendStatus(500);
+    }
 }
-
 function withColorOverrides(source) {
-  let colorLess = ''
-  Object.keys(config.colors).forEach((stateName) => {
-    colorLess += `@${stateName}-color:${config.colors[stateName]};`
-  })
-  return source + colorLess
+    const { colors } = config;
+    if (!colors) {
+        return source;
+    }
+    let colorLess = '';
+    Object.keys(colors).forEach((stateName) => {
+        colorLess += `@${stateName}-color:${colors[stateName]};`;
+    });
+    return source + colorLess;
 }

package/src/tsconfig.build.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../../src/app.ts","../../src/auth.ts","../../src/config.ts","../../src/dev-assets.ts","../../src/less.ts","../../src/common/gitlab-types.d.ts","../../src/gitlab/client.ts","../../src/gitlab/index.ts","../../src/gitlab/pipelines.ts","../../src/gitlab/projects.ts","../../src/gitlab/runners.ts"],"version":"5.9.3"}