ekzyis/snappy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: ekzyis:develop
Branches Tags
ekzyis:develop
ekzyis:v0.8.0
ekzyis:v0.7.0
ekzyis:v0.6.2
ekzyis:v0.6.1
ekzyis:v0.6.0
ekzyis:v0.5.4
ekzyis:v0.5.3
ekzyis:v0.5.2
ekzyis:v0.5.1
ekzyis:v0.5.1rc1
ekzyis:v0.5.0
ekzyis:v0.4.2
ekzyis:v0.4.1
ekzyis:v0.4.0
ekzyis:v0.3.3
ekzyis:v0.3.2
ekzyis:v0.3.1
ekzyis:v0.3.0
ekzyis:v0.2.0
ekzyis:v0.1.1
ekzyis:v0.1.0
..
compare: ekzyis:v0.1.0
Branches Tags
ekzyis:develop
ekzyis:v0.8.0
ekzyis:v0.7.0
ekzyis:v0.6.2
ekzyis:v0.6.1
ekzyis:v0.6.0
ekzyis:v0.5.4
ekzyis:v0.5.3
ekzyis:v0.5.2
ekzyis:v0.5.1
ekzyis:v0.5.1rc1
ekzyis:v0.5.0
ekzyis:v0.4.2
ekzyis:v0.4.1
ekzyis:v0.4.0
ekzyis:v0.3.3
ekzyis:v0.3.2
ekzyis:v0.3.1
ekzyis:v0.3.0
ekzyis:v0.2.0
ekzyis:v0.1.1
ekzyis:v0.1.0

No commits in common. "develop" and "v0.1.0" have entirely different histories.
develop ... v0.1.0

17 changed files with 328 additions and 1170 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1 +0,0 @@
.env

19
README.md
View File

@ -1,19 +0,0 @@
# snappy
<div style="text-align: center">
<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" />
[stacker.news](https://stacker.news) API client package for Go
</div>
## How to use
```
$ go get github.com/ekzyis/snappy
```
`SN_API_KEY` must be set in your environment for authenticated API access.

109
client.go
View File

@ -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
}

132
client_test.go
View File

@ -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)
}
}

46
dupes.go Normal file
View File

@ -0,0 +1,46 @@
package sn
import (
"encoding/json"
"fmt"
)
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
}

7
go.mod
View File

@ -1,5 +1,8 @@
module github.com/ekzyis/snappy module github.com/ekzyis/sn-goapi
go 1.20 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
)

6
go.sum
View File

@ -1,2 +1,4 @@
gopkg.in/guregu/null.v4 v4.0.0 h1:1Wm3S1WEA2I26Kq+6vcW+w0gcDo44YKYD7YIEJNHDjg= github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
gopkg.in/guregu/null.v4 v4.0.0/go.mod h1:YoQhUrADuG3i9WqesrCmpNRwm1ypAgSHYqoOcTu/JrI= 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=

97
invoice.go
View File

@ -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
}

425
items.go
View File

@ -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
}

74
main.go Normal file
View File

@ -0,0 +1,74 @@
package sn
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"log"
"net/http"
"github.com/joho/godotenv"
"github.com/namsral/flag"
)
var (
SnUrl = "https://stacker.news"
SnApiUrl = "https://stacker.news/api/graphql"
// TODO add API key support
// SnApiKey string
SnAuthCookie string
)
func init() {
err := godotenv.Load()
if err != nil {
log.Fatal("error loading .env file")
}
flag.StringVar(&SnAuthCookie, "SN_AUTH_COOKIE", "", "Cookie required for authorizing requests to stacker.news/api/graphql")
flag.Parse()
if SnAuthCookie == "" {
log.Fatal("SN_AUTH_COOKIE not set")
}
}
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
}
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
}
func FormatLink(id int) string {
return fmt.Sprintf("%s/items/%d", SnUrl, id)
}

33
notes.go Normal file
View File

@ -0,0 +1,33 @@
package sn
import (
"encoding/json"
"fmt"
)
func HasNewNotes() (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
}

125
notifications.go
View File

@ -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
}

73
post.go Normal file
View File

@ -0,0 +1,73 @@
package sn
import (
"encoding/json"
"fmt"
)
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
}
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
}

70
rss.go
View File

@ -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
}

93
types.go Normal file
View File

@ -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)
}

131
upload.go
View File

@ -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
}

57
user.go
View File

@ -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
}