planetscale 0.3.1 → 0.3.3

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

@@ -1,368 +0,0 @@
-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)
-}

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

@@ -1,103 +0,0 @@
-package planetscale
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/pkg/errors"
-)
-
-const organizationsAPIPath = "v1/organizations"
-
-// GetOrganizationRequest encapsulates the request for getting a single
-// organization.
-type GetOrganizationRequest struct {
-	Organization string
-}
-
-// OrganizationsService is an interface for communicating with the PlanetScale
-// Organizations API endpoints.
-type OrganizationsService interface {
-	Get(context.Context, *GetOrganizationRequest) (*Organization, error)
-	List(context.Context) ([]*Organization, error)
-	ListRegions(context.Context, *ListOrganizationRegionsRequest) ([]*Region, error)
-}
-
-// ListRegionsRequest encapsulates the request for getting a list of regions for
-// an organization.
-type ListOrganizationRegionsRequest struct {
-	Organization string
-}
-
-// Organization represents a PlanetScale organization.
-type Organization struct {
-	Name      string    `json:"name"`
-	CreatedAt time.Time `json:"created_at"`
-	UpdatedAt time.Time `json:"updated_at"`
-}
-
-type organizationsResponse struct {
-	Organizations []*Organization `json:"data"`
-}
-
-type organizationsService struct {
-	client *Client
-}
-
-var _ OrganizationsService = &organizationsService{}
-
-func NewOrganizationsService(client *Client) *organizationsService {
-	return &organizationsService{
-		client: client,
-	}
-}
-
-// Get fetches a single organization by name.
-func (o *organizationsService) Get(ctx context.Context, getReq *GetOrganizationRequest) (*Organization, error) {
-	req, err := o.client.newRequest(http.MethodGet, fmt.Sprintf("%s/%s", organizationsAPIPath, getReq.Organization), nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "error creating request for get organization")
-	}
-
-	org := &Organization{}
-	if err := o.client.do(ctx, req, &org); err != nil {
-		return nil, err
-	}
-
-	return org, nil
-}
-
-// List returns all the organizations for a user.
-func (o *organizationsService) List(ctx context.Context) ([]*Organization, error) {
-	req, err := o.client.newRequest(http.MethodGet, organizationsAPIPath, nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "error creating request for list organization")
-	}
-
-	orgResponse := &organizationsResponse{}
-	if err := o.client.do(ctx, req, &orgResponse); err != nil {
-		return nil, err
-	}
-
-	return orgResponse.Organizations, nil
-}
-
-type listRegionsResponse struct {
-	Regions []*Region `json:"data"`
-}
-
-func (o *organizationsService) ListRegions(ctx context.Context, listReq *ListOrganizationRegionsRequest) ([]*Region, error) {
-	req, err := o.client.newRequest(http.MethodGet, fmt.Sprintf("%s/%s/regions", organizationsAPIPath, listReq.Organization), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	listResponse := &listRegionsResponse{}
-	if err := o.client.do(ctx, req, &listResponse); err != nil {
-		return nil, err
-	}
-
-	return listResponse.Regions, nil
-}

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

@@ -1,52 +0,0 @@
-package planetscale
-
-import (
-	"context"
-	"net/http"
-
-	"github.com/pkg/errors"
-)
-
-const regionsAPIPath = "v1/regions"
-
-type Region struct {
-	Slug    string `json:"slug"`
-	Name    string `json:"display_name"`
-	Enabled bool   `json:"enabled"`
-}
-
-type regionsResponse struct {
-	Regions []*Region `json:"data"`
-}
-
-type ListRegionsRequest struct{}
-
-type RegionsService interface {
-	List(ctx context.Context, req *ListRegionsRequest) ([]*Region, error)
-}
-
-type regionsService struct {
-	client *Client
-}
-
-var _ RegionsService = &regionsService{}
-
-func NewRegionsSevice(client *Client) *regionsService {
-	return &regionsService{
-		client: client,
-	}
-}
-
-func (r *regionsService) List(ctx context.Context, listReq *ListRegionsRequest) ([]*Region, error) {
-	req, err := r.client.newRequest(http.MethodGet, regionsAPIPath, nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "error creating request for list regions")
-	}
-
-	regionsResponse := &regionsResponse{}
-	if err := r.client.do(ctx, req, &regionsResponse); err != nil {
-		return nil, err
-	}
-
-	return regionsResponse.Regions, nil
-}

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

