d1http/database.go at master · pubflow/d1http · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
package d1http

import (
	"context"
	"net/http"
	"net/url"
	"strconv"
)

type Database struct {
	UUID                string `json:"uuid,omitempty"`
	ID                  string `json:"id,omitempty"`
	Name                string `json:"name,omitempty"`
	Version             string `json:"version,omitempty"`
	NumTables           int    `json:"num_tables,omitempty"`
	FileSize            int64  `json:"file_size,omitempty"`
	CreatedAt           string `json:"created_at,omitempty"`
	RunningInRegion     string `json:"running_in_region,omitempty"`
	PrimaryLocationHint string `json:"primary_location_hint,omitempty"`
}

type ListDatabasesOptions struct {
	Name    string
	Page    int
	PerPage int
}

type CreateDatabaseRequest struct {
	Name                string `json:"name"`
	PrimaryLocationHint string `json:"primary_location_hint,omitempty"`
}

type UpdateDatabaseRequest struct {
	Name string `json:"name,omitempty"`
}

type PatchDatabaseRequest struct {
	Name string `json:"name,omitempty"`
}

func (c *Client) ListDatabases(ctx context.Context, opts ListDatabasesOptions) (*Page[[]Database], error) {
	q := url.Values{}
	if opts.Name != "" {
		q.Set("name", opts.Name)
	}
	if opts.Page > 0 {
		q.Set("page", strconv.Itoa(opts.Page))
	}
	if opts.PerPage > 0 {
		q.Set("per_page", strconv.Itoa(opts.PerPage))
	}
	var env envelope[[]Database]
	err := c.do(ctx, http.MethodGet, apiPath("accounts", c.cfg.AccountID, "d1/database"), q, nil, &env)
	if err != nil {
		return nil, err
	}
	return &Page[[]Database]{Items: env.Result, ResultInfo: env.ResultInfo, Messages: env.Messages}, nil
}

func (c *Client) GetDatabase(ctx context.Context, databaseID string) (*Database, error) {
	var env envelope[Database]
	err := c.do(ctx, http.MethodGet, apiPath("accounts", c.cfg.AccountID, "d1/database", databaseID), nil, nil, &env)
	return &env.Result, err
}

func (c *Client) CreateDatabase(ctx context.Context, req CreateDatabaseRequest) (*Database, error) {
	var env envelope[Database]
	err := c.do(ctx, http.MethodPost, apiPath("accounts", c.cfg.AccountID, "d1/database"), nil, req, &env)
	return &env.Result, err
}

func (c *Client) UpdateDatabase(ctx context.Context, databaseID string, req UpdateDatabaseRequest) (*Database, error) {
	var env envelope[Database]
	err := c.do(ctx, http.MethodPut, apiPath("accounts", c.cfg.AccountID, "d1/database", databaseID), nil, req, &env)
	return &env.Result, err
}

func (c *Client) PatchDatabase(ctx context.Context, databaseID string, req PatchDatabaseRequest) (*Database, error) {
	var env envelope[Database]
	err := c.do(ctx, http.MethodPatch, apiPath("accounts", c.cfg.AccountID, "d1/database", databaseID), nil, req, &env)
	return &env.Result, err
}

func (c *Client) DeleteDatabase(ctx context.Context, databaseID string) error {
	var env envelope[map[string]any]
	return c.do(ctx, http.MethodDelete, apiPath("accounts", c.cfg.AccountID, "d1/database", databaseID), nil, nil, &env)
}