.gitignore

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

README.md

@@ -1,19 +1,19 @@
-# snappy
+# sn-goapi
 
-<div style="text-align: center">
+Package for [stacker.news](https://stacker.news) API access
 
-<img src="https://stacker.news/favicon.png" width="64" height="64" />
-<img src="https://go.dev/blog/go-brand/Go-Logo/PNG/Go-Logo_Blue.png" width="64" height="64" />
+Install via `go get github.com/ekzyis/sn-goapi`
 
-[stacker.news](https://stacker.news) API client package for Go
+Supports:
 
-</div>
+- [ ] Post of type ...
+  - [ ] ... Discussion
+  - [x] ... Link
+  - [ ] ... Bounty
+  - [ ] ... Poll
+- [x] Reply (comments)
+- [ ] Tips
+- [x] Checking dupes
+- [x] Checking notifications
 
-
-## How to use
-
-```
-$ go get github.com/ekzyis/snappy
-```
-
-`SN_API_KEY` must be set in your environment for authenticated API access.
+`SN_AUTH_COOKIE` must be set with a valid session cookie.

client.go

@@ -1,109 +0,0 @@
-package sn
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-	"os"
-)
-
-type Client struct {
-	BaseUrl  string
-	ApiUrl   string
-	ApiKey   string
-	MediaUrl string
-}
-
-func NewClient(options ...func(*Client)) *Client {
-	c := &Client{}
-	for _, o := range options {
-		o(c)
-	}
-
-	// set defaults
-	var ok bool
-	if c.BaseUrl == "" {
-		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
-	}
-}
-
-type GqlBody struct {
-	Query     string                 `json:"query"`
-	Variables map[string]interface{} `json:"variables,omitempty"`
-}
-
-type GqlError struct {
-	Message string `json:"message"`
-}
-
-func (c *Client) callApi(body GqlBody) (*http.Response, error) {
-	bodyJSON, err := json.Marshal(body)
-	if err != nil {
-		err = fmt.Errorf("error encoding SN payload: %w", err)
-		return nil, err
-	}
-
-	req, err := http.NewRequest("POST", c.ApiUrl, bytes.NewBuffer(bodyJSON))
-	if err != nil {
-		err = fmt.Errorf("error preparing SN request: %w", err)
-		return nil, err
-	}
-	req.Header.Set("Content-Type", "application/json")
-	if c.ApiKey != "" {
-		req.Header.Set("X-Api-Key", c.ApiKey)
-	}
-
-	client := http.DefaultClient
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-
-	return resp, nil
-}
-
-func (c *Client) checkForErrors(err []GqlError) error {
-	if len(err) > 0 {
-		errMsg, marshalErr := json.Marshal(err)
-		if marshalErr != nil {
-			return marshalErr
-		}
-		return errors.New(string(errMsg))
-	}
-	return nil
-}

client_test.go

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

dupes.go

@@ -0,0 +1,47 @@
+package sn
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// Fetch dupes
+func Dupes(url string) (*[]Dupe, error) {
+	body := GraphQLPayload{
+		Query: `
+			query Dupes($url: String!) {
+				dupes(url: $url) {
+					id
+					url
+					title
+					user {
+						name
+					}
+					createdAt
+					sats
+					ncomments
+				}
+			}`,
+		Variables: map[string]interface{}{
+			"url": url,
+		},
+	}
+	resp, err := MakeStackerNewsRequest(body)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var respBody DupesResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		err = fmt.Errorf("error decoding SN dupes: %w", err)
+		return nil, err
+	}
+	err = CheckForErrors(respBody.Errors)
+	if err != nil {
+		return nil, err
+	}
+
+	return &respBody.Data.Dupes, nil
+}

go.mod

@@ -1,5 +1,8 @@
-module github.com/ekzyis/snappy
+module github.com/ekzyis/sn-goapi
 
 go 1.20
 
-require gopkg.in/guregu/null.v4 v4.0.0 // indirect
+require (
+	github.com/joho/godotenv v1.5.1 // indirect
+	github.com/namsral/flag v1.7.4-pre // indirect
+)

