Check if payment required

* mutations now return { result, invoice, paymentMethod } due to new backend payment optimism

.gitignore

@@ -0,0 +1 @@
+.env

client.go

@@ -9,29 +9,56 @@ import (
 	"os"
 )
 
-type ClientOptions struct {
-	BaseUrl string
-	ApiKey  string
-}
-
 type Client struct {
 	BaseUrl  string
 	ApiUrl   string
 	ApiKey   string
+	MediaUrl string
 }
 
-func NewClient(options *ClientOptions) *Client {
+func NewClient(options ...func(*Client)) *Client {
-	if options.BaseUrl == "" {
+	c := &Client{}
-		options.BaseUrl = "https://stacker.news"
+	for _, o := range options {
-	}
+		o(c)
-	if options.ApiKey == "" {
-		options.ApiKey = os.Getenv("SN_API_KEY")
 	}
 
-	return &Client{
+	// set defaults
-		BaseUrl: options.BaseUrl,
+	var ok bool
-		ApiUrl:  fmt.Sprintf("%s/api/graphql", options.BaseUrl),
+	if c.BaseUrl == "" {
-		ApiKey:  options.ApiKey,
+		c.BaseUrl, ok = os.LookupEnv("SN_BASE_URL")
+		if !ok {
+			c.BaseUrl = "https://stacker.news"
+		}
+	}
+	if c.ApiKey == "" {
+		c.ApiKey = os.Getenv("SN_API_KEY")
+	}
+	if c.MediaUrl == "" {
+		c.MediaUrl, ok = os.LookupEnv("SN_MEDIA_URL")
+		if !ok {
+			c.MediaUrl = "https://m.stacker.news"
+		}
+	}
+	c.ApiUrl = fmt.Sprintf("%s/api/graphql", c.BaseUrl)
+
+	return c
+}
+
+func WithApiKey(apiKey string) func(*Client) {
+	return func(c *Client) {
+		c.ApiKey = apiKey
+	}
+}
+
+func WithBaseUrl(baseUrl string) func(*Client) {
+	return func(c *Client) {
+		c.BaseUrl = baseUrl
+	}
+}
+
+func WithMediaUrl(mediaUrl string) func(*Client) {
+	return func(c *Client) {
+		c.MediaUrl = mediaUrl
 	}
 }
 

client_test.go

@@ -0,0 +1,132 @@
+package sn_test
+
+import (
+	"bufio"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"testing"
+
+	sn "github.com/ekzyis/snappy"
+)
+
+var (
+	c = testClient()
+)
+
+func TestQueryItems(t *testing.T) {
+	var (
+		cursor *sn.ItemsCursor
+		err    error
+	)
+
+	if cursor, err = c.Items(nil); err != nil {
+		t.Error(err)
+		return
+	}
+
+	if len(cursor.Items) == 0 {
+		t.Error("items cursor empty")
+		return
+	}
+}
+
+func TestMutationCreateComment(t *testing.T) {
+	var (
+		parentId = 349
+		text     = "test comment"
+		err      error
+	)
+
+	// TODO: return result, invoice, paymentMethod from CreateComment and run assertions on that
+	if _, err = c.CreateComment(parentId, text); err != nil {
+		t.Error(err)
+		return
+	}
+}
+
+func TestMutationPostDiscussion(t *testing.T) {
+	var (
+		title = "test discussion"
+		text  = "test discussion text"
+		sub   = "bitcoin"
+		err   error
+	)
+
+	// TODO: return result, invoice, paymentMethod from CreateComment and run assertions on that
+	if _, err = c.PostDiscussion(title, text, sub); err != nil {
+		t.Error(err)
+		return
+	}
+}
+
+func TestMutationPostLink(t *testing.T) {
+	var (
+		url   = "https://stacker.news"
+		title = "test discussion"
+		text  = "test discussion text"
+		sub   = "bitcoin"
+		err   error
+	)
+
+	// TODO: return result, invoice, paymentMethod from CreateComment and run assertions on that
+	if _, err = c.PostLink(url, title, text, sub); err != nil {
+		t.Error(err)
+		return
+	}
+}
+
+func testClient() *sn.Client {
+	loadEnv()
+
+	baseUrl, set := os.LookupEnv("TEST_SN_BASE_URL")
+	if !set {
+		baseUrl = "http://localhost:3000"
+	}
+	log.Printf("baseUrl=%s\n", baseUrl)
+
+	apiKey, set := os.LookupEnv("TEST_SN_API_KEY")
+	if !set {
+		log.Fatalf("TEST_SN_API_KEY is not set")
+	}
+	log.Printf("apiKey=%s\n", apiKey)
+
+	return sn.NewClient(
+		sn.WithBaseUrl(baseUrl),
+		sn.WithApiKey(apiKey),
+	)
+}
+
+func loadEnv() {
+	var (
+		f   *os.File
+		s   *bufio.Scanner
+		err error
+	)
+
+	if f, err = os.Open(".env"); err != nil {
+		log.Fatalf("error opening .env: %v", err)
+	}
+	defer f.Close()
+
+	s = bufio.NewScanner(f)
+	s.Split(bufio.ScanLines)
+	for s.Scan() {
+		line := s.Text()
+		parts := strings.SplitN(line, "=", 2)
+
+		// Check if we have exactly 2 parts (key and value)
+		if len(parts) == 2 {
+			os.Setenv(parts[0], parts[1])
+		} else {
+			log.Fatalf(".env: invalid line: %s\n", line)
+		}
+	}
+
+	// Check for errors during scanning
+	if err = s.Err(); err != nil {
+		fmt.Println("error scanning .env:", err)
+	}
+
+}

go.mod

@@ -1,3 +1,5 @@
 module github.com/ekzyis/snappy
 
 go 1.20
+
+require gopkg.in/guregu/null.v4 v4.0.0 // indirect

go.sum

@@ -0,0 +1,2 @@
+gopkg.in/guregu/null.v4 v4.0.0 h1:1Wm3S1WEA2I26Kq+6vcW+w0gcDo44YKYD7YIEJNHDjg=
+gopkg.in/guregu/null.v4 v4.0.0/go.mod h1:YoQhUrADuG3i9WqesrCmpNRwm1ypAgSHYqoOcTu/JrI=

invoice.go

@@ -0,0 +1,97 @@
+package sn
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+type Invoice struct {
+	Id                int                    `json:"id,string"`
+	Hash              string                 `json:"hash"`
+	Hmac              string                 `json:"hmac"`
+	Bolt11            string                 `json:"bolt11"`
+	SatsRequested     int                    `json:"satsRequested"`
+	SatsReceived      int                    `json:"satsReceived"`
+	Cancelled         bool                   `json:"cancelled"`
+	ConfirmedAt       time.Time              `json:"createdAt"`
+	ExpiresAt         time.Time              `json:"expiresAt"`
+	Nostr             map[string]interface{} `json:"nostr"`
+	IsHeld            bool                   `json:"isHeld"`
+	Comment           string                 `json:"comment"`
+	Lud18Data         map[string]interface{} `json:"lud18Data"`
+	ConfirmedPreimage string                 `json:"confirmedPreimage"`
+	ActionState       string                 `json:"actionState"`
+	ActionType        string                 `json:"actionType"`
+}
+
+type PaymentMethod string
+
+const (
+	PaymentMethodFeeCredits  PaymentMethod = "FEE_CREDIT"
+	PaymentMethodOptimistic  PaymentMethod = "OPTIMISTIC"
+	PaymentMethodPessimistic PaymentMethod = "PESSIMISTIC"
+)
+
+type CreateInvoiceArgs struct {
+	Amount      int
+	ExpireSecs  int
+	HodlInvoice bool
+}
+
+type CreateInvoiceResponse struct {
+	Errors []GqlError `json:"errors"`
+	Data   struct {
+		CreateInvoice Invoice `json:"createInvoice"`
+	} `json:"data"`
+}
+
+func (c *Client) CreateInvoice(args *CreateInvoiceArgs) (*Invoice, error) {
+	if args == nil {
+		args = &CreateInvoiceArgs{}
+	}
+
+	body := GqlBody{
+		// TODO: add createdAt
+		//   when I wrote this code, createdAt returned null but is non-nullable
+		//   so I had to remove it.
+		Query: `
+		mutation createInvoice($amount: Int!, $expireSecs: Int, $hodlInvoice: Boolean) {
+			createInvoice(amount: $amount, expireSecs: $expireSecs, hodlInvoice: $hodlInvoice) {
+				id
+				hash
+				hmac
+				bolt11
+				satsRequested
+				satsReceived
+				isHeld
+				comment
+				confirmedPreimage
+				expiresAt
+				confirmedAt
+			}
+		}`,
+		Variables: map[string]interface{}{
+			"amount": args.Amount,
+		},
+	}
+
+	resp, err := c.callApi(body)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var respBody CreateInvoiceResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		err = fmt.Errorf("error decoding items: %w", err)
+		return nil, err
+	}
+
+	err = c.checkForErrors(respBody.Errors)
+	if err != nil {
+		return nil, err
+	}
+	return &respBody.Data.CreateInvoice, nil
+}

items.go

@@ -4,15 +4,19 @@ import (
 	"encoding/json"
 	"fmt"
 	"time"
+
+	"gopkg.in/guregu/null.v4"
 )
 
 type Item struct {
 	Id        int       `json:"id,string"`
-	ParentId  int       `json:"parentId,string"`
+	ParentId  int       `json:"parentId"`
 	Title     string    `json:"title"`
 	Url       string    `json:"url"`
+	Text      string    `json:"text"`
 	Sats      int       `json:"sats"`
 	CreatedAt time.Time `json:"createdAt"`
+	DeletedAt null.Time `json:"deletedAt"`
 	Comments  []Comment `json:"comments"`
 	NComments int       `json:"ncomments"`
 	User      User      `json:"user"`
@@ -20,7 +24,7 @@ type Item struct {
 
 type Comment struct {
 	Id        int       `json:"id,string"`
-	ParentId  int       `json:"parentId,string"`
+	ParentId  int       `json:"parentId"`
 	CreatedAt time.Time `json:"createdAt"`
 	Text      string    `json:"text"`
 	User      User      `json:"user"`
@@ -43,6 +47,13 @@ type ItemsCursor struct {
 	Cursor string `json:"cursor"`
 }
 
+type ItemResponse struct {
+	Errors []GqlError `json:"errors"`
+	Data   struct {
+		Item Item `json:"item"`
+	} `json:"data"`
+}
+
 type ItemsResponse struct {
 	Errors []GqlError `json:"errors"`
 	Data   struct {
@@ -50,24 +61,30 @@ type ItemsResponse struct {
 	} `json:"data"`
 }
 
+type ItemPaidAction struct {
+	Result        Item          `json:"result"`
+	Invoice       Invoice       `json:"invoice"`
+	PaymentMethod PaymentMethod `json:"paymentMethod"`
+}
+
 type UpsertDiscussionResponse struct {
 	Errors []GqlError `json:"errors"`
 	Data   struct {
-		UpsertDiscussion Item `json:"upsertDiscussion"`
+		UpsertDiscussion ItemPaidAction `json:"upsertDiscussion"`
 	} `json:"data"`
 }
 
 type UpsertLinkResponse struct {
 	Errors []GqlError `json:"errors"`
 	Data   struct {
-		UpsertLink Item `json:"upsertLink"`
+		UpsertLink ItemPaidAction `json:"upsertLink"`
 	} `json:"data"`
 }
 
-type CreateCommentsResponse struct {
+type UpsertCommentResponse struct {
 	Errors []GqlError `json:"errors"`
 	Data   struct {
-		CreateComment Comment `json:"createComment"`
+		UpsertComment ItemPaidAction `json:"upsertComment"`
 	} `json:"data"`
 }
 
@@ -93,6 +110,55 @@ type DupesError struct {
 	Dupes []Dupe
 }
 
+func (e *DupesError) Error() string {
+	return fmt.Sprintf("found %d dupes for %s", len(e.Dupes), e.Url)
+}
+
+func (c *Client) Item(id int) (*Item, error) {
+	body := GqlBody{
+		Query: `
+		query item($id: ID!) {
+			item(id: $id) {
+				id
+				parentId
+				title
+				url
+				text
+				sats
+				createdAt
+				deletedAt
+				ncomments
+				user {
+					id
+					name
+				}
+			}
+		}`,
+		Variables: map[string]interface{}{
+			"id": id,
+		},
+	}
+
+	resp, err := c.callApi(body)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var respBody ItemResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		err = fmt.Errorf("error decoding item: %w", err)
+		return nil, err
+	}
+
+	err = c.checkForErrors(respBody.Errors)
+	if err != nil {
+		return nil, err
+	}
+	return &respBody.Data.Item, nil
+}
+
 func (c *Client) Items(query *ItemsQuery) (*ItemsCursor, error) {
 	if query == nil {
 		query = &ItemsQuery{}
@@ -106,42 +172,17 @@ func (c *Client) Items(query *ItemsQuery) (*ItemsCursor, error) {
 				items {
 					id
 					parentId
-					createdAt
-					deletedAt
 					title
 					url
+					text
+					sats
+					createdAt
+					deletedAt
+					ncomments
 					user {
 						id
 						name
 					}
-					otsHash
-					position
-					sats
-					boost
-					bounty
-					bountyPaidTo
-					path
-					upvotes
-					meSats
-					meDontLikeSats
-					meBookmark
-					meSubscription
-					outlawed
-					freebie
-					ncomments
-					commentSats
-					lastCommentAt
-					maxBid
-					isJob
-					company
-					location
-					remote
-					subName
-					pollCost
-					status
-					uploadId
-					mine
-					position
 				},
 			}
 		}`,
@@ -185,8 +226,18 @@ func (c *Client) PostDiscussion(title string, text string, sub string) (int, err
 		Query: `
 		mutation upsertDiscussion($title: String!, $text: String, $sub: String) {
 			upsertDiscussion(title: $title, text: $text, sub: $sub) {
+				result {
 					id
 				}
+				invoice {
+					id
+					hash
+					bolt11
+					satsRequested
+					expiresAt
+				}
+				paymentMethod
+			}
 		}`,
 		Variables: map[string]interface{}{
 			"title": title,
@@ -213,7 +264,12 @@ func (c *Client) PostDiscussion(title string, text string, sub string) (int, err
 		return -1, err
 	}
 
-	return respBody.Data.UpsertDiscussion.Id, nil
+	inv := respBody.Data.UpsertDiscussion.Invoice
+	if inv.Id != 0 {
+		return -1, fmt.Errorf("mutation requires %d sats as payment", inv.SatsRequested)
+	}
+
+	return respBody.Data.UpsertDiscussion.Result.Id, nil
 }
 
 func (c *Client) PostLink(url string, title string, text string, sub string) (int, error) {
@@ -221,8 +277,18 @@ func (c *Client) PostLink(url string, title string, text string, sub string) (in
 		Query: `
 		mutation upsertLink($url: String!, $title: String!, $text: String, $sub: String!) {
 			upsertLink(url: $url, title: $title, text: $text, sub: $sub) {
+				result {
 					id
 				}
+				invoice {
+					id
+					hash
+					bolt11
+					satsRequested
+					expiresAt
+				}
+				paymentMethod
+			}
 		}`,
 		Variables: map[string]interface{}{
 			"url":   url,
@@ -250,7 +316,12 @@ func (c *Client) PostLink(url string, title string, text string, sub string) (in
 		return -1, err
 	}
 
-	return respBody.Data.UpsertLink.Id, nil
+	inv := respBody.Data.UpsertLink.Invoice
+	if inv.Id != 0 {
+		return -1, fmt.Errorf("mutation requires %d sats as payment", inv.SatsRequested)
+	}
+
+	return respBody.Data.UpsertLink.Result.Id, nil
 }
 
 func (c *Client) CreateComment(parentId int, text string) (int, error) {
@@ -258,8 +329,18 @@ func (c *Client) CreateComment(parentId int, text string) (int, error) {
 		Query: `
 		mutation upsertComment($parentId: ID!, $text: String!) {
 			upsertComment(parentId: $parentId, text: $text) {
+				result {
 					id
 				}
+				invoice {
+					id
+					hash
+					bolt11
+					satsRequested
+					expiresAt
+				}
+				paymentMethod
+			}
 		}`,
 		Variables: map[string]interface{}{
 			"parentId": parentId,
@@ -273,7 +354,7 @@ func (c *Client) CreateComment(parentId int, text string) (int, error) {
 	}
 	defer resp.Body.Close()
 
-	var respBody CreateCommentsResponse
+	var respBody UpsertCommentResponse
 	err = json.NewDecoder(resp.Body).Decode(&respBody)
 	if err != nil {
 		err = fmt.Errorf("error decoding upsertComment: %w", err)
@@ -285,7 +366,12 @@ func (c *Client) CreateComment(parentId int, text string) (int, error) {
 		return -1, err
 	}
 
-	return respBody.Data.CreateComment.Id, nil
+	inv := respBody.Data.UpsertComment.Invoice
+	if inv.Id != 0 {
+		return -1, fmt.Errorf("mutation requires %d sats as payment", inv.SatsRequested)
+	}
+
+	return respBody.Data.UpsertComment.Result.Id, nil
 }
 
 func (c *Client) Dupes(url string) (*[]Dupe, error) {

notifications.go

@@ -0,0 +1,125 @@
+package sn
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+type Notification struct {
+	Id   int    `json:"id,string"`
+	Type string `json:"__typename"`
+	Item Item   `json:"item"`
+}
+
+type NotificationsCursor struct {
+	LastChecked   time.Time      `json:"lastChecked"`
+	Cursor        string         `json:"cursor"`
+	Notifications []Notification `json:"notifications"`
+}
+
+type NotificationsResponse struct {
+	Errors []GqlError `json:"errors"`
+	Data   struct {
+		Notifications NotificationsCursor `json:"notifications"`
+	} `json:"data"`
+}
+
+func (c *Client) Notifications() (*NotificationsCursor, error) {
+	body := GqlBody{
+		Query: `
+		fragment ItemFields on Item {
+			id
+			user {
+				id
+				name
+			}
+			parentId
+			createdAt
+			deletedAt
+			title
+			text
+		}
+		query notifications {
+			notifications {
+				lastChecked
+				cursor
+				notifications {
+					__typename
+					... on Reply {
+						id
+						item {
+							...ItemFields
+						}
+					}
+					... on Mention {
+						id
+						item {
+							...ItemFields
+						}
+					}
+				}
+			}
+		}
+		`,
+		Variables: map[string]interface{}{},
+	}
+
+	resp, err := c.callApi(body)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var respBody NotificationsResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		err = fmt.Errorf("error decoding notifications: %w", err)
+		return nil, err
+	}
+
+	err = c.checkForErrors(respBody.Errors)
+	if err != nil {
+		return nil, err
+	}
+	return &respBody.Data.Notifications, nil
+}
+
+func (c *Client) Mentions() ([]Notification, error) {
+	return c.filterNotifications(
+		func(n Notification) bool {
+			return n.Type == "Mention"
+		},
+	)
+}
+
+func (c *Client) Replies() ([]Notification, error) {
+	return c.filterNotifications(
+		func(n Notification) bool {
+			return n.Type == "Reply"
+		},
+	)
+}
+
+func (c *Client) filterNotifications(f func(Notification) bool) ([]Notification, error) {
+	var (
+		n   *NotificationsCursor
+		err error
+	)
+
+	if n, err = c.Notifications(); err != nil {
+		return nil, err
+	}
+
+	return filter(n.Notifications, f), nil
+}
+
+func filter[T any](s []T, f func(T) bool) []T {
+	var r []T
+	for _, v := range s {
+		if f(v) {
+			r = append(r, v)
+		}
+	}
+	return r
+}

snappy/user.go

@@ -1,6 +0,0 @@
-package sn
-
-type User struct {
-	Id   int    `json:"id,string"`
-	Name string `json:"name"`
-}

upload.go

@@ -0,0 +1,131 @@
+package sn
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"image"
+	"image/png"
+	"io"
+	"mime/multipart"
+	"net/http"
+)
+
+type GetSignedPOST struct {
+	Url    string            `json:"url"`
+	Fields map[string]string `json:"fields"`
+}
+
+type GetSignedPOSTResponse struct {
+	Errors []GqlError `json:"errors"`
+	Data   struct {
+		GetSignedPOST GetSignedPOST `json:"getSignedPOST"`
+	} `json:"data"`
+}
+
+func (c *Client) UploadImage(img *image.RGBA) (string, error) {
+	var (
+		b      = img.Bounds()
+		width  = b.Dx()
+		height = b.Dy()
+		type_  = "image/png"
+		size   int
+	)
+
+	var imgBuf bytes.Buffer
+	if err := png.Encode(&imgBuf, img); err != nil {
+		return "", err
+	}
+	size = imgBuf.Len()
+
+	// get signed URL for S3 upload
+	body := GqlBody{
+		Query: `
+		mutation getSignedPOST($type: String!, $size: Int!, $width: Int!, $height: Int!, $avatar: Boolean) {
+			getSignedPOST(type: $type, size: $size, width: $width, height: $height, avatar: $avatar) {
+				url
+				fields
+			}
+		}`,
+		Variables: map[string]interface{}{
+			"type":   type_,
+			"size":   size,
+			"width":  width,
+			"height": height,
+			"avatar": false,
+		},
+	}
+
+	resp, err := c.callApi(body)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	var respBody GetSignedPOSTResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		err = fmt.Errorf("error decoding getSignedPOST: %w", err)
+		return "", err
+	}
+
+	err = c.checkForErrors(respBody.Errors)
+	if err != nil {
+		return "", err
+	}
+
+	s3Url := respBody.Data.GetSignedPOST.Url
+	fields := respBody.Data.GetSignedPOST.Fields
+
+	// create multipart form
+	var (
+		buf bytes.Buffer
+		w   = multipart.NewWriter(&buf)
+		fw  io.Writer
+	)
+
+	for k, v := range fields {
+		if fw, err = w.CreateFormField(k); err != nil {
+			return "", err
+		}
+		fw.Write([]byte(v))
+	}
+
+	for k, v := range map[string]string{
+		"Content-Type":  type_,
+		"Cache-Control": "max-age=31536000",
+		"acl":           "public-read",
+	} {
+		if fw, err = w.CreateFormField(k); err != nil {
+			return "", err
+		}
+		fw.Write([]byte(v))
+	}
+
+	if fw, err = w.CreateFormFile("file", "image.png"); err != nil {
+		return "", err
+	}
+	fw.Write(imgBuf.Bytes())
+
+	if err = w.Close(); err != nil {
+		return "", err
+	}
+
+	// upload to S3
+	var req *http.Request
+	if req, err = http.NewRequest("POST", s3Url, &buf); err != nil {
+		return "", err
+	}
+	req.Header.Set("Content-Type", w.FormDataContentType())
+
+	client := http.DefaultClient
+	if resp, err = client.Do(req); err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	imgId := respBody.Data.GetSignedPOST.Fields["key"]
+	imgUrl := fmt.Sprintf("%s/%s", c.MediaUrl, imgId)
+
+	return imgUrl, nil
+}

user.go

@@ -0,0 +1,57 @@
+package sn
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type User struct {
+	Id       int          `json:"id,string"`
+	Name     string       `json:"name"`
+	Privates UserPrivates `json:"privates"`
+}
+
+type UserPrivates struct {
+	Sats int `json:"sats"`
+}
+
+type MeResponse struct {
+	Errors []GqlError `json:"errors"`
+	Data   struct {
+		Me User `json:"me"`
+	} `json:"data"`
+}
+
+func (c *Client) Me() (*User, error) {
+	body := GqlBody{
+		Query: `
+		query me {
+			me {
+				id
+				name
+				privates {
+					sats
+				}
+			}
+		}`,
+	}
+
+	resp, err := c.callApi(body)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var respBody MeResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		err = fmt.Errorf("error decoding me: %w", err)
+		return nil, err
+	}
+
+	err = c.checkForErrors(respBody.Errors)
+	if err != nil {
+		return nil, err
+	}
+	return &respBody.Data.Me, nil
+}