planetscale 0.2.0 → 0.3.3

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

@@ -1,305 +0,0 @@
-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

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