go.sum

@@ -1,2 +1,4 @@
-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=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/namsral/flag v1.7.4-pre h1:b2ScHhoCUkbsq0d2C15Mv+VU8bl8hAXV8arnWiOHNZs=
+github.com/namsral/flag v1.7.4-pre/go.mod h1:OXldTctbM6SWH1K899kPZcf65KxJiD7MsceFUpB5yDo=

invoice.go

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

@@ -1,425 +0,0 @@
-package sn
-
-import (
-	"encoding/json"
-	"fmt"
-	"time"
-
-	"gopkg.in/guregu/null.v4"
-)
-
-type Item struct {
-	Id        int       `json:"id,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"`
-}
-
-type Comment struct {
-	Id        int       `json:"id,string"`
-	ParentId  int       `json:"parentId"`
-	CreatedAt time.Time `json:"createdAt"`
-	Text      string    `json:"text"`
-	User      User      `json:"user"`
-	Comments  []Comment `json:"comments"`
-}
-
-type ItemsQuery struct {
-	Sub    string
-	Sort   string
-	Type   string
-	Cursor string
-	Name   string
-	When   string
-	By     string
-	Limit  int
-}
-
-type ItemsCursor struct {
-	Items  []Item `json:"items"`
-	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 {
-		Items ItemsCursor `json:"items"`
-	} `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 ItemPaidAction `json:"upsertDiscussion"`
-	} `json:"data"`
-}
-
-type UpsertLinkResponse struct {
-	Errors []GqlError `json:"errors"`
-	Data   struct {
-		UpsertLink ItemPaidAction `json:"upsertLink"`
-	} `json:"data"`
-}
-
-type UpsertCommentResponse struct {
-	Errors []GqlError `json:"errors"`
-	Data   struct {
-		UpsertComment ItemPaidAction `json:"upsertComment"`
-	} `json:"data"`
-}
-
-type Dupe struct {
-	Id        int       `json:"id,string"`
-	Url       string    `json:"url"`
-	Title     string    `json:"title"`
-	User      User      `json:"user"`
-	CreatedAt time.Time `json:"createdAt"`
-	Sats      int       `json:"sats"`
-	NComments int       `json:"ncomments"`
-}
-
-type DupesResponse struct {
-	Errors []GqlError `json:"errors"`
-	Data   struct {
-		Dupes []Dupe `json:"dupes"`
-	} `json:"data"`
-}
-
-type DupesError struct {
-	Url   string
-	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{}
-	}
-
-	body := GqlBody{
-		Query: `
-		query items($sub: String, $sort: String, $cursor: String, $type: String, $name: String, $when: String, $by: String, $limit: Limit) {
-			items(sub: $sub, sort: $sort, cursor: $cursor, type: $type, name: $name, when: $when, by: $by, limit: $limit) {
-				cursor
-				items {
-					id
-					parentId
-					title
-					url
-					text
-					sats
-					createdAt
-					deletedAt
-					ncomments
-					user {
-						id
-						name
-					}
-				},
-			}
-		}`,
-		Variables: map[string]interface{}{
-			"sub":    query.Sub,
-			"sort":   query.Sort,
-			"type":   query.Type,
-			"cursor": query.Cursor,
-			"name":   query.Name,
-			"when":   query.When,
-			"by":     query.By,
-			"limit":  query.Limit,
-		},
-	}
-	if query.Limit == 0 {
-		body.Variables["limit"] = 21
-	}
-
-	resp, err := c.callApi(body)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	var respBody ItemsResponse
-	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.Items, nil
-}
-
-func (c *Client) PostDiscussion(title string, text string, sub string) (int, error) {
-	body := GqlBody{
-		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,
-			"text":  text,
-			"sub":   sub,
-		},
-	}
-
-	resp, err := c.callApi(body)
-	if err != nil {
-		return -1, err
-	}
-	defer resp.Body.Close()
-
-	var respBody UpsertDiscussionResponse
-	err = json.NewDecoder(resp.Body).Decode(&respBody)
-	if err != nil {
-		err = fmt.Errorf("error decoding upsertDiscussion: %w", err)
-		return -1, err
-	}
-
-	err = c.checkForErrors(respBody.Errors)
-	if err != nil {
-		return -1, err
-	}
-
-	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) {
-	body := GqlBody{
-		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,
-			"title": title,
-			"text":  text,
-			"sub":   sub,
-		},
-	}
-
-	resp, err := c.callApi(body)
-	if err != nil {
-		return -1, err
-	}
-	defer resp.Body.Close()
-
-	var respBody UpsertLinkResponse
-	err = json.NewDecoder(resp.Body).Decode(&respBody)
-	if err != nil {
-		err = fmt.Errorf("error decoding upsertLink: %w", err)
-		return -1, err
-	}
-
-	err = c.checkForErrors(respBody.Errors)
-	if err != nil {
-		return -1, err
-	}
-
-	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) {
-	body := GqlBody{
-		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,
-			"text":     text,
-		},
-	}
-
-	resp, err := c.callApi(body)
-	if err != nil {
-		return -1, err
-	}
-	defer resp.Body.Close()
-
-	var respBody UpsertCommentResponse
-	err = json.NewDecoder(resp.Body).Decode(&respBody)
-	if err != nil {
-		err = fmt.Errorf("error decoding upsertComment: %w", err)
-		return -1, err
-	}
-
-	err = c.checkForErrors(respBody.Errors)
-	if err != nil {
-		return -1, err
-	}
-
-	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) {
-	body := GqlBody{
-		Query: `
-		query Dupes($url: String!) {
-			dupes(url: $url) {
-				id
-				url
-				title
-				user {
-					name
-				}
-				createdAt
-				sats
-				ncomments
-			}
-		}`,
-		Variables: map[string]interface{}{
-			"url": url,
-		},
-	}
-	resp, err := c.callApi(body)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	var respBody DupesResponse
-	err = json.NewDecoder(resp.Body).Decode(&respBody)
-	if err != nil {
-		err = fmt.Errorf("error decoding dupes: %w", err)
-		return nil, err
-	}
-
-	err = c.checkForErrors(respBody.Errors)
-	if err != nil {
-		return nil, err
-	}
-
-	return &respBody.Data.Dupes, nil
-}
-
-func (c *Client) HasDupes(url string) (bool, error) {
-	dupes, err := c.Dupes(url)
-	if err != nil {
-		return false, err
-	}
-
-	return len(*dupes) > 0, nil
-}

main.go

@@ -0,0 +1,81 @@
+// Package for stacker.news API access
+package sn
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/joho/godotenv"
+	"github.com/namsral/flag"
+)
+
+var (
+	// stacker.news URL
+	SnUrl = "https://stacker.news"
+	// stacker.news API URL
+	SnApiUrl = "https://stacker.news/api/graphql"
+	// stacker.news session cookie
+	SnAuthCookie string
+	// TODO add API key support
+	// SnApiKey string
+)
+
+func init() {
+	err := godotenv.Load()
+	if err != nil {
+		log.Fatal("error loading .env file")
+	}
+	flag.StringVar(&SnAuthCookie, "SN_AUTH_COOKIE", "", "Cookie required for authentication requests to stacker.news/api/graphql")
+	flag.Parse()
+	if SnAuthCookie == "" {
+		log.Fatal("SN_AUTH_COOKIE not set")
+	}
+}
+
+// Make GraphQL request using raw payload
+func MakeStackerNewsRequest(body GraphQLPayload) (*http.Response, error) {
+	bodyJSON, err := json.Marshal(body)
+	if err != nil {
+		err = fmt.Errorf("error encoding SN payload: %w", err)
+		return nil, err
+	}
+
+	req, err := http.NewRequest("POST", SnApiUrl, bytes.NewBuffer(bodyJSON))
+	if err != nil {
+		err = fmt.Errorf("error preparing SN request: %w", err)
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	req.Header.Set("Cookie", SnAuthCookie)
+
+	client := http.DefaultClient
+	resp, err := client.Do(req)
+	if err != nil {
+		err = fmt.Errorf("error posting SN payload: %w", err)
+		return nil, err
+	}
+
+	return resp, nil
+}
+
+// Returns error if any error was found
+func CheckForErrors(graphqlErrors []GraphQLError) error {
+	if len(graphqlErrors) > 0 {
+		errorMsg, marshalErr := json.Marshal(graphqlErrors)
+		if marshalErr != nil {
+			return marshalErr
+		}
+		return errors.New(string(errorMsg))
+	}
+	return nil
+}
+
+// Format item id as link
+func FormatLink(id int) string {
+	return fmt.Sprintf("%s/items/%d", SnUrl, id)
+}

notes.go

@@ -0,0 +1,34 @@
+package sn
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// Check for new notifications
+func CheckNotifications() (bool, error) {
+	body := GraphQLPayload{
+		Query: `
+			{
+				hasNewNotes
+			}`,
+	}
+	resp, err := MakeStackerNewsRequest(body)
+	if err != nil {
+		return false, err
+	}
+	defer resp.Body.Close()
+
+	var respBody HasNewNotesResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		err = fmt.Errorf("error decoding SN hasNewNotes: %w", err)
+		return false, err
+	}
+	err = CheckForErrors(respBody.Errors)
+	if err != nil {
+		return false, err
+	}
+
+	return respBody.Data.HasNewNotes, nil
+}

notifications.go

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

post.go

@@ -0,0 +1,75 @@
+package sn
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// Create a new LINK post
+func PostLink(url string, title string, sub string) (int, error) {
+	body := GraphQLPayload{
+		Query: `
+	 		mutation upsertLink($url: String!, $title: String!, $sub: String!) {
+	 			upsertLink(url: $url, title: $title, sub: $sub) {
+	 				id
+	 			}
+	 		}`,
+		Variables: map[string]interface{}{
+			"url":   url,
+			"title": title,
+			"sub":   sub,
+		},
+	}
+	resp, err := MakeStackerNewsRequest(body)
+	if err != nil {
+		return -1, err
+	}
+	defer resp.Body.Close()
+
+	var respBody UpsertLinkResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		err = fmt.Errorf("error decoding SN upsertLink: %w", err)
+		return -1, err
+	}
+	err = CheckForErrors(respBody.Errors)
+	if err != nil {
+		return -1, err
+	}
+	itemId := respBody.Data.UpsertLink.Id
+	return itemId, nil
+}
+
+// Create a new comment
+func CreateComment(parentId int, text string) (int, error) {
+	body := GraphQLPayload{
+		Query: `
+			mutation createComment($text: String!, $parentId: ID!) {
+        createComment(text: $text, parentId: $parentId) {
+          id
+        }
+			}`,
+		Variables: map[string]interface{}{
+			"text":     text,
+			"parentId": parentId,
+		},
+	}
+	resp, err := MakeStackerNewsRequest(body)
+	if err != nil {
+		return -1, err
+	}
+	defer resp.Body.Close()
+
+	var respBody CreateCommentsResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		err = fmt.Errorf("error decoding SN createComment: %w", err)
+		return -1, err
+	}
+	err = CheckForErrors(respBody.Errors)
+	if err != nil {
+		return -1, err
+	}
+
+	return parentId, nil
+}

rss.go

@@ -1,70 +0,0 @@
-package sn
-
-import (
-	"encoding/xml"
-	"fmt"
-	"log"
-	"net/http"
-	"time"
-)
-
-type RssItem struct {
-	Guid        string    `xml:"guid"`
-	Title       string    `xml:"title"`
-	Link        string    `xml:"link"`
-	Description string    `xml:"description"`
-	PubDate     RssDate   `xml:"pubDate"`
-	Author      RssAuthor `xml:"author"`
-}
-
-type RssChannel struct {
-	Title         string    `xml:"title"`
-	Description   string    `xml:"description"`
-	Link          string    `xml:"link"`
-	Items         []RssItem `xml:"item"`
-	LastBuildDate RssDate   `xml:"lastBuildDate"`
-}
-
-type Rss struct {
-	Channel RssChannel `xml:"channel"`
-}
-
-type RssDate struct {
-	time.Time
-}
-
-type RssAuthor struct {
-	Name string `xml:"name"`
-}
-
-func (c *RssDate) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
-	var v string
-	dateFormat := "Mon, 02 Jan 2006 15:04:05 GMT"
-	d.DecodeElement(&v, &start)
-	parse, err := time.Parse(dateFormat, v)
-	if err != nil {
-		return err
-	}
-	*c = RssDate{parse}
-	return nil
-}
-
-func (c *Client) GetRssFeed() (*Rss, error) {
-	url := fmt.Sprintf("%s/rss", c.BaseUrl)
-	resp, err := http.Get(url)
-	if err != nil {
-		err = fmt.Errorf("error fetching RSS feed: %w", err)
-		log.Println(err)
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	var rss Rss
-	err = xml.NewDecoder(resp.Body).Decode(&rss)
-	if err != nil {
-		err = fmt.Errorf("error decoding RSS feed XML: %w", err)
-		return nil, err
-	}
-
-	return &rss, nil
-}

types.go

@@ -0,0 +1,93 @@
+package sn
+
+import (
+	"fmt"
+	"time"
+)
+
+type GraphQLPayload struct {
+	Query     string                 `json:"query"`
+	Variables map[string]interface{} `json:"variables,omitempty"`
+}
+
+type GraphQLError struct {
+	Message string `json:"message"`
+}
+
+type User struct {
+	Name string `json:"name"`
+}
+
+type Comment struct {
+	Id       int       `json:"id,string"`
+	Text     string    `json:"text"`
+	User     User      `json:"user"`
+	Comments []Comment `json:"comments"`
+}
+
+type CreateCommentsResponse struct {
+	Errors []GraphQLError `json:"errors"`
+	Data   struct {
+		CreateComment Comment `json:"createComment"`
+	} `json:"data"`
+}
+
+type Item struct {
+	Id        int       `json:"id,string"`
+	Title     string    `json:"title"`
+	Url       string    `json:"url"`
+	Sats      int       `json:"sats"`
+	CreatedAt time.Time `json:"createdAt"`
+	Comments  []Comment `json:"comments"`
+	NComments int       `json:"ncomments"`
+}
+
+type UpsertLinkResponse struct {
+	Errors []GraphQLError `json:"errors"`
+	Data   struct {
+		UpsertLink Item `json:"upsertLink"`
+	} `json:"data"`
+}
+
+type ItemsResponse struct {
+	Errors []GraphQLError `json:"errors"`
+	Data   struct {
+		Items struct {
+			Items  []Item `json:"items"`
+			Cursor string `json:"cursor"`
+		} `json:"items"`
+	} `json:"data"`
+}
+
+type HasNewNotesResponse struct {
+	Errors []GraphQLError `json:"errors"`
+	Data   struct {
+		HasNewNotes bool `json:"hasNewNotes"`
+	} `json:"data"`
+}
+
+type Dupe struct {
+	Id        int       `json:"id,string"`
+	Url       string    `json:"url"`
+	Title     string    `json:"title"`
+	User      User      `json:"user"`
+	CreatedAt time.Time `json:"createdAt"`
+	Sats      int       `json:"sats"`
+	NComments int       `json:"ncomments"`
+}
+
+type DupesResponse struct {
+	Errors []GraphQLError `json:"errors"`
+	Data   struct {
+		Dupes []Dupe `json:"dupes"`
+	} `json:"data"`
+}
+
+type DupesError struct {
+	Url   string
+	Dupes []Dupe
+}
+
+func (e *DupesError) Error() string {
+	return fmt.Sprintf("found %d dupes for %s", len(e.Dupes), e.Url)
+}

upload.go

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

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