extract from cli

Author: notnmeyer

.github/workflows/release.yml

@@ -0,0 +1,21 @@
+name: release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-go@v6
+        with:
+          go-version-file: go.mod
+      - env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh release create "$GITHUB_REF_NAME" --generate-notes

.github/workflows/test.yml

@@ -0,0 +1,18 @@
+name: test
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-go@v6
+        with:
+          go-version-file: go.mod
+      - uses: go-task/setup-task@v2
+      - run: task test

.github/workflows/vuln.yml

@@ -0,0 +1,16 @@
+name: vuln
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  vuln:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-go@v6
+        with:
+          go-version-file: go.mod
+      - uses: go-task/setup-task@v2
+      - run: task vuln

Taskfile.yml

@@ -0,0 +1,31 @@
+# https://taskfile.dev
+
+version: "3"
+
+tasks:
+  deps:
+    desc: install/update deps
+    cmds:
+      - go mod tidy
+
+  test:
+    desc: run tests
+    aliases: [t]
+    cmds:
+      - go test ./... -cover
+
+  vuln:
+    desc: run govulncheck
+    aliases: [v]
+    cmds:
+      - go tool govulncheck {{.CLI_ARGS}} ./...
+
+  release:
+    desc: tag a new sdk version
+    requires:
+      vars:
+        - tag
+    cmds:
+      - git pull --rebase
+      - git tag {{.tag}}
+      - git push origin {{.tag}}

api_key.go

@@ -0,0 +1,35 @@
+package loops
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+type APIKeyResponse struct {
+	TeamName string `json:"teamName"`
+}
+
+func (c *Client) GetAPIKey() (*APIKeyResponse, error) {
+	req, err := c.newRequest(http.MethodGet, "/api-key", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := c.do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, errorFromResponse(resp)
+	}
+
+	var result APIKeyResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return &result, nil
+}

api_key_test.go

@@ -0,0 +1,89 @@
+package loops
+
+import (
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestGetAPIKey(t *testing.T) {
+	tests := []struct {
+		name          string
+		statusCode    int
+		body          string
+		wantAPIErr    *APIError
+		wantErrMsg    string
+		wantTeam      string
+	}{
+		{
+			name:       "success",
+			statusCode: http.StatusOK,
+			body:       `{"teamName":"Acme"}`,
+			wantTeam:   "Acme",
+		},
+		{
+			name:       "unauthorized",
+			statusCode: http.StatusUnauthorized,
+			body:       `{"success":false,"error":"Invalid API key"}`,
+			wantAPIErr: &APIError{StatusCode: http.StatusUnauthorized, Message: "Invalid API key"},
+		},
+		{
+			name:       "unexpected status",
+			statusCode: http.StatusInternalServerError,
+			body:       ``,
+			wantAPIErr: &APIError{StatusCode: http.StatusInternalServerError},
+		},
+		{
+			name:       "invalid json",
+			statusCode: http.StatusOK,
+			body:       `not json`,
+			wantErrMsg: "failed to decode response",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(tt.statusCode)
+				w.Write([]byte(tt.body))
+			}))
+			defer server.Close()
+
+			client := NewClient("test-key", WithBaseURL(server.URL))
+			result, err := client.GetAPIKey()
+
+			if tt.wantAPIErr != nil {
+				var apiErr *APIError
+				if !errors.As(err, &apiErr) {
+					t.Fatalf("expected *APIError, got %T: %v", err, err)
+				}
+				if apiErr.StatusCode != tt.wantAPIErr.StatusCode {
+					t.Errorf("StatusCode = %d, want %d", apiErr.StatusCode, tt.wantAPIErr.StatusCode)
+				}
+				if tt.wantAPIErr.Message != "" && apiErr.Message != tt.wantAPIErr.Message {
+					t.Errorf("Message = %q, want %q", apiErr.Message, tt.wantAPIErr.Message)
+				}
+				return
+			}
+
+			if tt.wantErrMsg != "" {
+				if err == nil {
+					t.Fatalf("expected error containing %q, got nil", tt.wantErrMsg)
+				}
+				if !strings.Contains(err.Error(), tt.wantErrMsg) {
+					t.Errorf("error = %q, want it to contain %q", err.Error(), tt.wantErrMsg)
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if result.TeamName != tt.wantTeam {
+				t.Errorf("TeamName = %q, want %q", result.TeamName, tt.wantTeam)
+			}
+		})
+	}
+}

