package store import ( "context" "crypto/sha256" "database/sql" "encoding/json" "errors" "fmt" "net/url" "sort" "strings" "unicode/utf8" "github.com/google/uuid" ) type FeedSubscription struct { Title string `json:"title"` Folder string `json:"folder"` URL string `json:"url"` } // Only normalize syntactic equivalence; never reorder query parameters, change // path case or follow redirects to decide identity. func FeedURLKey(raw string) string { u, err := url.Parse(strings.TrimSpace(raw)) if err != nil { return raw } u.Scheme = strings.ToLower(u.Scheme) u.Host = strings.ToLower(u.Host) if u.Scheme == "https" && u.Port() == "443" { u.Host = strings.TrimSuffix(u.Host, ":443") } if u.Path == "" { u.Path = "/" } u.Fragment = "" return u.String() } func FeedSourcesSnapshot(sources []FeedSource) string { versions := make([]string, 0, len(sources)) for _, s := range sources { versions = append(versions, fmt.Sprintf("%s:%d", s.UUID, s.Version)) } sort.Strings(versions) return fmt.Sprintf("%x", sha256.Sum256([]byte(strings.Join(versions, "\n")))) } type FeedImport struct { RequestID string `json:"request_id"` Expected string `json:"expected"` Entries []FeedSubscription `json:"entries"` Enabled bool `json:"enabled"` Interval int `json:"interval_seconds"` } // Append-only import: source inserts and the durable retry receipt commit as a // unit. A retry after later source deletion returns its receipt, never resurrects // the deleted subscription. Authorization is checked even on receipt replay. func (s *Store) ImportFeedSubscriptions(ctx context.Context, domain, owner string, input FeedImport) ([]string, error) { if _, err := uuid.Parse(input.RequestID); err != nil { return nil, ErrTaskInvalid } if len(input.Expected) != 64 || len(input.Entries) == 0 || len(input.Entries) > 32 || input.Interval < 300 || input.Interval > 86400 { return nil, ErrTaskInvalid } keys := map[string]bool{} for _, entry := range input.Entries { u, err := url.Parse(entry.URL) if err != nil || u.Scheme != "https" || u.Hostname() == "" || u.User != nil || u.Fragment != "" || (u.Port() != "" && u.Port() != "443") || len(entry.URL) > 4096 || strings.TrimSpace(entry.Title) == "" || len(entry.Title) > 200 || len(entry.Folder) > 200 || !utf8.ValidString(entry.Title+entry.Folder+entry.URL) { return nil, ErrTaskInvalid } key := FeedURLKey(entry.URL) if keys[key] { return nil, ErrTaskInvalid } keys[key] = true } raw, _ := json.Marshal(input) hash := fmt.Sprintf("%x", sha256.Sum256(raw)) ids := []string{} err := s.feedWrite(ctx, domain, owner, func(tx *sql.Tx) error { var oldHash, result string err := tx.QueryRowContext(ctx, `SELECT input_hash,result FROM feed_import_receipts WHERE domain_uuid=? AND owner_uuid=? AND request_id=?`, domain, owner, input.RequestID).Scan(&oldHash, &result) if err == nil { if oldHash != hash { return ErrTaskConflict } return json.Unmarshal([]byte(result), &ids) } if !errors.Is(err, sql.ErrNoRows) { return err } rows, err := tx.QueryContext(ctx, `SELECT uuid,version,provider,url FROM feed_sources WHERE domain_uuid=? AND owner_uuid=?`, domain, owner) if err != nil { return err } existing := []FeedSource{} for rows.Next() { var source FeedSource if err = rows.Scan(&source.UUID, &source.Version, &source.Provider, &source.URL); err != nil { rows.Close() return err } existing = append(existing, source) } err = rows.Err() rows.Close() if err != nil { return err } if FeedSourcesSnapshot(existing) != input.Expected { return ErrTaskConflict } if len(existing)+len(input.Entries) > 32 { return ErrTaskDAVLimit } for _, source := range existing { if source.Provider == "local" && keys[FeedURLKey(source.URL)] { return ErrTaskConflict } } var receipts int if err = tx.QueryRowContext(ctx, `SELECT count(*) FROM feed_import_receipts WHERE domain_uuid=? AND owner_uuid=?`, domain, owner).Scan(&receipts); err != nil { return err } if receipts >= 1000 { return ErrTaskDAVLimit } for _, entry := range input.Entries { id := uuid.NewString() if _, err = tx.ExecContext(ctx, `INSERT INTO feed_sources(uuid,domain_uuid,owner_uuid,provider,title,folder,url,version,enabled,interval_seconds) VALUES(?,?,?,'local',?,?,?,1,?,?)`, id, domain, owner, entry.Title, entry.Folder, entry.URL, input.Enabled, input.Interval); err != nil { return err } ids = append(ids, id) } encoded, _ := json.Marshal(ids) _, err = tx.ExecContext(ctx, `INSERT INTO feed_import_receipts VALUES(?,?,?,?,?)`, domain, owner, input.RequestID, hash, string(encoded)) return err }) if err != nil { return nil, err } return ids, nil }