@@ -1,163 +0,0 @@
-package planetscale
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-)
-
-var _ ServiceTokenService = &serviceTokenService{}
-
-// ServiceTokenService is an interface for communicating with the PlanetScale
-// Service Token API.
-type ServiceTokenService interface {
-	Create(context.Context, *CreateServiceTokenRequest) (*ServiceToken, error)
-	List(context.Context, *ListServiceTokensRequest) ([]*ServiceToken, error)
-	Delete(context.Context, *DeleteServiceTokenRequest) error
-	GetAccess(context.Context, *GetServiceTokenAccessRequest) ([]*ServiceTokenAccess, error)
-	AddAccess(context.Context, *AddServiceTokenAccessRequest) ([]*ServiceTokenAccess, error)
-	DeleteAccess(context.Context, *DeleteServiceTokenAccessRequest) error
-}
-
-type serviceTokenService struct {
-	client *Client
-}
-
-func (s *serviceTokenService) Create(ctx context.Context, createReq *CreateServiceTokenRequest) (*ServiceToken, error) {
-	req, err := s.client.newRequest(http.MethodPost, serviceTokensAPIPath(createReq.Organization), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	st := &ServiceToken{}
-	if err := s.client.do(ctx, req, &st); err != nil {
-		return nil, err
-	}
-
-	return st, nil
-}
-
-func (s *serviceTokenService) List(ctx context.Context, listReq *ListServiceTokensRequest) ([]*ServiceToken, error) {
-	req, err := s.client.newRequest(http.MethodGet, serviceTokensAPIPath(listReq.Organization), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	tokenListResponse := serviceTokensResponse{}
-	if err := s.client.do(ctx, req, &tokenListResponse); err != nil {
-		return nil, err
-	}
-
-	return tokenListResponse.ServiceTokens, nil
-}
-
-func (s *serviceTokenService) Delete(ctx context.Context, delReq *DeleteServiceTokenRequest) error {
-	req, err := s.client.newRequest(http.MethodDelete, serviceTokenAPIPath(delReq.Organization, delReq.ID), nil)
-	if err != nil {
-		return err
-	}
-
-	err = s.client.do(ctx, req, nil)
-	return err
-}
-
-func (s *serviceTokenService) GetAccess(ctx context.Context, accessReq *GetServiceTokenAccessRequest) ([]*ServiceTokenAccess, error) {
-	req, err := s.client.newRequest(http.MethodGet, serviceTokenAccessAPIPath(accessReq.Organization, accessReq.ID), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	tokenAccess := serviceTokenAccessResponse{}
-	if err := s.client.do(ctx, req, &tokenAccess); err != nil {
-		return nil, err
-	}
-	return tokenAccess.ServiceTokenAccesses, nil
-}
-
-func (s *serviceTokenService) AddAccess(ctx context.Context, addReq *AddServiceTokenAccessRequest) ([]*ServiceTokenAccess, error) {
-	req, err := s.client.newRequest(http.MethodPost, serviceTokenAccessAPIPath(addReq.Organization, addReq.ID), addReq)
-	if err != nil {
-		return nil, err
-	}
-
-	tokenAccess := serviceTokenAccessResponse{}
-	if err := s.client.do(ctx, req, &tokenAccess); err != nil {
-		return nil, err
-	}
-	return tokenAccess.ServiceTokenAccesses, nil
-}
-
-func (s *serviceTokenService) DeleteAccess(ctx context.Context, delReq *DeleteServiceTokenAccessRequest) error {
-	req, err := s.client.newRequest(http.MethodDelete, serviceTokenAccessAPIPath(delReq.Organization, delReq.ID), delReq)
-	if err != nil {
-		return err
-	}
-
-	err = s.client.do(ctx, req, nil)
-	return err
-}
-
-type CreateServiceTokenRequest struct {
-	Organization string `json:"-"`
-}
-
-type DeleteServiceTokenRequest struct {
-	Organization string `json:"-"`
-	ID           string `json:"-"`
-}
-
-type ListServiceTokensRequest struct {
-	Organization string `json:"-"`
-}
-
-type GetServiceTokenAccessRequest struct {
-	Organization string `json:"-"`
-	ID           string `json:"-"`
-}
-
-type AddServiceTokenAccessRequest struct {
-	Organization string   `json:"-"`
-	ID           string   `json:"-"`
-	Database     string   `json:"database"`
-	Accesses     []string `json:"access"`
-}
-
-type DeleteServiceTokenAccessRequest struct {
-	Organization string   `json:"-"`
-	ID           string   `json:"-"`
-	Database     string   `json:"database"`
-	Accesses     []string `json:"access"`
-}
-
-type ServiceToken struct {
-	ID    string `json:"id"`
-	Type  string `json:"type"`
-	Token string `json:"token"`
-}
-
-type serviceTokensResponse struct {
-	ServiceTokens []*ServiceToken `json:"data"`
-}
-
-type ServiceTokenAccess struct {
-	ID       string   `json:"id"`
-	Access   string   `json:"access"`
-	Type     string   `json:"type"`
-	Resource Database `json:"resource"`
-}
-
-type serviceTokenAccessResponse struct {
-	ServiceTokenAccesses []*ServiceTokenAccess `json:"data"`
-}
-
-func serviceTokenAccessAPIPath(org, id string) string {
-	return fmt.Sprintf("%s/%s/access", serviceTokensAPIPath(org), id)
-}
-
-func serviceTokensAPIPath(org string) string {
-	return fmt.Sprintf("v1/organizations/%s/service-tokens", org)
-}
-
-func serviceTokenAPIPath(org, id string) string {
-	return fmt.Sprintf("%s/%s", serviceTokensAPIPath(org), id)
-}