133 lines
3.1 KiB
Go
133 lines
3.1 KiB
Go
// Copyright © 2020 Mike Berezin
|
|
//
|
|
// Use of this source code is governed by an MIT license.
|
|
// Details in the LICENSE file.
|
|
|
|
package airtable
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
defaultBaseURL = "https://api.airtable.com/v0"
|
|
defaultRateLimit = 4
|
|
)
|
|
|
|
// Client client for airtable api.
|
|
type Client struct {
|
|
Client *http.Client
|
|
BaseURL string
|
|
APIKey string
|
|
rateLimiter <-chan time.Time
|
|
}
|
|
|
|
// New airtable client constructor
|
|
// your API KEY you can get on your account page
|
|
// https://airtable.com/account
|
|
func New(apiKey string) *Client {
|
|
c := &Client{
|
|
Client: http.DefaultClient,
|
|
APIKey: apiKey,
|
|
BaseURL: defaultBaseURL,
|
|
}
|
|
|
|
c.SetRateLimit(defaultRateLimit)
|
|
|
|
return c
|
|
}
|
|
|
|
// SetRateLimit rate limit setter for custom usage
|
|
// Airtable limit is 5 requests per second (we use 4)
|
|
// https://airtable.com/{yourDatabaseID}/api/docs#curl/ratelimits
|
|
func (at *Client) SetRateLimit(rateLimit int) {
|
|
at.rateLimiter = time.Tick(time.Second / time.Duration(rateLimit))
|
|
}
|
|
|
|
func (at *Client) waitForRateLimit() {
|
|
<-at.rateLimiter
|
|
}
|
|
|
|
func (at *Client) get(ctx context.Context, db, table, recordID string, params url.Values, target any) error {
|
|
return at.do(ctx, "GET", db, table, recordID, params, nil, target)
|
|
}
|
|
|
|
func (at *Client) post(ctx context.Context, db, table string, data, target any) error {
|
|
return at.do(ctx, "POST", db, table, "", nil, data, target)
|
|
}
|
|
|
|
func (at *Client) delete(ctx context.Context, db, table string, recordIDs []string, target any) error {
|
|
params := url.Values{}
|
|
|
|
for _, recordID := range recordIDs {
|
|
params.Add("records[]", recordID)
|
|
}
|
|
|
|
return at.do(ctx, "DELETE", db, table, "", params, nil, target)
|
|
}
|
|
|
|
func (at *Client) patch(ctx context.Context, db, table string, data, target any) error {
|
|
return at.do(ctx, "PATCH", db, table, "", nil, data, target)
|
|
}
|
|
|
|
func (at *Client) put(ctx context.Context, db, table string, data, target any) error {
|
|
return at.do(ctx, "PUT", db, table, "", nil, data, target)
|
|
}
|
|
|
|
func (at *Client) do(ctx context.Context, method, db, table, recordID string, params url.Values, data, target any) error {
|
|
var err error
|
|
|
|
at.waitForRateLimit()
|
|
|
|
url := fmt.Sprintf("%s/%s/%s", at.BaseURL, db, table)
|
|
|
|
if recordID != "" {
|
|
url += fmt.Sprintf("/%s", recordID)
|
|
}
|
|
|
|
body := []byte{}
|
|
|
|
if data != nil {
|
|
body, err = json.Marshal(data)
|
|
if err != nil {
|
|
return fmt.Errorf("marshalling message body: %w", err)
|
|
}
|
|
}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, method, url, bytes.NewReader(body))
|
|
if err != nil {
|
|
return fmt.Errorf("cannot create request: %w", err)
|
|
}
|
|
|
|
req.URL.RawQuery = params.Encode()
|
|
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", at.APIKey))
|
|
|
|
resp, err := at.Client.Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("http request failed: %w", err)
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode < 200 || resp.StatusCode > 299 {
|
|
return makeHTTPClientError(url, resp)
|
|
}
|
|
|
|
dec := json.NewDecoder(resp.Body)
|
|
|
|
err = dec.Decode(target)
|
|
if err != nil {
|
|
return fmt.Errorf("json decode failed: %w", err)
|
|
}
|
|
|
|
return nil
|
|
}
|