Gitlink
/
gitlink-cli
0
0
Fork 49
Code Issues Pull Requests 11 Packages Projects Releases 10 Wiki Activity

Merge PR #281: fix(api): 补齐单次请求模板变量与请求头支持 

# Conflicts:
#	cmd/api/api.go
#	cmd/api/api_test.go
This commit is contained in:
wbtiger 2026-07-14 22:49:56 +08:00
parent 901f93be08 ac211ac4e9
commit ae5b27687f
6 changed files with 342 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
README.md
View File

@ -677,6 +677,16 @@ Get-Content issue.json | gitlink-cli api POST /Gitlink/forgeplus/issues --body-s
# With query parameters
gitlink-cli api GET /Gitlink/forgeplus/commits --query 'page=1&limit=5'
# Reuse --owner/--repo placeholders in a single request
gitlink-cli api GET /:owner/:repo/issues --owner Gitlink --repo gitlink-cli --query 'page=1&limit=5'
# Render one-off template variables in path, query, body, and headers
gitlink-cli api POST /{{owner}}/{{repo}}/issues/{{number}}/journals \
--var owner=Gitlink --var repo=gitlink-cli --var number=42 --var actor=codex \
--query 'notify={{actor}}' \
--header 'X-Actor: {{actor}}' \
--body '{"notes":"handled by {{actor}}"}'
```
## Global Parameters

10
README.zh-CN.md
View File

@ -849,6 +849,16 @@ Get-Content issue.json | gitlink-cli api POST /Gitlink/forgeplus/issues --body-s
# 带查询参数
gitlink-cli api GET /Gitlink/forgeplus/commits --query 'page=1&limit=5'
# 鍗曟璇锋眰涓洿鎺ュ鐢?--owner / --repo 鍗犱綅绗?
gitlink-cli api GET /:owner/:repo/issues --owner Gitlink --repo gitlink-cli --query 'page=1&limit=5'
# 鍦?path / query / body / header 涓覆鏌撲竴娆℃€фā鏉垮彉閲?
gitlink-cli api POST /{{owner}}/{{repo}}/issues/{{number}}/journals \
--var owner=Gitlink --var repo=gitlink-cli --var number=42 --var actor=codex \
--query 'notify={{actor}}' \
--header 'X-Actor: {{actor}}' \
--body '{"notes":"handled by {{actor}}"}'
```
### Shell 自动补全

259
cmd/api/api.go
View File

