planetscale 0.1.0

data/vendor/github.com/planetscale/planetscale-go/planetscale/client.go

@@ -0,0 +1,305 @@
+package planetscale
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+
+	"github.com/hashicorp/go-cleanhttp"
+	"golang.org/x/oauth2"
+)
+
+const (
+	DefaultBaseURL = "https://api.planetscale.com/"
+	jsonMediaType  = "application/json"
+)
+
+// ErrorCode defines the code of an error.
+type ErrorCode string
+
+const (
+	ErrInternal          ErrorCode = "internal"           // Internal error.
+	ErrInvalid           ErrorCode = "invalid"            // Invalid operation, e.g wrong params
+	ErrPermission        ErrorCode = "permission"         // Permission denied.
+	ErrNotFound          ErrorCode = "not_found"          // Resource not found.
+	ErrRetry             ErrorCode = "retry"              // Operation should be retried.
+	ErrResponseMalformed ErrorCode = "response_malformed" // Response body is malformed.
+)
+
+// Client encapsulates a client that talks to the PlanetScale API
+type Client struct {
+	// client represents the HTTP client used for making HTTP requests.
+	client *http.Client
+
+	// base URL for the API
+	baseURL *url.URL
+
+	Backups          BackupsService
+	Databases        DatabasesService
+	Certificates     CertificatesService
+	DatabaseBranches DatabaseBranchesService
+	Organizations    OrganizationsService
+	DeployRequests   DeployRequestsService
+	ServiceTokens    ServiceTokenService
+}
+
+// ClientOption provides a variadic option for configuring the client
+type ClientOption func(c *Client) error
+
+// WithBaseURL overrides the base URL for the API.
+func WithBaseURL(baseURL string) ClientOption {
+	return func(c *Client) error {
+		parsedURL, err := url.Parse(baseURL)
+		if err != nil {
+			return err
+		}
+
+		c.baseURL = parsedURL
+		return nil
+	}
+}
+
+// WithAccessToken configures a client with the given PlanetScale access token.
+func WithAccessToken(token string) ClientOption {
+	return func(c *Client) error {
+		if token == "" {
+			return errors.New("missing access token")
+		}
+
+		tokenSource := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: token})
+
+		// make sure we use our own HTTP client
+		ctx := context.WithValue(context.Background(), oauth2.HTTPClient, c.client)
+		oauthClient := oauth2.NewClient(ctx, tokenSource)
+
+		c.client = oauthClient
+		return nil
+	}
+}
+
+// WithServiceToken configures a client with the given PlanetScale Service Token
+func WithServiceToken(name, token string) ClientOption {
+	return func(c *Client) error {
+		if token == "" || name == "" {
+			return errors.New("missing token name and string")
+		}
+
+		transport := serviceTokenTransport{
+			rt:        c.client.Transport,
+			token:     token,
+			tokenName: name,
+		}
+
+		c.client.Transport = &transport
+		return nil
+	}
+}
+
+// WithHTTPClient configures the PLanetScale client with the given HTTP client.
+func WithHTTPClient(client *http.Client) ClientOption {
+	return func(c *Client) error {
+		if client == nil {
+			client = cleanhttp.DefaultClient()
+		}
+
+		c.client = client
+		return nil
+	}
+}
+
+// NewClient instantiates an instance of the PlanetScale API client.
+func NewClient(opts ...ClientOption) (*Client, error) {
+	baseURL, err := url.Parse(DefaultBaseURL)
+	if err != nil {
+		return nil, err
+	}
+
+	c := &Client{
+		client:  cleanhttp.DefaultClient(),
+		baseURL: baseURL,
+	}
+
+	for _, opt := range opts {
+		err := opt(c)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	c.Backups = &backupsService{client: c}
+	c.Databases = &databasesService{client: c}
+	c.Certificates = &certificatesService{client: c}
+	c.DatabaseBranches = &databaseBranchesService{client: c}
+	c.Organizations = &organizationsService{client: c}
+	c.DeployRequests = &deployRequestsService{client: c}
+	c.ServiceTokens = &serviceTokenService{client: c}
+
+	return c, nil
+}
+
+// do makes an HTTP request and populates the given struct v from the response.
+func (c *Client) do(ctx context.Context, req *http.Request, v interface{}) error {
+	req = req.WithContext(ctx)
+	res, err := c.client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	return c.handleResponse(ctx, res, v)
+}
+
+// handleResponse makes an HTTP request and populates the given struct v from
+// the response.  This is meant for internal testing and shouldn't be used
+// directly. Instead please use `Client.do`.
+func (c *Client) handleResponse(ctx context.Context, res *http.Response, v interface{}) error {
+	out, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return err
+	}
+
+	if res.StatusCode >= 400 {
+		// errorResponse represents an error response from the API
+		type errorResponse struct {
+			Code    string `json:"code"`
+			Message string `json:"message"`
+		}
+
+		errorRes := &errorResponse{}
+		err = json.Unmarshal(out, errorRes)
+		if err != nil {
+			if _, ok := err.(*json.SyntaxError); ok {
+				return &Error{
+					msg:  "malformed response body received",
+					Code: ErrResponseMalformed,
+					Meta: map[string]string{
+						"body": string(out),
+						"err":  err.Error(),
+					},
+				}
+			}
+			return err
+		}
+
+		// json.Unmarshal doesn't return an error if the response
+		// body has a different protocol then "ErrorResponse". We
+		// check here to make sure that errorRes is populated. If
+		// not, we return the full response back to the user, so
+		// they can debug the issue.
+		// TODO(fatih): fix the behavior on the API side
+		if *errorRes == (errorResponse{}) {
+			return &Error{
+				msg:  "internal error, please open an issue to github.com/planetscale/planetscale-go",
+				Code: ErrInternal,
+				Meta: map[string]string{
+					"body": string(out),
+				},
+			}
+		}
+
+		var errCode ErrorCode
+		switch errorRes.Code {
+		case "not_found":
+			errCode = ErrNotFound
+		case "unauthorized":
+			errCode = ErrPermission
+		case "invalid_params":
+			errCode = ErrInvalid
+		case "unprocessable":
+			errCode = ErrRetry
+		}
+
+		return &Error{
+			msg:  errorRes.Message,
+			Code: errCode,
+		}
+	}
+
+	// this means we don't care about unmrarshaling the response body into v
+	if v == nil {
+		return nil
+	}
+
+	err = json.Unmarshal(out, &v)
+	if err != nil {
+		if _, ok := err.(*json.SyntaxError); ok {
+			return &Error{
+				msg:  "malformed response body received",
+				Code: ErrResponseMalformed,
+				Meta: map[string]string{
+					"body": string(out),
+				},
+			}
+		}
+		return err
+	}
+
+	return nil
+}
+
+func (c *Client) newRequest(method string, path string, body interface{}) (*http.Request, error) {
+	u, err := c.baseURL.Parse(path)
+	if err != nil {
+		return nil, err
+	}
+
+	var req *http.Request
+	switch method {
+	case http.MethodGet:
+		req, err = http.NewRequest(method, u.String(), nil)
+		if err != nil {
+			return nil, err
+		}
+	default:
+		buf := new(bytes.Buffer)
+		if body != nil {
+			err = json.NewEncoder(buf).Encode(body)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		req, err = http.NewRequest(method, u.String(), buf)
+		if err != nil {
+			return nil, err
+		}
+
+		req.Header.Set("Content-Type", jsonMediaType)
+	}
+
+	req.Header.Set("Accept", jsonMediaType)
+
+	return req, nil
+}
+
+type serviceTokenTransport struct {
+	rt        http.RoundTripper
+	token     string
+	tokenName string
+}
+
+func (t *serviceTokenTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	req.Header.Add("Authorization", t.tokenName+":"+t.token)
+	return t.rt.RoundTrip(req)
+}
+
+// Error represents common errors originating from the Client.
+type Error struct {
+	// msg contains the human readable string
+	msg string
+
+	// Code specifies the error code. i.e; NotFound, RateLimited, etc...
+	Code ErrorCode
+
+	// Meta contains additional information depending on the error code. As an
+	// example, if the Code is "ErrResponseMalformed", the map will be: ["body"]
+	// = "body of the response"
+	Meta map[string]string
+}
+
+// Error returns the string representation of the error.
+func (e *Error) Error() string { return e.msg }

data/vendor/github.com/planetscale/planetscale-go/planetscale/databases.go

@@ -0,0 +1,131 @@
+package planetscale
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+// CreateDatabaseRequest encapsulates the request for creating a new database.
+type CreateDatabaseRequest struct {
+	Organization string
+	Name         string `json:"name"`
+	Notes        string `json:"notes"`
+}
+
+// DatabaseRequest encapsulates the request for getting a single database.
+type GetDatabaseRequest struct {
+	Organization string
+	Database     string
+}
+
+// ListDatabasesRequest encapsulates the request for listing all databases in an
+// organization.
+type ListDatabasesRequest struct {
+	Organization string
+}
+
+// DeleteDatabaseRequest encapsulates the request for deleting a database from
+// an organization.
+type DeleteDatabaseRequest struct {
+	Organization string
+	Database     string
+}
+
+// DatabaseService is an interface for communicating with the PlanetScale
+// Databases API endpoint.
+type DatabasesService interface {
+	Create(context.Context, *CreateDatabaseRequest) (*Database, error)
+	Get(context.Context, *GetDatabaseRequest) (*Database, error)
+	List(context.Context, *ListDatabasesRequest) ([]*Database, error)
+	Delete(context.Context, *DeleteDatabaseRequest) error
+}
+
+// Database represents a PlanetScale database
+type Database struct {
+	Name      string    `json:"name"`
+	Notes     string    `json:"notes"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+// Database represents a list of PlanetScale databases
+type databasesResponse struct {
+	Databases []*Database `json:"data"`
+}
+
+type databasesService struct {
+	client *Client
+}
+
+var _ DatabasesService = &databasesService{}
+
+func NewDatabasesService(client *Client) *databasesService {
+	return &databasesService{
+		client: client,
+	}
+}
+
+func (ds *databasesService) List(ctx context.Context, listReq *ListDatabasesRequest) ([]*Database, error) {
+	req, err := ds.client.newRequest(http.MethodGet, databasesAPIPath(listReq.Organization), nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating http request")
+	}
+
+	dbResponse := databasesResponse{}
+	err = ds.client.do(ctx, req, &dbResponse)
+	if err != nil {
+		return nil, err
+	}
+
+	return dbResponse.Databases, nil
+}
+
+func (ds *databasesService) Create(ctx context.Context, createReq *CreateDatabaseRequest) (*Database, error) {
+	req, err := ds.client.newRequest(http.MethodPost, databasesAPIPath(createReq.Organization), createReq)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating request for create database")
+	}
+
+	db := &Database{}
+	err = ds.client.do(ctx, req, &db)
+	if err != nil {
+		return nil, err
+	}
+
+	return db, nil
+}
+
+func (ds *databasesService) Get(ctx context.Context, getReq *GetDatabaseRequest) (*Database, error) {
+	path := fmt.Sprintf("%s/%s", databasesAPIPath(getReq.Organization), getReq.Database)
+	req, err := ds.client.newRequest(http.MethodGet, path, nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating request for get database")
+	}
+
+	db := &Database{}
+	err = ds.client.do(ctx, req, &db)
+	if err != nil {
+		return nil, err
+	}
+
+	return db, nil
+}
+
+func (ds *databasesService) Delete(ctx context.Context, deleteReq *DeleteDatabaseRequest) error {
+	path := fmt.Sprintf("%s/%s", databasesAPIPath(deleteReq.Organization), deleteReq.Database)
+	req, err := ds.client.newRequest(http.MethodDelete, path, nil)
+	if err != nil {
+		return errors.Wrap(err, "error creating request for delete database")
+	}
+
+	err = ds.client.do(ctx, req, nil)
+	return err
+}
+
+func databasesAPIPath(org string) string {
+	return fmt.Sprintf("v1/organizations/%s/databases", org)
+}

data/vendor/github.com/planetscale/planetscale-go/planetscale/deploy_requests.go

@@ -0,0 +1,368 @@
+package planetscale
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+type deployRequestsService struct {
+	client *Client
+}
+
+var _ DeployRequestsService = (*deployRequestsService)(nil)
+
+// DeployRequestsService is an interface for communicating with the PlanetScale
+// deploy requests API.
+type DeployRequestsService interface {
+	CancelDeploy(context.Context, *CancelDeployRequestRequest) (*DeployRequest, error)
+	CloseDeploy(context.Context, *CloseDeployRequestRequest) (*DeployRequest, error)
+	Create(context.Context, *CreateDeployRequestRequest) (*DeployRequest, error)
+	CreateReview(context.Context, *ReviewDeployRequestRequest) (*DeployRequestReview, error)
+	Deploy(context.Context, *PerformDeployRequest) (*DeployRequest, error)
+	Diff(ctx context.Context, diffReq *DiffRequest) ([]*Diff, error)
+	Get(context.Context, *GetDeployRequestRequest) (*DeployRequest, error)
+	List(context.Context, *ListDeployRequestsRequest) ([]*DeployRequest, error)
+}
+
+// DeployRequestReview posts a review to a deploy request.
+type DeployRequestReview struct {
+	ID        string    `json:"id"`
+	Body      string    `json:"body"`
+	State     string    `json:"state"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+// PerformDeployRequest is a request for approving and deploying a deploy request.
+// NOTE: We deviate from naming convention here because we have a data model
+// named DeployRequest already.
+type PerformDeployRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Number       uint64 `json:"-"`
+}
+
+// GetDeployRequest encapsulates the request for getting a single deploy
+// request.
+type GetDeployRequestRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Number       uint64 `json:"-"`
+}
+
+// ListDeployRequestsRequest gets the deploy requests for a specific database
+// branch.
+type ListDeployRequestsRequest struct {
+	Organization string
+	Database     string
+}
+
+// DeployOperation encapsulates a deploy operation within a deployment from the
+// PlanetScale API.
+type DeployOperation struct {
+	ID                 string    `json:"id"`
+	State              string    `json:"state"`
+	Table              string    `json:"table_name"`
+	Keyspace           string    `json:"keyspace_name"`
+	Operation          string    `json:"operation_name"`
+	ETASeconds         int64     `json:"eta_seconds"`
+	ProgressPercentage uint64    `json:"progress_percentage"`
+	CreatedAt          time.Time `json:"created_at"`
+	UpdatedAt          time.Time `json:"updated_at"`
+}
+
+// QueuedDeployment encapsulates a deployment that is in the queue.
+type QueuedDeployment struct {
+	ID                  string `json:"id"`
+	State               string `json:"state"`
+	DeployRequestNumber uint64 `json:"deploy_request_number"`
+	IntoBranch          string `json:"into_branch"`
+
+	CreatedAt  time.Time  `json:"created_at"`
+	UpdatedAt  time.Time  `json:"updated_at"`
+	StartedAt  *time.Time `json:"started_at"`
+	QueuedAt   *time.Time `json:"queued_at"`
+	FinishedAt *time.Time `json:"finished_at"`
+}
+
+// Deployment encapsulates a deployment for a deploy request.
+type Deployment struct {
+	ID                   string              `json:"id"`
+	State                string              `json:"state"`
+	Deployable           bool                `json:"deployable"`
+	DeployRequestNumber  uint64              `json:"deploy_request_number"`
+	IntoBranch           string              `json:"into_branch"`
+	PrecedingDeployments []*QueuedDeployment `json:"preceding_deployments"`
+
+	CreatedAt  time.Time  `json:"created_at"`
+	UpdatedAt  time.Time  `json:"updated_at"`
+	StartedAt  *time.Time `json:"started_at"`
+	QueuedAt   *time.Time `json:"queued_at"`
+	FinishedAt *time.Time `json:"finished_at"`
+}
+
+// DeployRequest encapsulates the request to deploy a database branch's schema
+// to a production branch
+type DeployRequest struct {
+	ID string `json:"id"`
+
+	Branch     string `json:"branch"`
+	IntoBranch string `json:"into_branch"`
+
+	Number uint64 `json:"number"`
+
+	State string `json:"state"`
+
+	Approved bool `json:"approved"`
+
+	Notes string `json:"notes"`
+
+	Deployment *Deployment `json:"deployment"`
+
+	CreatedAt time.Time  `json:"created_at"`
+	UpdatedAt time.Time  `json:"updated_at"`
+	ClosedAt  *time.Time `json:"closed_at"`
+}
+
+type CancelDeployRequestRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Number       uint64 `json:"-"`
+}
+
+type CreateDeployRequestRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Branch       string `json:"branch"`
+	IntoBranch   string `json:"into_branch"`
+	Notes        string `json:"notes"`
+}
+
+type ReviewDeployRequestRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Number       uint64 `json:"-"`
+
+	// CommentText represents the comment body to be posted
+	CommentText string `json:"-"`
+
+	// ReviewAction defines the action for an individual review.
+	ReviewAction ReviewAction `json:"-"`
+}
+
+// ReviewAction defines the action for an individual review.
+type ReviewAction int
+
+const (
+	// Comment is used to comment a Review with a custom text.
+	ReviewComment ReviewAction = iota
+
+	// Approve is used to approve a Review.
+	ReviewApprove
+)
+
+func (r ReviewAction) String() string {
+	switch r {
+	case ReviewApprove:
+		return "approved"
+	case ReviewComment:
+		fallthrough
+	default:
+		return "commented"
+	}
+}
+
+type CloseDeployRequestRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Number       uint64 `json:"-"`
+}
+
+func NewDeployRequestsService(client *Client) *deployRequestsService {
+	return &deployRequestsService{
+		client: client,
+	}
+}
+
+// Get fetches a single deploy request.
+func (d *deployRequestsService) Get(ctx context.Context, getReq *GetDeployRequestRequest) (*DeployRequest, error) {
+	req, err := d.client.newRequest(http.MethodGet, deployRequestAPIPath(getReq.Organization, getReq.Database, getReq.Number), nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating http request")
+	}
+
+	dr := &DeployRequest{}
+	if err := d.client.do(ctx, req, &dr); err != nil {
+		return nil, err
+	}
+
+	return dr, nil
+}
+
+type CloseRequest struct {
+	State string `json:"state"`
+}
+
+// CloseDeploy closes a deploy request
+func (d *deployRequestsService) CloseDeploy(ctx context.Context, closeReq *CloseDeployRequestRequest) (*DeployRequest, error) {
+	updateReq := &CloseRequest{
+		State: "closed",
+	}
+
+	req, err := d.client.newRequest(http.MethodPatch, deployRequestAPIPath(closeReq.Organization, closeReq.Database, closeReq.Number), updateReq)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating http request")
+	}
+
+	dr := &DeployRequest{}
+	if err := d.client.do(ctx, req, &dr); err != nil {
+		return nil, err
+	}
+
+	return dr, nil
+}
+
+// Deploy approves and executes a specific deploy request.
+func (d *deployRequestsService) Deploy(ctx context.Context, deployReq *PerformDeployRequest) (*DeployRequest, error) {
+	path := deployRequestActionAPIPath(deployReq.Organization, deployReq.Database, deployReq.Number, "deploy")
+	req, err := d.client.newRequest(http.MethodPost, path, deployReq)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating http request")
+	}
+
+	dr := &DeployRequest{}
+	if err := d.client.do(ctx, req, &dr); err != nil {
+		return nil, err
+	}
+
+	return dr, nil
+}
+
+type deployRequestsResponse struct {
+	DeployRequests []*DeployRequest `json:"data"`
+}
+
+func (d *deployRequestsService) Create(ctx context.Context, createReq *CreateDeployRequestRequest) (*DeployRequest, error) {
+	path := deployRequestsAPIPath(createReq.Organization, createReq.Database)
+	req, err := d.client.newRequest(http.MethodPost, path, createReq)
+	if err != nil {
+		return nil, err
+	}
+
+	dr := &DeployRequest{}
+	if err := d.client.do(ctx, req, &dr); err != nil {
+		return nil, err
+	}
+	return dr, nil
+}
+
+// CancelDeploy cancels a queued deploy request.
+func (d *deployRequestsService) CancelDeploy(ctx context.Context, deployReq *CancelDeployRequestRequest) (*DeployRequest, error) {
+	path := deployRequestActionAPIPath(deployReq.Organization, deployReq.Database, deployReq.Number, "cancel")
+	req, err := d.client.newRequest(http.MethodPost, path, deployReq)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating http request")
+	}
+
+	dr := &DeployRequest{}
+	if err := d.client.do(ctx, req, &dr); err != nil {
+		return nil, err
+	}
+
+	return dr, nil
+}
+
+// Diff returns the diff for a database deploy request
+type Diff struct {
+	Name string `json:"name"`
+	Raw  string `json:"raw"`
+	HTML string `json:"html"`
+}
+
+type diffResponse struct {
+	Diffs []*Diff `json:"data"`
+}
+
+type DiffRequest struct {
+	Organization string `json:"-"`
+	Database     string `json:"-"`
+	Number       uint64 `json:"-"`
+}
+
+// Diff returns a diff
+func (d *deployRequestsService) Diff(ctx context.Context, diffReq *DiffRequest) ([]*Diff, error) {
+	req, err := d.client.newRequest(
+		http.MethodGet,
+		deployRequestActionAPIPath(diffReq.Organization, diffReq.Database, diffReq.Number, "diff"),
+		nil,
+	)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating http request")
+	}
+
+	diffs := &diffResponse{}
+	if err := d.client.do(ctx, req, &diffs); err != nil {
+		return nil, err
+	}
+
+	return diffs.Diffs, nil
+}
+
+func (d *deployRequestsService) List(ctx context.Context, listReq *ListDeployRequestsRequest) ([]*DeployRequest, error) {
+	req, err := d.client.newRequest(http.MethodGet, deployRequestsAPIPath(listReq.Organization, listReq.Database), nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating http request")
+	}
+
+	drReq := &deployRequestsResponse{}
+	if err := d.client.do(ctx, req, &drReq); err != nil {
+		return nil, err
+	}
+
+	return drReq.DeployRequests, nil
+}
+
+func (d *deployRequestsService) CreateReview(ctx context.Context, reviewReq *ReviewDeployRequestRequest) (*DeployRequestReview, error) {
+	var reqBody = struct {
+		State string `json:"state"`
+		Body  string `json:"body"`
+	}{
+		State: reviewReq.ReviewAction.String(),
+		Body:  reviewReq.CommentText,
+	}
+
+	req, err := d.client.newRequest(http.MethodPost,
+		deployRequestActionAPIPath(
+			reviewReq.Organization,
+			reviewReq.Database,
+			reviewReq.Number,
+			"reviews",
+		), reqBody)
+	if err != nil {
+		return nil, errors.Wrap(err, "error creating http request")
+	}
+
+	drr := &DeployRequestReview{}
+	if err := d.client.do(ctx, req, &drr); err != nil {
+		return nil, err
+	}
+
+	return drr, nil
+}
+
+func deployRequestsAPIPath(org, db string) string {
+	return fmt.Sprintf("%s/%s/deploy-requests", databasesAPIPath(org), db)
+}
+
+// deployRequestAPIPath gets the base path for accessing a single deploy request
+func deployRequestAPIPath(org string, db string, number uint64) string {
+	return fmt.Sprintf("%s/%s/deploy-requests/%d", databasesAPIPath(org), db, number)
+}
+
+func deployRequestActionAPIPath(org string, db string, number uint64, path string) string {
+	return fmt.Sprintf("%s/%s", deployRequestAPIPath(org, db, number), path)
+}