Files
shields/services/github/github-issue-detail.service.js
T
jNulljandPierre-Yves Bigourdan 28839b2502 add not-planned and duplicate to issue state to [GithubIssueDetail] (#11666)
* add not-planned and duplicate to issue state to [GithubIssueDetail]

Fixes GitHub issues/PRs - Support the "not planned" state
Fixes #11662

* fix: replace underscore with space in state reason response transformation

* fix: tests after not_planed replaced by not planned

* fix: update issue state color key from not_planned to not planned

* improve testing, forever closed

Co-authored-by: Pierre-Yves Bigourdan <10694593+PyvesB@users.noreply.github.com>

* remove redundent condition

---------

Co-authored-by: Pierre-Yves Bigourdan <10694593+PyvesB@users.noreply.github.com>
2026-02-08 19:12:18 +00:00

254 lines
6.3 KiB
JavaScript

import Joi from 'joi'
import { nonNegativeInteger } from '../validators.js'
import { metric } from '../text-formatters.js'
import { renderDateBadge } from '../date.js'
import { InvalidResponse, pathParams } from '../index.js'
import { GithubAuthV3Service } from './github-auth-service.js'
import {
documentation,
httpErrorsFor,
issueStateColor,
commentsColor,
} from './github-helpers.js'
const commonSchemaFields = {
number: nonNegativeInteger,
pull_request: Joi.any(),
}
const stateMap = {
schema: Joi.object({
...commonSchemaFields,
state: Joi.equal('open', 'closed').required(),
state_reason: Joi.string().allow(null), // only for issues
merged_at: Joi.string().allow(null),
}).required(),
transform: ({ json }) => {
const mergedAt = json.pull_request?.merged_at ?? json.merged_at
const stateWithReason =
json.state_reason === 'not_planned' || json.state_reason === 'duplicate'
? json.state_reason.replace('_', ' ')
: json.state
return {
state: stateWithReason,
merged: mergedAt != null,
}
},
render: ({ value, isPR, number }) => {
const state = value.state
const label = `${isPR ? 'pull request' : 'issue'} ${number}`
if (!isPR || state === 'open') {
return {
color: issueStateColor(state),
label,
message: state,
}
} else if (value.merged) {
return {
label,
message: 'merged',
color: 'blueviolet',
}
} else
return {
label,
message: 'rejected',
color: 'red',
}
},
}
const titleMap = {
schema: Joi.object({
...commonSchemaFields,
title: Joi.string().required(),
}).required(),
transform: ({ json }) => json.title,
render: ({ value, isPR, number }) => ({
label: `${isPR ? 'pull request' : 'issue'} ${number}`,
message: value,
}),
}
const authorMap = {
schema: Joi.object({
...commonSchemaFields,
user: Joi.object({
login: Joi.string().required(),
}).required(),
}).required(),
transform: ({ json }) => json.user.login,
render: ({ value }) => ({
label: 'author',
message: value,
}),
}
const labelMap = {
schema: Joi.object({
...commonSchemaFields,
labels: Joi.array()
.items(
Joi.object({
name: Joi.string().required(),
color: Joi.string().required(),
}),
)
.required(),
}).required(),
transform: ({ json }) => {
if (json.labels.length === 0) {
throw new InvalidResponse({ prettyMessage: 'no labels found' })
}
return {
names: json.labels.map(l => l.name),
colors: json.labels.map(l => l.color),
}
},
render: ({ value }) => {
let color
if (value.colors.length === 1) {
color = value.colors[0]
}
return {
color,
label: 'label',
message: value.names.join(' | '),
}
},
}
const commentsMap = {
schema: Joi.object({
...commonSchemaFields,
comments: nonNegativeInteger,
}).required(),
transform: ({ json }) => json.comments,
render: ({ value }) => ({
color: commentsColor(value),
label: 'comments',
message: metric(value),
}),
}
const ageUpdateMap = {
schema: Joi.object({
...commonSchemaFields,
created_at: Joi.date().required(),
updated_at: Joi.date().required(),
}).required(),
transform: ({ json, property }) =>
property === 'age' ? json.created_at : json.updated_at,
render: ({ property, value }) => {
const label = property === 'age' ? 'created' : 'updated'
return {
...renderDateBadge(value),
label,
}
},
}
const milestoneMap = {
schema: Joi.object({
...commonSchemaFields,
milestone: Joi.object({
title: Joi.string().required(),
}).allow(null),
}).required(),
transform: ({ json }) => {
if (!json.milestone) {
throw new InvalidResponse({ prettyMessage: 'no milestone' })
}
return json.milestone.title
},
render: ({ value }) => ({
label: 'milestone',
message: value,
color: 'informational',
}),
}
const propertyMap = {
state: stateMap,
title: titleMap,
author: authorMap,
label: labelMap,
comments: commentsMap,
age: ageUpdateMap,
'last-update': ageUpdateMap,
milestone: milestoneMap,
}
export default class GithubIssueDetail extends GithubAuthV3Service {
static category = 'issue-tracking'
static route = {
base: 'github',
pattern:
':issueKind(issues|pulls)/detail/:property(state|title|author|label|comments|age|last-update|milestone)/:user/:repo/:number([0-9]+)',
}
static openApi = {
'/github/{issueKind}/detail/{property}/{user}/{repo}/{number}': {
get: {
summary: 'GitHub issue/pull request detail',
description: documentation,
parameters: pathParams(
{
name: 'issueKind',
example: 'issues',
schema: { type: 'string', enum: this.getEnum('issueKind') },
},
{
name: 'property',
example: 'state',
schema: { type: 'string', enum: this.getEnum('property') },
},
{
name: 'user',
example: 'badges',
},
{
name: 'repo',
example: 'shields',
},
{
name: 'number',
example: '979',
},
),
},
},
}
static defaultBadgeData = {
label: 'issue/pull request',
color: 'informational',
}
static render({ property, value, isPR, number }) {
return propertyMap[property].render({ property, value, isPR, number })
}
async fetch({ issueKind, property, user, repo, number }) {
return this._requestJson({
url: `/repos/${user}/${repo}/${issueKind}/${number}`,
schema: propertyMap[property].schema,
httpErrors: httpErrorsFor('issue, pull request or repo not found'),
})
}
transform({ json, property, issueKind }) {
const value = propertyMap[property].transform({ json, property })
const isPR = 'pull_request' in json || issueKind === 'pulls'
return { value, isPR }
}
async handle({ issueKind, property, user, repo, number }) {
const json = await this.fetch({ issueKind, property, user, repo, number })
const { value, isPR } = this.transform({ json, property, issueKind })
return this.constructor.render({ property, value, isPR, number })
}
}