@ -5,14 +5,17 @@ import (
"errors"
"fmt"
"io"
"net/http"
"net/url"
"os"
"sort"
"strings"
"github.com/spf13/cobra"
"github.com/gitlink-org/gitlink-cli/cmd/cmdutil"
"github.com/gitlink-org/gitlink-cli/internal/client"
gitcontext "github.com/gitlink-org/gitlink-cli/internal/context"
"github.com/gitlink-org/gitlink-cli/internal/i18n"
"github.com/gitlink-org/gitlink-cli/internal/output"
)
@ -29,6 +32,7 @@ func NewAPICmd(translators ...*i18n.Translator) *cobra.Command {
Example: ` gitlink-cli api GET /users/me
gitlink-cli api GET /projects --query 'page=1&limit=10'
gitlink-cli api POST /:owner/:repo/issues --body '{"subject":"Bug","description":"..."}'
gitlink-cli api GET /{{owner}}/{{repo}}/pulls --var owner=Gitlink --var repo=gitlink-cli
gitlink-cli api POST /:owner/:repo/issues --body-file issue.json
gitlink-cli api --batch-file plan.json --dry-run
gitlink-cli api --batch-file plan.json --var owner=Gitlink --var repo=gitlink-cli`,
@ -40,7 +44,6 @@ func NewAPICmd(translators ...*i18n.Translator) *cobra.Command {
apiCmd.Flags().String("body-file", "", tr.T("flag.api.body_file"))
apiCmd.Flags().Bool("body-stdin", false, tr.T("flag.api.body_stdin"))
apiCmd.Flags().String("query", "", tr.T("flag.api.query"))
apiCmd.Flags().Bool("paginate", false, tr.T("flag.api.paginate"))
apiCmd.Flags().StringSlice("header", nil, tr.T("flag.api.header"))
apiCmd.Flags().String("batch-file", "", tr.T("flag.api.batch_file"))
apiCmd.Flags().Bool("dry-run", false, tr.T("flag.api.batch_dry_run"))
@ -68,17 +71,6 @@ func runAPI(c *cobra.Command, args []string) error {
}
method := strings.ToUpper(args[0])
path := args[1]
if !strings.HasPrefix(path, "/") {
path = "/" + path
}
cli, err := client.New()
if err != nil {
return err
}
cli.Debug = cmdutil.Debug
body, err := readJSONBody(c)
if err != nil {
@ -95,11 +87,23 @@ func runAPI(c *cobra.Command, args []string) error {
}
}
if paginate, _ := c.Flags().GetBool("paginate"); paginate {
return runAPIPaginate(cli, method, path, query)
headers, err := parseAPIHeaders(c)
if err != nil {
return err
}
env, err := cli.Do(method, path, body, query)
request, err := renderSingleAPIRequest(args[1], query, body, headers, c)
if err != nil {
return err
}
cli, err := client.New()
if err != nil {
return err
}
cli.Debug = cmdutil.Debug
env, err := cli.DoWithHeaders(method, request.Path, request.Body, request.Query, request.Headers)
if err != nil {
var apiErr *client.APIError
if errors.As(err, &apiErr) {
@ -112,27 +116,6 @@ func runAPI(c *cobra.Command, args []string) error {
return output.Print(env, resolveFormat())
}
// runAPIPaginate walks every page and prints the concatenated items as one array.
// PaginateAll drives GET only, so a non-GET method must fail loudly rather than
// silently degrade.
func runAPIPaginate(cli *client.Client, method, path string, query url.Values) error {
if method != "GET" {
return fmt.Errorf("--paginate only supports GET requests, got %s", method)
}
items, err := cli.PaginateAll(path, query)
if err != nil {
var apiErr *client.APIError
if errors.As(err, &apiErr) {
errEnv := output.ErrorEnvelope(apiErr.Code, apiErr.Message, "")
return output.Print(errEnv, resolveFormat())
}
return err
}
return output.Print(output.SuccessEnvelope(items, nil), resolveFormat())
}
func readJSONBody(c *cobra.Command) (interface{}, error) {
bodyStr, _ := c.Flags().GetString("body")
bodyFile, _ := c.Flags().GetString("body-file")
@ -183,3 +166,207 @@ func resolveFormat() string {
}
return f
}
type singleAPIRequest struct {
Path string
Query url.Values
Body interface{}
Headers http.Header
}
func renderSingleAPIRequest(path string, query url.Values, body interface{}, headers http.Header, c *cobra.Command) (*singleAPIRequest, error) {
normalizedPath := normalizeSingleAPIPath(path)
if !strings.HasPrefix(normalizedPath, "/") {
normalizedPath = "/" + normalizedPath
}
vars, err := resolveSingleRequestVars(c, normalizedPath, query, body, headers)
if err != nil {
return nil, err
}
renderedPath, err := renderTemplate(normalizedPath, vars)
if err != nil {
return nil, fmt.Errorf("render path: %w", err)
}
renderedQuery, err := renderURLValues(query, vars)
if err != nil {
return nil, fmt.Errorf("render query: %w", err)
}
renderedBody, err := renderBatchValue(body, vars)
if err != nil {
return nil, fmt.Errorf("render body: %w", err)
}
renderedHeaders, err := renderAPIHeaders(headers, vars)
if err != nil {
return nil, fmt.Errorf("render headers: %w", err)
}
return &singleAPIRequest{
Path: renderedPath,
Query: renderedQuery,
Body: renderedBody,
Headers: renderedHeaders,
}, nil
}
func normalizeSingleAPIPath(path string) string {
return strings.NewReplacer(":owner", "{{owner}}", ":repo", "{{repo}}").Replace(strings.TrimSpace(path))
}
func resolveSingleRequestVars(c *cobra.Command, path string, query url.Values, body interface{}, headers http.Header) (map[string]string, error) {
vars, err := parseBatchVars(c)
if err != nil {
return nil, err
}
if !needsOwnerRepoResolution(path, query, body, headers, vars) {
return vars, nil
}
owner, repo, err := gitcontext.ResolveOwnerRepo(cmdutil.Owner, cmdutil.Repo)
if err != nil {
return nil, fmt.Errorf("resolve owner/repo for api templates: %w", err)
}
if _, ok := vars["owner"]; !ok {
vars["owner"] = owner
}
if _, ok := vars["repo"]; !ok {
vars["repo"] = repo
}
return vars, nil
}
func needsOwnerRepoResolution(path string, query url.Values, body interface{}, headers http.Header, vars map[string]string) bool {
if vars["owner"] != "" && vars["repo"] != "" {
return false
}
if strings.Contains(path, "{{owner}}") || strings.Contains(path, "{{repo}}") {
return true
}
for key, values := range query {
if strings.Contains(key, "{{owner}}") || strings.Contains(key, "{{repo}}") {
return true
}
for _, value := range values {
if strings.Contains(value, "{{owner}}") || strings.Contains(value, "{{repo}}") {
return true
}
}
}
if containsTemplateVar(body, "owner", "repo") {
return true
}
for key, values := range headers {
if strings.Contains(key, "{{owner}}") || strings.Contains(key, "{{repo}}") {
return true
}
for _, value := range values {
if strings.Contains(value, "{{owner}}") || strings.Contains(value, "{{repo}}") {
return true
}
}
}
return false
}
func containsTemplateVar(value interface{}, names ...string) bool {
switch typed := value.(type) {
case nil:
return false
case string:
for _, name := range names {
if strings.Contains(typed, "{{"+name+"}}") {
return true
}
}
return false
case []interface{}:
for _, item := range typed {
if containsTemplateVar(item, names...) {
return true
}
}
return false
case map[string]interface{}:
for key, item := range typed {
if containsTemplateVar(key, names...) || containsTemplateVar(item, names...) {
return true
}
}
return false
default:
return false
}
}
func parseAPIHeaders(c *cobra.Command) (http.Header, error) {
rawHeaders, _ := c.Flags().GetStringSlice("header")
if len(rawHeaders) == 0 {
return nil, nil
}
headers := http.Header{}
for _, item := range rawHeaders {
name, value, ok := strings.Cut(item, ":")
if !ok {
return nil, fmt.Errorf("invalid --header %q, want key:value", item)
}
name = strings.TrimSpace(name)
value = strings.TrimSpace(value)
if name == "" {
return nil, fmt.Errorf("invalid --header %q, header name cannot be empty", item)
}
headers.Add(name, value)
}
return headers, nil
}
func renderAPIHeaders(headers http.Header, vars map[string]string) (http.Header, error) {
if len(headers) == 0 {
return nil, nil
}
rendered := http.Header{}
keys := make([]string, 0, len(headers))
for key := range headers {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
renderedKey, err := renderTemplate(key, vars)
if err != nil {
return nil, err
}
for _, value := range headers.Values(key) {
renderedValue, err := renderTemplate(value, vars)
if err != nil {
return nil, err
}
rendered.Add(renderedKey, renderedValue)
}
}
return rendered, nil
}
func renderURLValues(query url.Values, vars map[string]string) (url.Values, error) {
if len(query) == 0 {
return nil, nil
}
rendered := url.Values{}
keys := make([]string, 0, len(query))
for key := range query {
keys = append(keys, key)
}
sort.Strings(keys)
for _, key := range keys {
renderedKey, err := renderTemplate(key, vars)
if err != nil {
return nil, err
}
for _, value := range query[key] {
renderedValue, err := renderTemplate(value, vars)
if err != nil {
return nil, err
}
rendered.Add(renderedKey, renderedValue)
}
}
return rendered, nil
}

274
cmd/api/api_test.go
View File

@ -1,13 +1,13 @@
package api
import (
"bytes"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"net/url"
"os"
"path/filepath"
"reflect"
"testing"
"github.com/gitlink-org/gitlink-cli/cmd/cmdutil"
@ -34,55 +34,6 @@ func TestResolveFormat(t *testing.T) {
}
}
func TestResolvePathPlaceholders(t *testing.T) {
origOwner, origRepo := cmdutil.Owner, cmdutil.Repo
t.Cleanup(func() { cmdutil.Owner, cmdutil.Repo = origOwner, origRepo })
cmdutil.Owner, cmdutil.Repo = "demo-owner", "demo-repo"
tests := []struct {
name string
path string
want string
}{
{"colon placeholders", "/:owner/:repo/issues", "/demo-owner/demo-repo/issues"},
{"colon with suffix", "/:owner/:repo/issues/42", "/demo-owner/demo-repo/issues/42"},
{"brace placeholders", "/{{owner}}/{{repo}}/pulls", "/demo-owner/demo-repo/pulls"},
{"no placeholders unchanged", "/users/me", "/users/me"},
{"literal path unchanged", "/Gitlink/gitlink-cli/issues", "/Gitlink/gitlink-cli/issues"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := resolvePathPlaceholders(tt.path)
if err != nil {
t.Fatalf("resolvePathPlaceholders(%q): %v", tt.path, err)
}
if got != tt.want {
t.Fatalf("resolvePathPlaceholders(%q) = %q, want %q", tt.path, got, tt.want)
}
})
}
}
func TestResolvePathPlaceholdersUnresolvable(t *testing.T) {
origOwner, origRepo := cmdutil.Owner, cmdutil.Repo
t.Cleanup(func() { cmdutil.Owner, cmdutil.Repo = origOwner, origRepo })
cmdutil.Owner, cmdutil.Repo = "", ""
tmp := t.TempDir()
origWD, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = os.Chdir(origWD) })
if err := os.Chdir(tmp); err != nil {
t.Fatal(err)
}
if _, err := resolvePathPlaceholders("/:owner/:repo/issues"); err == nil {
t.Fatal("expected error when owner/repo cannot be resolved")
}
}
func TestNewAPICmd(t *testing.T) {
cmd := NewAPICmd()
if cmd.Use != "api (<METHOD> <PATH> | --batch-file <FILE>)" {
@ -93,7 +44,7 @@ func TestNewAPICmd(t *testing.T) {
}
// Verify flags exist
flags := []string{"body", "query", "paginate", "header", "batch-file", "dry-run", "continue-on-error", "var"}
flags := []string{"body", "query", "header", "batch-file", "dry-run", "continue-on-error", "var"}
for _, f := range flags {
if cmd.Flags().Lookup(f) == nil {
t.Fatalf("flag %q not found", f)
@ -253,53 +204,104 @@ func TestRunAPINoPrefix(t *testing.T) {
}
}
func TestRunAPIResolvesOwnerRepoPlaceholders(t *testing.T) {
func TestRunAPISingleRequestTemplatesAndHeaders(t *testing.T) {
oldOwner, oldRepo, oldFormat := cmdutil.Owner, cmdutil.Repo, cmdutil.Format
cmdutil.Owner = "Gitlink"
cmdutil.Repo = "gitlink-cli"
cmdutil.Format = "json"
t.Cleanup(func() {
cmdutil.Owner = oldOwner
cmdutil.Repo = oldRepo
cmdutil.Format = oldFormat
})
var gotBody map[string]interface{}
setupAPITest(t, func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/testowner/testrepo/commits.json" {
if r.URL.Path != "/Gitlink/gitlink-cli/issues.json" {
t.Fatalf("unexpected path: %s", r.URL.Path)
}
if r.URL.Query().Get("state") != "open" {
t.Fatalf("state query = %q, want open", r.URL.Query().Get("state"))
}
if r.URL.Query().Get("repo") != "gitlink-cli" {
t.Fatalf("repo query = %q, want gitlink-cli", r.URL.Query().Get("repo"))
}
if r.Header.Get("X-Repo") != "gitlink-cli" {
t.Fatalf("X-Repo = %q, want gitlink-cli", r.Header.Get("X-Repo"))
}
if err := json.NewDecoder(r.Body).Decode(&gotBody); err != nil {
t.Fatalf("decode body: %v", err)
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]interface{}{"ok": true})
json.NewEncoder(w).Encode(map[string]interface{}{"id": 7})
})
cmdutil.Format = "json"
cmdutil.Owner, cmdutil.Repo = "testowner", "testrepo"
defer func() { cmdutil.Owner, cmdutil.Repo = "", "" }()
cmd := NewAPICmd()
cmd.SetArgs([]string{"GET", "/:owner/:repo/commits"})
cmd.SetArgs([]string{"POST", "/:owner/:repo/issues"})
cmd.Flags().Set("query", "state={{state}}&repo={{repo}}")
cmd.Flags().Set("body", `{"subject":"{{title}}","meta":{"owner":"{{owner}}","repo":"{{repo}}"}}`)
cmd.Flags().Set("header", "X-Repo: {{repo}}")
cmd.Flags().Set("var", "state=open")
cmd.Flags().Set("var", "title=Bug report")
if err := cmd.Execute(); err != nil {
t.Fatalf("runAPI :owner/:repo error: %v", err)
t.Fatalf("runAPI template error: %v", err)
}
if gotBody["subject"] != "Bug report" {
t.Fatalf("subject = %#v, want Bug report", gotBody["subject"])
}
meta, _ := gotBody["meta"].(map[string]interface{})
if meta["owner"] != "Gitlink" || meta["repo"] != "gitlink-cli" {
t.Fatalf("meta = %#v", meta)
}
}
func TestRunAPIRendersVarTemplateSingleCall(t *testing.T) {
setupAPITest(t, func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/v1/Mengz/gitlink-cli/issues.json" {
t.Fatalf("unexpected path: %s", r.URL.Path)
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]interface{}{"ok": true})
func TestRenderSingleAPIRequestUsesVarsAndOwnerRepo(t *testing.T) {
oldOwner, oldRepo := cmdutil.Owner, cmdutil.Repo
cmdutil.Owner = "Gitlink"
cmdutil.Repo = "gitlink-cli"
t.Cleanup(func() {
cmdutil.Owner = oldOwner
cmdutil.Repo = oldRepo
})
cmdutil.Format = "json"
cmdutil.Owner, cmdutil.Repo = "", ""
cmd := NewAPICmd()
cmd.SetArgs([]string{"GET", "/v1/{{owner}}/gitlink-cli/issues", "--var", "owner=Mengz"})
if err := cmd.Execute(); err != nil {
t.Fatalf("runAPI --var single call error: %v", err)
if err := cmd.Flags().Set("var", "issue=42"); err != nil {
t.Fatalf("set var: %v", err)
}
headers := http.Header{"X-Issue": []string{"{{issue}}"}}
query := url.Values{
"repo": {"{{repo}}"},
}
body := map[string]interface{}{
"notes": "owner={{owner}} issue={{issue}}",
}
req, err := renderSingleAPIRequest("/:owner/:repo/issues/{{issue}}", query, body, headers, cmd)
if err != nil {
t.Fatalf("renderSingleAPIRequest error: %v", err)
}
if req.Path != "/Gitlink/gitlink-cli/issues/42" {
t.Fatalf("Path = %q", req.Path)
}
if req.Query.Get("repo") != "gitlink-cli" {
t.Fatalf("query repo = %q", req.Query.Get("repo"))
}
if req.Headers.Get("X-Issue") != "42" {
t.Fatalf("X-Issue = %q", req.Headers.Get("X-Issue"))
}
if !reflect.DeepEqual(req.Body, map[string]interface{}{"notes": "owner=Gitlink issue=42"}) {
t.Fatalf("Body = %#v", req.Body)
}
}
func TestRunAPIMissingVarTemplateSingleCall(t *testing.T) {
setupAPITest(t, func(w http.ResponseWriter, r *http.Request) {
t.Fatal("should not reach server")
})
cmdutil.Format = "json"
func TestParseAPIHeadersRejectsInvalidInput(t *testing.T) {
cmd := NewAPICmd()
cmd.SetArgs([]string{"GET", "/{{missing}}", "--var", "present=1"})
if err := cmd.Execute(); err == nil {
t.Fatal("expected error for missing template variable")
if err := cmd.Flags().Set("header", "broken"); err != nil {
t.Fatalf("set header: %v", err)
}
if _, err := parseAPIHeaders(cmd); err == nil {
t.Fatal("expected invalid header error")
}
}
@ -491,94 +493,6 @@ func TestRunAPIBatchContinueOnError(t *testing.T) {
}
}
// captureStdout redirects os.Stdout while fn runs, since output.Print writes there directly.
func captureStdout(t *testing.T, fn func()) string {
t.Helper()
old := os.Stdout
r, w, err := os.Pipe()
if err != nil {
t.Fatalf("pipe: %v", err)
}
os.Stdout = w
done := make(chan string, 1)
go func() {
var buf bytes.Buffer
io.Copy(&buf, r)
done <- buf.String()
}()
fn()
w.Close()
os.Stdout = old
return <-done
}
type paginateEnvelope struct {
OK bool `json:"ok"`
Data []map[string]interface{} `json:"data"`
}
func TestRunAPIPaginateCombinesPages(t *testing.T) {
// Real GitLink list shape wraps the array under a resource key, not "data".
var pages []string
setupAPITest(t, func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/repos/owner/repo/issues.json" {
t.Fatalf("unexpected path: %s", r.URL.Path)
}
page := r.URL.Query().Get("page")
pages = append(pages, page)
w.Header().Set("Content-Type", "application/json")
switch page {
case "1":
w.Write([]byte(`{"total_count":3,"issues":[{"id":1},{"id":2}]}`))
case "2":
w.Write([]byte(`{"total_count":3,"issues":[{"id":3}]}`))
default:
t.Fatalf("unexpected page: %s", page)
}
})
cmdutil.Format = "json"
out := captureStdout(t, func() {
cmd := NewAPICmd()
cmd.SetArgs([]string{"GET", "/repos/owner/repo/issues", "--paginate", "--query", "limit=2"})
if err := cmd.Execute(); err != nil {
t.Fatalf("paginate error: %v", err)
}
})
var env paginateEnvelope
if err := json.Unmarshal([]byte(out), &env); err != nil {
t.Fatalf("unmarshal output %q: %v", out, err)
}
if !env.OK {
t.Fatalf("expected ok=true, got %s", out)
}
if len(env.Data) != 3 {
t.Fatalf("expected 3 combined items, got %d (%s)", len(env.Data), out)
}
for i, want := range []float64{1, 2, 3} {
if env.Data[i]["id"] != want {
t.Fatalf("item[%d].id = %v, want %v", i, env.Data[i]["id"], want)
}
}
if len(pages) != 2 || pages[0] != "1" || pages[1] != "2" {
t.Fatalf("expected pages [1 2], got %v", pages)
}
}
func TestRunAPIPaginateRejectsNonGet(t *testing.T) {
setupAPITest(t, func(w http.ResponseWriter, r *http.Request) {
t.Fatal("non-GET paginate should not reach server")
})
cmdutil.Format = "json"
cmd := NewAPICmd()
cmd.SetArgs([]string{"POST", "/items", "--paginate"})
if err := cmd.Execute(); err == nil {
t.Fatal("expected error for --paginate with non-GET method")
}
}
func writeBatchPlan(t *testing.T, payload interface{}) string {
t.Helper()
data, err := json.Marshal(payload)
@ -591,25 +505,3 @@ func writeBatchPlan(t *testing.T, payload interface{}) string {
}
return path
}
func TestRestoreAPIPath(t *testing.T) {
tests := []struct {
name string
path string
want string
}{
{"normal v1 path unchanged", "/v1/owner/repo", "/v1/owner/repo"},
{"msys2 polluted v1", "C:/Program Files/Git/v1/owner/repo", "/v1/owner/repo"},
{"msys2 polluted v2", "D:/Git/v2/x/y", "/v2/x/y"},
{"msys2 polluted api prefix", "C:/Program Files/Git/api/v1/users", "/api/v1/users"},
{"drive letter but no known prefix", "C:/something/else", "C:/something/else"},
{"empty path", "", ""},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := restoreAPIPath(tt.path); got != tt.want {
t.Fatalf("restoreAPIPath(%q) = %q, want %q", tt.path, got, tt.want)
}
})
}
}

7
doc/changes/api-single-request-templates.md Normal file
View File

@ -0,0 +1,7 @@
# Raw API 单次调用模板变量与请求头支持
`gitlink-cli api` 的单次调用模式现在和批处理模式对齐了模板渲染能力，不再只能手写完整路径。现在可以直接在路径里使用 `/:owner/:repo`，也可以在 path、query、JSON body、header 中使用 `{{owner}}`、`{{repo}}` 和自定义 `{{var}}` 变量；其中 `owner` / `repo` 会优先读取 `--var`，否则自动复用全局 `--owner`、`--repo` 或当前仓库上下文。
这次改动同时把原来声明但未实际生效的 `--header` 接上了。单次请求现在支持通过 `--header key:value` 传递一个或多个自定义请求头，header 名和值都可以参与模板渲染，适合调试网关、透传审计字段、补充实验性接口所需头信息。
本次提交补充了路径占位符回归测试、query/body/header 联动渲染测试、非法 header 校验测试，以及自定义 header 真正发到服务端的行为验证。README 和 README.zh-CN 也同步加入了单次请求模板变量示例，方便维护者、脚本和 Agent 直接复用。

9
internal/client/client.go
View File

@ -48,6 +48,10 @@ func New() (*Client, error) {
}
func (c *Client) Do(method, path string, body interface{}, query url.Values) (*output.Envelope, error) {
return c.DoWithHeaders(method, path, body, query, nil)
}
func (c *Client) DoWithHeaders(method, path string, body interface{}, query url.Values, headers http.Header) (*output.Envelope, error) {
path = normalizeAPIPath(c.BaseURL, path)
// Append .json suffix if not already present (GitLink API convention)
@ -84,6 +88,11 @@ func (c *Client) Do(method, path string, body interface{}, query url.Values) (*o
if err != nil {
return nil, err
}
for key, values := range headers {
for _, value := range values {
req.Header.Add(key, value)
}
}
if c.Debug {
fmt.Printf("-> %s %s\n", method, fullURL)