beads/internal/gitlab/client.go
Vishnu J a8a6c67413
Beads #6735: prevent duplicate GitLab sync on self-hosted URLs (#6736)
* fix(gitlab): recognize work-item URLs on the configured self-hosted host (GH#6735)

IsExternalRef required the substring "gitlab" in the URL, so self-hosted
instances without it were treated as unlinked and sync created duplicate
issues. Also accept issue/work-item/milestone URLs whose host (and base
path) match the configured gitlab.url; unrelated hosts stay rejected.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* docs(gitlab): record the self-hosted ref fix and correct the BaseURL contract

Maintainer review fixups for #6736. The review found no blocker and no major;
these are its two gate-impact minors plus the two nearby nits. No behavior
change: the only non-comment edits are in the test.

- CHANGELOG had no entry for a user-visible change to which external refs the
  GitLab tracker claims (6 of the 8 commits preceding the merge base touch it).
  The bullet names GH#6735 and the two limits a reader actually needs: matching
  is host-scoped, not project-scoped, and the host must be spelled the way
  GitLab emits it in web_url.

- Client.BaseURL was documented as "https://gitlab.com/api/v4". That example was
  already wrong before this PR -- buildURL appends DefaultAPIEndpoint itself, so
  the documented form doubles the suffix -- but onConfiguredHost now makes the
  web-root form load-bearing for ref identity, so a maintainer "fixing" a
  construction site to match the comment would silently restore the duplicate
  sync this PR fixes. WithEndpoint is that construction site: its doc said
  "custom API endpoint" while assigning BaseURL. It has no production caller,
  so both are doc-only corrections.

- onConfiguredHost now states the host-only match scope and the literal host
  comparison. Both reviewers asked for these to be documented rather than
  narrowed: keying the match on gitlab.project_path would drop self-hosted
  recognition exactly where it is least likely to be configured, since that
  key is optional and Init discards its load error.

- tracker_test: the milestone and shorthand rows are satisfied by the
  pre-existing "milestones" substring and glShorthandPattern arms, so they pass
  with onConfiguredHost deleted and overstated the table's coverage of the new
  predicate. They are now grouped and labeled as regression pins for those arms,
  and the two cases that do discriminate are added -- a scheme mismatch (claimed:
  only the host is compared) and a non-default port (not claimed when the ref
  omits it). Deleting `&& !t.onConfiguredHost(ref)` now fails 6 assertions, up
  from 4.

Validation: gofmt, git diff --check, go vet ./internal/gitlab/,
golangci-lint ./internal/gitlab/... (0 issues), go test ./internal/gitlab/...
and go test ./cmd/bd/ -run 'GitLab|Gitlab', plus the counterfactual run above.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
Co-authored-by: Julian Knutsen <julianknutsen@users.noreply.github.com>
2026-09-26 04:15:47 -07:00

720 lines
22 KiB
Go

// Package gitlab provides client and data types for the GitLab REST API.
package gitlab
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"math/rand/v2"
"net/http"
"net/url"
"strconv"
"time"
)
// NewClient creates a new GitLab client with the given token, base URL, and project ID.
func NewClient(token, baseURL, projectID string) *Client {
return &Client{
Token: token,
BaseURL: baseURL,
ProjectID: projectID,
HTTPClient: &http.Client{
Timeout: DefaultTimeout,
},
}
}
// WithGroupID returns a new client configured to fetch issues at the group level.
// When GroupID is set, FetchIssues and FetchIssuesSince use /groups/:id/issues
// instead of /projects/:id/issues. Issue creation still uses the project endpoint.
func (c *Client) WithGroupID(groupID string) *Client {
return &Client{
Token: c.Token,
BaseURL: c.BaseURL,
ProjectID: c.ProjectID,
GroupID: groupID,
HTTPClient: c.HTTPClient,
taskTypeID: c.taskTypeID,
}
}
// WithHTTPClient returns a new client configured to use the specified HTTP client.
// This is useful for testing or customizing timeouts and transport settings.
func (c *Client) WithHTTPClient(httpClient *http.Client) *Client {
return &Client{
Token: c.Token,
BaseURL: c.BaseURL,
ProjectID: c.ProjectID,
GroupID: c.GroupID,
HTTPClient: httpClient,
taskTypeID: c.taskTypeID,
}
}
// WithEndpoint returns a new client pointed at a different instance web root.
// This is useful for testing with mock servers or self-hosted GitLab instances.
// It sets BaseURL, so endpoint carries the same contract: the web root, without
// the /api/v4 suffix buildURL appends per request.
func (c *Client) WithEndpoint(endpoint string) *Client {
return &Client{
Token: c.Token,
BaseURL: endpoint,
ProjectID: c.ProjectID,
GroupID: c.GroupID,
HTTPClient: c.HTTPClient,
taskTypeID: c.taskTypeID,
}
}
// projectPath returns the URL-encoded project path for API calls.
// This handles both numeric IDs (e.g., "123") and path-based IDs (e.g., "group/project").
func (c *Client) projectPath() string {
return url.PathEscape(c.ProjectID)
}
// issuesBasePath returns the API path prefix for listing issues.
// When GroupID is set, returns /groups/:id/issues (group-level).
// Otherwise, returns /projects/:id/issues (project-level).
func (c *Client) issuesBasePath() string {
if c.GroupID != "" {
return "/groups/" + url.PathEscape(c.GroupID) + "/issues"
}
return "/projects/" + c.projectPath() + "/issues"
}
// buildURL constructs a full API URL from path and optional query parameters.
func (c *Client) buildURL(path string, params map[string]string) string {
u := c.BaseURL + DefaultAPIEndpoint + path
if len(params) > 0 {
values := url.Values{}
for k, v := range params {
values.Set(k, v)
}
u += "?" + values.Encode()
}
return u
}
// doRequest performs an HTTP request with authentication and retry logic.
func (c *Client) doRequest(ctx context.Context, method, urlStr string, body interface{}) ([]byte, http.Header, error) {
var reqBody io.Reader
if body != nil {
jsonBody, err := json.Marshal(body)
if err != nil {
return nil, nil, fmt.Errorf("failed to marshal request body: %w", err)
}
reqBody = bytes.NewReader(jsonBody)
}
var lastErr error
for attempt := 0; attempt <= MaxRetries; attempt++ {
// Reset body reader at top of loop so retries after network errors
// don't send empty bodies (the reader may be at EOF).
if body != nil {
jsonBody, err := json.Marshal(body)
if err != nil {
return nil, nil, fmt.Errorf("failed to marshal request body: %w", err)
}
reqBody = bytes.NewReader(jsonBody)
}
req, err := http.NewRequestWithContext(ctx, method, urlStr, reqBody)
if err != nil {
return nil, nil, fmt.Errorf("failed to create request: %w", err)
}
req.Header.Set("PRIVATE-TOKEN", c.Token)
req.Header.Set("Content-Type", "application/json")
resp, err := c.HTTPClient.Do(req)
if err != nil {
lastErr = fmt.Errorf("request failed (attempt %d/%d): %w", attempt+1, MaxRetries+1, err)
continue
}
// Limit response body to 50MB to prevent OOM from malformed responses.
const maxResponseSize = 50 * 1024 * 1024
respBody, err := io.ReadAll(io.LimitReader(resp.Body, maxResponseSize))
_ = resp.Body.Close() // Best effort: HTTP body close; connection may be reused regardless
if err != nil {
lastErr = fmt.Errorf("failed to read response (attempt %d/%d): %w", attempt+1, MaxRetries+1, err)
continue
}
if resp.StatusCode >= 200 && resp.StatusCode < 300 {
return respBody, resp.Header, nil
}
// Retry on rate-limiting and server errors with exponential backoff.
retriable := resp.StatusCode == http.StatusTooManyRequests ||
resp.StatusCode == http.StatusInternalServerError ||
resp.StatusCode == http.StatusBadGateway ||
resp.StatusCode == http.StatusServiceUnavailable ||
resp.StatusCode == http.StatusGatewayTimeout
if retriable {
delay := RetryDelay * time.Duration(1<<attempt)
useServerDelay := false
// Use Retry-After header if present (no jitter — respect server-mandated delay)
if retryAfter := resp.Header.Get("Retry-After"); retryAfter != "" {
if seconds, parseErr := strconv.Atoi(retryAfter); parseErr == nil {
delay = time.Duration(seconds) * time.Second
useServerDelay = true
}
}
// Only add jitter to our own exponential backoff, not server-mandated delays
if !useServerDelay {
if half := int64(delay / 2); half > 0 {
delay += time.Duration(rand.Int64N(half)) //nolint:gosec // G404: jitter for retry backoff does not need crypto rand
}
}
lastErr = fmt.Errorf("transient error %d (attempt %d/%d)", resp.StatusCode, attempt+1, MaxRetries+1)
select {
case <-ctx.Done():
return nil, nil, ctx.Err()
case <-time.After(delay):
continue
}
}
return nil, nil, fmt.Errorf("API error: %s (status %d)", string(respBody), resp.StatusCode)
}
return nil, nil, fmt.Errorf("max retries (%d) exceeded: %w", MaxRetries+1, lastErr)
}
// applyFilter adds IssueFilter fields as query parameters to the params map.
// ProjectID filtering is done client-side (not supported by GitLab API on group endpoints).
func applyFilter(params map[string]string, filter *IssueFilter) {
if filter == nil {
return
}
if filter.Labels != "" {
params["labels"] = filter.Labels
}
if filter.Milestone != "" {
params["milestone"] = filter.Milestone
}
if filter.Assignee != "" {
params["assignee_username"] = filter.Assignee
}
}
// filterByProject removes issues that don't match the filter's ProjectID.
// Returns the input slice unmodified if filter is nil or ProjectID is 0.
func filterByProject(issues []Issue, filter *IssueFilter) []Issue {
if filter == nil || filter.ProjectID == 0 {
return issues
}
filtered := make([]Issue, 0, len(issues))
for _, issue := range issues {
if issue.ProjectID == filter.ProjectID {
filtered = append(filtered, issue)
}
}
return filtered
}
// FetchIssues retrieves issues from GitLab with optional filtering by state and IssueFilter.
// state can be: "opened", "closed", or "all".
func (c *Client) FetchIssues(ctx context.Context, state string, filters ...*IssueFilter) ([]Issue, error) {
var filter *IssueFilter
if len(filters) > 0 {
filter = filters[0]
}
var allIssues []Issue
page := 1
for {
// Check for context cancellation at start of each iteration
select {
case <-ctx.Done():
return allIssues, ctx.Err()
default:
}
params := map[string]string{
"per_page": strconv.Itoa(MaxPageSize),
"page": strconv.Itoa(page),
}
if state != "" && state != "all" {
params["state"] = state
}
applyFilter(params, filter)
urlStr := c.buildURL(c.issuesBasePath(), params)
respBody, headers, err := c.doRequest(ctx, http.MethodGet, urlStr, nil)
if err != nil {
return nil, fmt.Errorf("failed to fetch issues: %w", err)
}
var issues []Issue
if err := json.Unmarshal(respBody, &issues); err != nil {
return nil, fmt.Errorf("failed to parse issues response: %w", err)
}
allIssues = append(allIssues, issues...)
// Check for next page
nextPage := headers.Get("X-Next-Page")
if nextPage == "" {
break
}
page++
// Guard against infinite pagination loops from malformed responses
if page > MaxPages {
return nil, fmt.Errorf("pagination limit exceeded: stopped after %d pages", MaxPages)
}
}
return filterByProject(allIssues, filter), nil
}
// FetchIssuesSince retrieves issues from GitLab that have been updated since the given time.
// This enables incremental sync by only fetching issues modified after the last sync.
func (c *Client) FetchIssuesSince(ctx context.Context, state string, since time.Time, filters ...*IssueFilter) ([]Issue, error) {
var filter *IssueFilter
if len(filters) > 0 {
filter = filters[0]
}
var allIssues []Issue
page := 1
sinceStr := since.UTC().Format(time.RFC3339)
for {
// Check for context cancellation at start of each iteration
select {
case <-ctx.Done():
return allIssues, ctx.Err()
default:
}
params := map[string]string{
"per_page": strconv.Itoa(MaxPageSize),
"page": strconv.Itoa(page),
"updated_after": sinceStr,
}
if state != "" && state != "all" {
params["state"] = state
}
applyFilter(params, filter)
urlStr := c.buildURL(c.issuesBasePath(), params)
respBody, headers, err := c.doRequest(ctx, http.MethodGet, urlStr, nil)
if err != nil {
return nil, fmt.Errorf("failed to fetch issues since %s: %w", sinceStr, err)
}
var issues []Issue
if err := json.Unmarshal(respBody, &issues); err != nil {
return nil, fmt.Errorf("failed to parse issues response: %w", err)
}
allIssues = append(allIssues, issues...)
// Check for next page
nextPage := headers.Get("X-Next-Page")
if nextPage == "" {
break
}
page++
// Guard against infinite pagination loops from malformed responses
if page > MaxPages {
return nil, fmt.Errorf("pagination limit exceeded: stopped after %d pages", MaxPages)
}
}
return filterByProject(allIssues, filter), nil
}
// CreateIssue creates a new issue in GitLab.
func (c *Client) CreateIssue(ctx context.Context, title, description string, labels []string) (*Issue, error) {
body := map[string]interface{}{
"title": title,
"description": description,
}
if len(labels) > 0 {
body["labels"] = labels
}
urlStr := c.buildURL("/projects/"+c.projectPath()+"/issues", nil)
respBody, _, err := c.doRequest(ctx, http.MethodPost, urlStr, body)
if err != nil {
return nil, fmt.Errorf("failed to create issue: %w", err)
}
var issue Issue
if err := json.Unmarshal(respBody, &issue); err != nil {
return nil, fmt.Errorf("failed to parse create response: %w", err)
}
return &issue, nil
}
// UpdateIssue updates an existing issue in GitLab.
func (c *Client) UpdateIssue(ctx context.Context, iid int, updates map[string]interface{}) (*Issue, error) {
urlStr := c.buildURL("/projects/"+c.projectPath()+"/issues/"+strconv.Itoa(iid), nil)
respBody, _, err := c.doRequest(ctx, http.MethodPut, urlStr, updates)
if err != nil {
return nil, fmt.Errorf("failed to update issue: %w", err)
}
var issue Issue
if err := json.Unmarshal(respBody, &issue); err != nil {
return nil, fmt.Errorf("failed to parse update response: %w", err)
}
return &issue, nil
}
// GetIssueLinks retrieves issue links for the specified issue IID.
func (c *Client) GetIssueLinks(ctx context.Context, iid int) ([]IssueLink, error) {
urlStr := c.buildURL("/projects/"+c.projectPath()+"/issues/"+strconv.Itoa(iid)+"/links", nil)
respBody, _, err := c.doRequest(ctx, http.MethodGet, urlStr, nil)
if err != nil {
return nil, fmt.Errorf("failed to get issue links: %w", err)
}
var links []IssueLink
if err := json.Unmarshal(respBody, &links); err != nil {
return nil, fmt.Errorf("failed to parse issue links response: %w", err)
}
return links, nil
}
// FetchIssueByIID retrieves a single issue by its project-scoped IID.
func (c *Client) FetchIssueByIID(ctx context.Context, iid int) (*Issue, error) {
urlStr := c.buildURL("/projects/"+c.projectPath()+"/issues/"+strconv.Itoa(iid), nil)
respBody, _, err := c.doRequest(ctx, http.MethodGet, urlStr, nil)
if err != nil {
return nil, fmt.Errorf("failed to fetch issue %d: %w", iid, err)
}
var issue Issue
if err := json.Unmarshal(respBody, &issue); err != nil {
return nil, fmt.Errorf("failed to parse issue response: %w", err)
}
return &issue, nil
}
// FetchMilestones retrieves milestones from the project with optional state filter.
// state can be: "active", "closed", or "" (all).
func (c *Client) FetchMilestones(ctx context.Context, state string) ([]Milestone, error) {
params := map[string]string{
"per_page": strconv.Itoa(MaxPageSize),
}
if state != "" {
params["state"] = state
}
urlStr := c.buildURL("/projects/"+c.projectPath()+"/milestones", params)
respBody, _, err := c.doRequest(ctx, http.MethodGet, urlStr, nil)
if err != nil {
return nil, fmt.Errorf("failed to fetch milestones: %w", err)
}
var milestones []Milestone
if err := json.Unmarshal(respBody, &milestones); err != nil {
return nil, fmt.Errorf("failed to parse milestones response: %w", err)
}
return milestones, nil
}
// FetchMilestoneByIID retrieves a single milestone by its project-scoped IID.
// Returns nil if no milestone matches the given IID.
func (c *Client) FetchMilestoneByIID(ctx context.Context, iid int) (*Milestone, error) {
params := map[string]string{
"iids[]": strconv.Itoa(iid),
}
urlStr := c.buildURL("/projects/"+c.projectPath()+"/milestones", params)
respBody, _, err := c.doRequest(ctx, http.MethodGet, urlStr, nil)
if err != nil {
return nil, fmt.Errorf("failed to fetch milestone by IID %d: %w", iid, err)
}
var milestones []Milestone
if err := json.Unmarshal(respBody, &milestones); err != nil {
return nil, fmt.Errorf("failed to parse milestone response: %w", err)
}
if len(milestones) == 0 {
return nil, nil
}
return &milestones[0], nil
}
// CreateMilestone creates a new milestone in GitLab.
func (c *Client) CreateMilestone(ctx context.Context, title, description string) (*Milestone, error) {
body := map[string]interface{}{
"title": title,
"description": description,
}
urlStr := c.buildURL("/projects/"+c.projectPath()+"/milestones", nil)
respBody, _, err := c.doRequest(ctx, http.MethodPost, urlStr, body)
if err != nil {
return nil, fmt.Errorf("failed to create milestone: %w", err)
}
var milestone Milestone
if err := json.Unmarshal(respBody, &milestone); err != nil {
return nil, fmt.Errorf("failed to parse milestone response: %w", err)
}
return &milestone, nil
}
// UpdateMilestone updates an existing milestone in GitLab.
func (c *Client) UpdateMilestone(ctx context.Context, milestoneID int, updates map[string]interface{}) (*Milestone, error) {
urlStr := c.buildURL("/projects/"+c.projectPath()+"/milestones/"+strconv.Itoa(milestoneID), nil)
respBody, _, err := c.doRequest(ctx, http.MethodPut, urlStr, updates)
if err != nil {
return nil, fmt.Errorf("failed to update milestone: %w", err)
}
var milestone Milestone
if err := json.Unmarshal(respBody, &milestone); err != nil {
return nil, fmt.Errorf("failed to parse milestone response: %w", err)
}
return &milestone, nil
}
// GraphQL support for work item hierarchy (Issue → Task parent-child).
// graphqlRequest executes a GraphQL query against the GitLab instance.
func (c *Client) graphqlRequest(ctx context.Context, query string, variables map[string]interface{}) (json.RawMessage, error) {
body := map[string]interface{}{"query": query}
if len(variables) > 0 {
body["variables"] = variables
}
// GraphQL endpoint is at /api/graphql (not under /api/v4/)
urlStr := c.BaseURL + "/api/graphql"
respBody, _, err := c.doRequest(ctx, http.MethodPost, urlStr, body)
if err != nil {
return nil, fmt.Errorf("GraphQL request failed: %w", err)
}
var result struct {
Data json.RawMessage `json:"data"`
Errors []struct {
Message string `json:"message"`
} `json:"errors"`
}
if err := json.Unmarshal(respBody, &result); err != nil {
return nil, fmt.Errorf("failed to parse GraphQL response: %w", err)
}
if len(result.Errors) > 0 {
return nil, fmt.Errorf("GraphQL error: %s", result.Errors[0].Message)
}
return result.Data, nil
}
// WorkItem represents a GitLab work item from the GraphQL API.
type WorkItem struct {
ID string `json:"id"` // Global ID (gid://gitlab/WorkItem/123)
IID string `json:"iid"` // Project-scoped ID
Title string `json:"title"`
Type string `json:"type"` // Work item type name
}
// defaultTaskTypeID is the fallback GID for older GitLab instances where the
// workItemTypes GraphQL query is unavailable.
const defaultTaskTypeID = "gid://gitlab/WorkItems::Type/5"
// getTaskWorkItemTypeID returns the GraphQL GID for the "Task" work item type.
// It queries the GitLab instance once per session and caches the result.
// Falls back to the hardcoded default if the query fails (e.g., older GitLab versions).
func (c *Client) getTaskWorkItemTypeID(ctx context.Context, projectPath string) string {
if c.taskTypeID != "" {
return c.taskTypeID
}
query := fmt.Sprintf(`{
project(fullPath: %q) {
workItemTypes(name: "Task") {
nodes { id }
}
}
}`, projectPath)
data, err := c.graphqlRequest(ctx, query, nil)
if err != nil {
c.taskTypeID = defaultTaskTypeID
return c.taskTypeID
}
var resp struct {
Project struct {
WorkItemTypes struct {
Nodes []struct {
ID string `json:"id"`
} `json:"nodes"`
} `json:"workItemTypes"`
} `json:"project"`
}
if err := json.Unmarshal(data, &resp); err != nil || len(resp.Project.WorkItemTypes.Nodes) == 0 {
c.taskTypeID = defaultTaskTypeID
return c.taskTypeID
}
c.taskTypeID = resp.Project.WorkItemTypes.Nodes[0].ID
return c.taskTypeID
}
// CreateTaskWorkItem creates a Task-type work item via GraphQL, optionally with a parent.
// parentGID is the global ID of the parent work item (e.g., "gid://gitlab/WorkItem/456").
// If parentGID is empty, creates a standalone task.
func (c *Client) CreateTaskWorkItem(ctx context.Context, projectPath, title, description, parentGID string) (*WorkItem, error) {
typeID := c.getTaskWorkItemTypeID(ctx, projectPath)
hierarchyPart := ""
if parentGID != "" {
hierarchyPart = fmt.Sprintf(`, hierarchyWidget: { parentId: %q }`, parentGID)
}
query := fmt.Sprintf(`mutation {
workItemCreate(input: {
projectPath: %q,
title: %q,
description: %q,
workItemTypeId: %q%s
}) {
errors
workItem { id iid title workItemType { name } webUrl }
}
}`, projectPath, title, description, typeID, hierarchyPart)
data, err := c.graphqlRequest(ctx, query, nil)
if err != nil {
return nil, err
}
var resp struct {
WorkItemCreate struct {
Errors []string `json:"errors"`
WorkItem *struct {
ID string `json:"id"`
IID string `json:"iid"`
Title string `json:"title"`
WebURL string `json:"webUrl"`
Type struct {
Name string `json:"name"`
} `json:"workItemType"`
} `json:"workItem"`
} `json:"workItemCreate"`
}
if err := json.Unmarshal(data, &resp); err != nil {
return nil, fmt.Errorf("failed to parse work item response: %w", err)
}
if len(resp.WorkItemCreate.Errors) > 0 {
return nil, fmt.Errorf("work item creation failed: %s", resp.WorkItemCreate.Errors[0])
}
if resp.WorkItemCreate.WorkItem == nil {
return nil, fmt.Errorf("work item creation returned nil")
}
wi := resp.WorkItemCreate.WorkItem
return &WorkItem{
ID: wi.ID,
IID: wi.IID,
Title: wi.Title,
Type: wi.Type.Name,
}, nil
}
// GetWorkItemGID looks up the global ID of a work item by its project-scoped IID.
func (c *Client) GetWorkItemGID(ctx context.Context, projectPath string, iid int) (string, error) {
query := fmt.Sprintf(`{
project(fullPath: %q) {
workItems(iid: "%d", first: 1) {
nodes { id }
}
}
}`, projectPath, iid)
data, err := c.graphqlRequest(ctx, query, nil)
if err != nil {
return "", err
}
var resp struct {
Project struct {
WorkItems struct {
Nodes []struct {
ID string `json:"id"`
} `json:"nodes"`
} `json:"workItems"`
} `json:"project"`
}
if err := json.Unmarshal(data, &resp); err != nil {
return "", fmt.Errorf("failed to parse work item GID response: %w", err)
}
if len(resp.Project.WorkItems.Nodes) == 0 {
return "", fmt.Errorf("work item with IID %d not found", iid)
}
return resp.Project.WorkItems.Nodes[0].ID, nil
}
// ListProjects retrieves projects accessible to the authenticated user.
func (c *Client) ListProjects(ctx context.Context) ([]Project, error) {
params := map[string]string{
"membership": "true",
"per_page": "100",
}
urlStr := c.buildURL("/projects", params)
respBody, _, err := c.doRequest(ctx, http.MethodGet, urlStr, nil)
if err != nil {
return nil, fmt.Errorf("failed to list projects: %w", err)
}
var projects []Project
if err := json.Unmarshal(respBody, &projects); err != nil {
return nil, fmt.Errorf("failed to parse projects response: %w", err)
}
return projects, nil
}
// CreateIssueLink creates a link between two issues in the SAME project.
// Cross-project links are not supported by this function; attempting to link
// issues from different projects will result in an error from the GitLab API.
// linkType can be: "relates_to", "blocks", or "is_blocked_by".
func (c *Client) CreateIssueLink(ctx context.Context, sourceIID, targetIID int, linkType string) (*IssueLink, error) {
body := map[string]interface{}{
"target_project_id": c.ProjectID,
"target_issue_iid": targetIID,
"link_type": linkType,
}
urlStr := c.buildURL("/projects/"+c.projectPath()+"/issues/"+strconv.Itoa(sourceIID)+"/links", nil)
respBody, _, err := c.doRequest(ctx, http.MethodPost, urlStr, body)
if err != nil {
return nil, fmt.Errorf("failed to create issue link: %w", err)
}
var link IssueLink
if err := json.Unmarshal(respBody, &link); err != nil {
return nil, fmt.Errorf("failed to parse issue link response: %w", err)
}
return &link, nil
}