feat(integration): add LinkTaco service for saving articles

internal/integration/integration.go

@@ -15,6 +15,7 @@ import (
 	"miniflux.app/v2/internal/integration/karakeep"
 	"miniflux.app/v2/internal/integration/linkace"
 	"miniflux.app/v2/internal/integration/linkding"
+	"miniflux.app/v2/internal/integration/linktaco"
 	"miniflux.app/v2/internal/integration/linkwarden"
 	"miniflux.app/v2/internal/integration/matrixbot"
 	"miniflux.app/v2/internal/integration/notion"
@@ -242,6 +243,29 @@ func SendEntry(entry *model.Entry, userIntegrations *model.Integration) {
 		}
 	}
 
+	if userIntegrations.LinktacoEnabled {
+		slog.Debug("Sending entry to LinkTaco",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.Int64("entry_id", entry.ID),
+			slog.String("entry_url", entry.URL),
+		)
+
+		client := linktaco.NewClient(
+			userIntegrations.LinktacoAPIToken,
+			userIntegrations.LinktacoOrgSlug,
+			userIntegrations.LinktacoTags,
+			userIntegrations.LinktacoVisibility,
+		)
+		if err := client.CreateBookmark(entry.URL, entry.Title, entry.Content); err != nil {
+			slog.Error("Unable to send entry to LinkTaco",
+				slog.Int64("user_id", userIntegrations.UserID),
+				slog.Int64("entry_id", entry.ID),
+				slog.String("entry_url", entry.URL),
+				slog.Any("error", err),
+			)
+		}
+	}
+
 	if userIntegrations.LinkwardenEnabled {
 		slog.Debug("Sending entry to linkwarden",
 			slog.Int64("user_id", userIntegrations.UserID),

internal/integration/linktaco/linktaco.go

@@ -0,0 +1,146 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package linktaco // import "miniflux.app/v2/internal/integration/linktaco"
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"miniflux.app/v2/internal/version"
+)
+
+const (
+	defaultClientTimeout = 10 * time.Second
+	defaultGraphQLURL    = "https://api.linktaco.com/query"
+	maxTags              = 10
+	maxDescriptionLength = 500
+)
+
+type Client struct {
+	graphqlURL string
+	apiToken   string
+	orgSlug    string
+	tags       string
+	visibility string
+}
+
+func NewClient(apiToken, orgSlug, tags, visibility string) *Client {
+	if visibility == "" {
+		visibility = "PUBLIC"
+	}
+	return &Client{
+		graphqlURL: defaultGraphQLURL,
+		apiToken:   apiToken,
+		orgSlug:    orgSlug,
+		tags:       tags,
+		visibility: visibility,
+	}
+}
+
+func (c *Client) CreateBookmark(entryURL, entryTitle, entryContent string) error {
+	if c.apiToken == "" || c.orgSlug == "" {
+		return fmt.Errorf("linktaco: missing API token or organization slug")
+	}
+
+	description := entryContent
+	if len(description) > maxDescriptionLength {
+		description = description[:maxDescriptionLength]
+	}
+
+	// tags (limit to 10)
+	tags := strings.FieldsFunc(c.tags, func(c rune) bool {
+		return c == ',' || c == ' '
+	})
+	if len(tags) > maxTags {
+		tags = tags[:maxTags]
+	}
+	// tagsStr is used in GraphQL query to pass comma separated tags
+	tagsStr := strings.Join(tags, ",")
+
+	mutation := `
+		mutation AddLink($input: LinkInput!) {
+			addLink(input: $input) {
+				id
+				url
+				title
+			}
+		}
+	`
+
+	variables := map[string]any{
+		"input": map[string]any{
+			"url":         entryURL,
+			"title":       entryTitle,
+			"description": description,
+			"orgSlug":     c.orgSlug,
+			"visibility":  c.visibility,
+			"unread":      true,
+			"starred":     false,
+			"archive":     false,
+			"tags":        tagsStr,
+		},
+	}
+
+	requestBody, err := json.Marshal(map[string]any{
+		"query":     mutation,
+		"variables": variables,
+	})
+	if err != nil {
+		return fmt.Errorf("linktaco: unable to encode request body: %v", err)
+	}
+
+	request, err := http.NewRequest(http.MethodPost, c.graphqlURL, bytes.NewReader(requestBody))
+	if err != nil {
+		return fmt.Errorf("linktaco: unable to create request: %v", err)
+	}
+
+	request.Header.Set("Content-Type", "application/json")
+	request.Header.Set("User-Agent", "Miniflux/"+version.Version)
+	request.Header.Set("Authorization", "Bearer "+c.apiToken)
+
+	httpClient := &http.Client{Timeout: defaultClientTimeout}
+	response, err := httpClient.Do(request)
+	if err != nil {
+		return fmt.Errorf("linktaco: unable to send request: %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode >= 400 {
+		return fmt.Errorf("linktaco: unable to create bookmark: status=%d", response.StatusCode)
+	}
+
+	var graphqlResponse struct {
+		Data   json.RawMessage   `json:"data"`
+		Errors []json.RawMessage `json:"errors"`
+	}
+
+	if err := json.NewDecoder(response.Body).Decode(&graphqlResponse); err != nil {
+		return fmt.Errorf("linktaco: unable to decode response: %v", err)
+	}
+
+	if len(graphqlResponse.Errors) > 0 {
+		// Try to extract error message
+		var errorMsg string
+		for _, errJSON := range graphqlResponse.Errors {
+			var errObj struct {
+				Message string `json:"message"`
+			}
+			if json.Unmarshal(errJSON, &errObj) == nil && errObj.Message != "" {
+				errorMsg = errObj.Message
+				break
+			}
+		}
+		if errorMsg == "" {
+			// Fallback. Should never be reached.
+			errorMsg = "GraphQL error occurred (fallback message)"
+		}
+		return fmt.Errorf("linktaco: %s", errorMsg)
+	}
+
+	return nil
+}

internal/integration/linktaco/linktaco_test.go

@@ -0,0 +1,440 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package linktaco
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestCreateBookmark(t *testing.T) {
+	tests := []struct {
+		name           string
+		apiToken       string
+		orgSlug        string
+		tags           string
+		visibility     string
+		entryURL       string
+		entryTitle     string
+		entryContent   string
+		serverResponse func(w http.ResponseWriter, r *http.Request)
+		wantErr        bool
+		errContains    string
+	}{
+		{
+			name:         "successful bookmark creation",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			tags:         "tag1, tag2",
+			visibility:   "PUBLIC",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test Article",
+			entryContent: "Test content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				// Verify authorization header
+				auth := r.Header.Get("Authorization")
+				if auth != "Bearer test-token" {
+					t.Errorf("Expected Authorization header 'Bearer test-token', got %s", auth)
+				}
+
+				// Verify content type
+				contentType := r.Header.Get("Content-Type")
+				if contentType != "application/json" {
+					t.Errorf("Expected Content-Type 'application/json', got %s", contentType)
+				}
+
+				// Parse and verify request
+				body, _ := io.ReadAll(r.Body)
+				var req map[string]interface{}
+				if err := json.Unmarshal(body, &req); err != nil {
+					t.Errorf("Failed to parse request body: %v", err)
+				}
+
+				// Verify mutation exists
+				if _, ok := req["query"]; !ok {
+					t.Error("Missing 'query' field in request")
+				}
+
+				// Return success response
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"data": map[string]interface{}{
+						"addLink": map[string]interface{}{
+							"id":    "123",
+							"url":   "https://example.com",
+							"title": "Test Article",
+						},
+					},
+				})
+			},
+			wantErr: false,
+		},
+		{
+			name:         "missing API token",
+			apiToken:     "",
+			orgSlug:      "test-org",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				// Should not be called
+				t.Error("Server should not be called when API token is missing")
+			},
+			wantErr:     true,
+			errContains: "missing API token or organization slug",
+		},
+		{
+			name:         "missing organization slug",
+			apiToken:     "test-token",
+			orgSlug:      "",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				// Should not be called
+				t.Error("Server should not be called when org slug is missing")
+			},
+			wantErr:     true,
+			errContains: "missing API token or organization slug",
+		},
+		{
+			name:         "GraphQL error response",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"errors": []interface{}{
+						map[string]interface{}{
+							"message": "Invalid input",
+						},
+					},
+				})
+			},
+			wantErr:     true,
+			errContains: "Invalid input",
+		},
+		{
+			name:         "HTTP error status",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusUnauthorized)
+			},
+			wantErr:     true,
+			errContains: "status=401",
+		},
+		{
+			name:         "private visibility permission error",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			visibility:   "PRIVATE",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"errors": []interface{}{
+						map[string]interface{}{
+							"message": "PRIVATE visibility requires a paid LinkTaco account",
+						},
+					},
+				})
+			},
+			wantErr:     true,
+			errContains: "PRIVATE visibility requires a paid LinkTaco account",
+		},
+		{
+			name:         "content truncation",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: strings.Repeat("a", 600), // Content longer than 500 chars
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				body, _ := io.ReadAll(r.Body)
+				var req map[string]interface{}
+				json.Unmarshal(body, &req)
+
+				// Check that description was truncated
+				variables := req["variables"].(map[string]interface{})
+				input := variables["input"].(map[string]interface{})
+				description := input["description"].(string)
+
+				if len(description) != maxDescriptionLength {
+					t.Errorf("Expected description length %d, got %d", maxDescriptionLength, len(description))
+				}
+
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"data": map[string]interface{}{
+						"addLink": map[string]interface{}{"id": "123"},
+					},
+				})
+			},
+			wantErr: false,
+		},
+		{
+			name:         "tag limiting",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			tags:         "tag1,tag2,tag3,tag4,tag5,tag6,tag7,tag8,tag9,tag10,tag11,tag12",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				body, _ := io.ReadAll(r.Body)
+				var req map[string]interface{}
+				json.Unmarshal(body, &req)
+
+				// Check that only 10 tags were sent
+				variables := req["variables"].(map[string]interface{})
+				input := variables["input"].(map[string]interface{})
+				tags := input["tags"].(string)
+
+				tagCount := len(strings.Split(tags, ","))
+				if tagCount != maxTags {
+					t.Errorf("Expected %d tags, got %d", maxTags, tagCount)
+				}
+
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"data": map[string]interface{}{
+						"addLink": map[string]interface{}{"id": "123"},
+					},
+				})
+			},
+			wantErr: false,
+		},
+		{
+			name:         "invalid JSON response",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				w.Write([]byte("invalid json"))
+			},
+			wantErr:     true,
+			errContains: "unable to decode response",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create test server if we have a server response function
+			var serverURL string
+			if tt.serverResponse != nil {
+				server := httptest.NewServer(http.HandlerFunc(tt.serverResponse))
+				defer server.Close()
+				serverURL = server.URL
+			}
+
+			// Create client with test server URL
+			client := &Client{
+				graphqlURL: serverURL,
+				apiToken:   tt.apiToken,
+				orgSlug:    tt.orgSlug,
+				tags:       tt.tags,
+				visibility: tt.visibility,
+			}
+
+			// Call CreateBookmark
+			err := client.CreateBookmark(tt.entryURL, tt.entryTitle, tt.entryContent)
+
+			// Check error expectations
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("Expected error but got none")
+				} else if tt.errContains != "" && !strings.Contains(err.Error(), tt.errContains) {
+					t.Errorf("Expected error containing '%s', got '%s'", tt.errContains, err.Error())
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Unexpected error: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestNewClient(t *testing.T) {
+	tests := []struct {
+		name               string
+		apiToken           string
+		orgSlug            string
+		tags               string
+		visibility         string
+		expectedVisibility string
+	}{
+		{
+			name:               "with all parameters",
+			apiToken:           "token",
+			orgSlug:            "org",
+			tags:               "tag1,tag2",
+			visibility:         "PRIVATE",
+			expectedVisibility: "PRIVATE",
+		},
+		{
+			name:               "empty visibility defaults to PUBLIC",
+			apiToken:           "token",
+			orgSlug:            "org",
+			tags:               "tag1",
+			visibility:         "",
+			expectedVisibility: "PUBLIC",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			client := NewClient(tt.apiToken, tt.orgSlug, tt.tags, tt.visibility)
+
+			if client.apiToken != tt.apiToken {
+				t.Errorf("Expected apiToken %s, got %s", tt.apiToken, client.apiToken)
+			}
+			if client.orgSlug != tt.orgSlug {
+				t.Errorf("Expected orgSlug %s, got %s", tt.orgSlug, client.orgSlug)
+			}
+			if client.tags != tt.tags {
+				t.Errorf("Expected tags %s, got %s", tt.tags, client.tags)
+			}
+			if client.visibility != tt.expectedVisibility {
+				t.Errorf("Expected visibility %s, got %s", tt.expectedVisibility, client.visibility)
+			}
+			if client.graphqlURL != defaultGraphQLURL {
+				t.Errorf("Expected graphqlURL %s, got %s", defaultGraphQLURL, client.graphqlURL)
+			}
+		})
+	}
+}
+
+func TestGraphQLMutation(t *testing.T) {
+	// Test that the GraphQL mutation is properly formatted
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		body, _ := io.ReadAll(r.Body)
+		var req map[string]interface{}
+		if err := json.Unmarshal(body, &req); err != nil {
+			t.Fatalf("Failed to parse request: %v", err)
+		}
+
+		// Verify mutation structure
+		query, ok := req["query"].(string)
+		if !ok {
+			t.Fatal("Missing query field")
+		}
+
+		// Check that mutation contains expected parts
+		if !strings.Contains(query, "mutation AddLink") {
+			t.Error("Mutation should contain 'mutation AddLink'")
+		}
+		if !strings.Contains(query, "$input: LinkInput!") {
+			t.Error("Mutation should contain input parameter")
+		}
+		if !strings.Contains(query, "addLink(input: $input)") {
+			t.Error("Mutation should contain addLink call")
+		}
+
+		// Verify variables structure
+		variables, ok := req["variables"].(map[string]interface{})
+		if !ok {
+			t.Fatal("Missing variables field")
+		}
+
+		input, ok := variables["input"].(map[string]interface{})
+		if !ok {
+			t.Fatal("Missing input in variables")
+		}
+
+		// Check all required fields
+		requiredFields := []string{"url", "title", "description", "orgSlug", "visibility", "unread", "starred", "archive", "tags"}
+		for _, field := range requiredFields {
+			if _, ok := input[field]; !ok {
+				t.Errorf("Missing required field: %s", field)
+			}
+		}
+
+		// Return success
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"data": map[string]interface{}{
+				"addLink": map[string]interface{}{
+					"id": "123",
+				},
+			},
+		})
+	}))
+	defer server.Close()
+
+	client := &Client{
+		graphqlURL: server.URL,
+		apiToken:   "test-token",
+		orgSlug:    "test-org",
+		tags:       "test",
+		visibility: "PUBLIC",
+	}
+
+	err := client.CreateBookmark("https://example.com", "Test Title", "Test Content")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func BenchmarkCreateBookmark(b *testing.B) {
+	// Create a mock server that always returns success
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"data": map[string]interface{}{
+				"addLink": map[string]interface{}{
+					"id": "123",
+				},
+			},
+		})
+	}))
+	defer server.Close()
+
+	client := &Client{
+		graphqlURL: server.URL,
+		apiToken:   "test-token",
+		orgSlug:    "test-org",
+		tags:       "tag1,tag2,tag3",
+		visibility: "PUBLIC",
+	}
+
+	// Run benchmark
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = client.CreateBookmark("https://example.com", "Test Title", "Test Content")
+	}
+}
+
+func BenchmarkTagProcessing(b *testing.B) {
+	// Benchmark tag splitting and limiting
+	tags := "tag1,tag2,tag3,tag4,tag5,tag6,tag7,tag8,tag9,tag10,tag11,tag12,tag13,tag14,tag15"
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		tagsSplitFn := func(c rune) bool {
+			return c == ',' || c == ' '
+		}
+		splitTags := strings.FieldsFunc(tags, tagsSplitFn)
+		if len(splitTags) > maxTags {
+			splitTags = splitTags[:maxTags]
+		}
+		_ = strings.Join(splitTags, ",")
+	}
+}