campaigns.go

@@ -0,0 +1,179 @@
+package loops
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+type Campaign struct {
+	CampaignID     string  `json:"campaignId"`
+	EmailMessageID *string `json:"emailMessageId"`
+	Name           string  `json:"name"`
+	Status         string  `json:"status"`
+	CreatedAt      string  `json:"createdAt"`
+	UpdatedAt      string  `json:"updatedAt"`
+}
+
+type CampaignListItem struct {
+	CampaignID     string  `json:"campaignId"`
+	EmailMessageID *string `json:"emailMessageId"`
+	Name           string  `json:"name"`
+	Subject        string  `json:"subject"`
+	Status         string  `json:"status"`
+	CreatedAt      string  `json:"createdAt"`
+	UpdatedAt      string  `json:"updatedAt"`
+}
+
+type LmxWarning struct {
+	Rule     string `json:"rule"`
+	Severity string `json:"severity"`
+	Message  string `json:"message"`
+	Path     string `json:"path,omitempty"`
+}
+
+type EmailMessageFields struct {
+	Subject      string `json:"subject,omitempty"`
+	PreviewText  string `json:"previewText,omitempty"`
+	FromName     string `json:"fromName,omitempty"`
+	FromEmail    string `json:"fromEmail,omitempty"`
+	ReplyToEmail string `json:"replyToEmail,omitempty"`
+	LMX          string `json:"lmx,omitempty"`
+}
+
+type CreateCampaignRequest struct {
+	Name string `json:"name"`
+}
+
+type UpdateCampaignRequest struct {
+	Name string `json:"name"`
+}
+
+type CampaignCreateResponse struct {
+	Campaign
+	EmailMessageContentRevisionID *string `json:"emailMessageContentRevisionId"`
+}
+
+func (c *Client) CreateCampaign(req CreateCampaignRequest) (*CampaignCreateResponse, error) {
+	b, err := json.Marshal(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to encode request: %w", err)
+	}
+
+	httpReq, err := c.newRequest(http.MethodPost, "/campaigns", bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := c.do(httpReq)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusCreated {
+		return nil, errorFromResponse(resp)
+	}
+
+	var result CampaignCreateResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return &result, nil
+}
+
+func (c *Client) UpdateCampaign(id string, req UpdateCampaignRequest) (*Campaign, error) {
+	b, err := json.Marshal(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to encode request: %w", err)
+	}
+
+	httpReq, err := c.newRequest(http.MethodPost, "/campaigns/"+id, bytes.NewReader(b))
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := c.do(httpReq)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, errorFromResponse(resp)
+	}
+
+	var result Campaign
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return &result, nil
+}
+
+func (c *Client) GetCampaign(id string) (*Campaign, error) {
+	req, err := c.newRequest(http.MethodGet, "/campaigns/"+id, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := c.do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, errorFromResponse(resp)
+	}
+
+	var result Campaign
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return &result, nil
+}
+
+func (c *Client) ListCampaigns(params PaginationParams) ([]CampaignListItem, *Pagination, error) {
+	q := url.Values{}
+	if params.PerPage != "" {
+		q.Set("perPage", params.PerPage)
+	}
+	if params.Cursor != "" {
+		q.Set("cursor", params.Cursor)
+	}
+
+	path := "/campaigns"
+	if len(q) > 0 {
+		path += "?" + q.Encode()
+	}
+
+	req, err := c.newRequest(http.MethodGet, path, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resp, err := c.do(req)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, nil, errorFromResponse(resp)
+	}
+
+	var result struct {
+		Pagination Pagination         `json:"pagination"`
+		Data       []CampaignListItem `json:"data"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return result.Data, &result.Pagination, nil
+}