commit 57979979492d9c9b4836a5f3f3c52f83bcb7a600 · bretton.dev/coves

internal/api/handlers/communityFeed/get_community.go

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"Coves/internal/core/communityFeeds"

     

       0
        
       
     

       5
        
       	"encoding/json"

     

       6
        
       	"log"

     

       7
        
       	"net/http"

     
···

       44
        
       	if err != nil {

     

       45
        
       		handleServiceError(w, err)

     

       46
        
       		return

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       47
        
       	}

     

       48
        
       

     

       49
        
       	// Return feed

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"Coves/internal/core/communityFeeds"

     

       5
       +
       	"Coves/internal/core/posts"

     

       6
        
       	"encoding/json"

     

       7
        
       	"log"

     

       8
        
       	"net/http"

     
···

       45
        
       	if err != nil {

     

       46
        
       		handleServiceError(w, err)

     

       47
        
       		return

     

       48
       +
       	}

     

       49
       +
       

     

       50
       +
       	// Transform blob refs to URLs for all posts

     

       51
       +
       	for _, feedPost := range response.Feed {

     

       52
       +
       		if feedPost.Post != nil {

     

       53
       +
       			posts.TransformBlobRefsToURLs(feedPost.Post)

     

       54
       +
       		}

     

       55
        
       	}

     

       56
        
       

     

       57
        
       	// Return feed

internal/api/handlers/discover/get_discover.go

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"Coves/internal/core/discover"

     

       0
        
       
     

       5
        
       	"encoding/json"

     

       6
        
       	"log"

     

       7
        
       	"net/http"

     
···

       37
        
       	if err != nil {

     

       38
        
       		handleServiceError(w, err)

     

       39
        
       		return

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       40
        
       	}

     

       41
        
       

     

       42
        
       	// Return feed

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"Coves/internal/core/discover"

     

       5
       +
       	"Coves/internal/core/posts"

     

       6
        
       	"encoding/json"

     

       7
        
       	"log"

     

       8
        
       	"net/http"

     
···

       38
        
       	if err != nil {

     

       39
        
       		handleServiceError(w, err)

     

       40
        
       		return

     

       41
       +
       	}

     

       42
       +
       

     

       43
       +
       	// Transform blob refs to URLs for all posts

     

       44
       +
       	for _, feedPost := range response.Feed {

     

       45
       +
       		if feedPost.Post != nil {

     

       46
       +
       			posts.TransformBlobRefsToURLs(feedPost.Post)

     

       47
       +
       		}

     

       48
        
       	}

     

       49
        
       

     

       50
        
       	// Return feed

internal/api/handlers/timeline/get_timeline.go

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"Coves/internal/api/middleware"

     

       0
        
       
     

       5
        
       	"Coves/internal/core/timeline"

     

       6
        
       	"encoding/json"

     

       7
        
       	"log"

     
···

       50
        
       	if err != nil {

     

       51
        
       		handleServiceError(w, err)

     

       52
        
       		return

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       53
        
       	}

     

       54
        
       

     

       55
        
       	// Return feed

···

       2
        
       

     

       3
        
       import (

     

       4
        
       	"Coves/internal/api/middleware"

     

       5
       +
       	"Coves/internal/core/posts"

     

       6
        
       	"Coves/internal/core/timeline"

     

       7
        
       	"encoding/json"

     

       8
        
       	"log"

     
···

       51
        
       	if err != nil {

     

       52
        
       		handleServiceError(w, err)

     

       53
        
       		return

     

       54
       +
       	}

     

       55
       +
       

     

       56
       +
       	// Transform blob refs to URLs for all posts

     

       57
       +
       	for _, feedPost := range response.Feed {

     

       58
       +
       		if feedPost.Post != nil {

     

       59
       +
       			posts.TransformBlobRefsToURLs(feedPost.Post)

     

       60
       +
       		}

     

       61
        
       	}

     

       62
        
       

     

       63
        
       	// Return feed

+81

internal/core/posts/blob_transform.go

···

       1
       +
       package posts

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"fmt"

     

       5
       +
       )

     

       6
       +
       

     

       7
       +
       // TransformBlobRefsToURLs transforms all blob references in a PostView to PDS URLs

     

       8
       +
       // This modifies the Embed field in-place, converting blob refs to direct URLs

     

       9
       +
       // The transformation only affects external embeds with thumbnail blobs

     

       10
       +
       func TransformBlobRefsToURLs(postView *PostView) {

     

       11
       +
       	if postView == nil || postView.Embed == nil {

     

       12
       +
       		return

     

       13
       +
       	}

     

       14
       +
       

     

       15
       +
       	// Get community PDS URL from post view

     

       16
       +
       	if postView.Community == nil || postView.Community.PDSURL == "" {

     

       17
       +
       		return // Cannot transform without PDS URL

     

       18
       +
       	}

     

       19
       +
       

     

       20
       +
       	communityDID := postView.Community.DID

     

       21
       +
       	pdsURL := postView.Community.PDSURL

     

       22
       +
       

     

       23
       +
       	// Check if embed is a map (should be for external embeds)

     

       24
       +
       	embedMap, ok := postView.Embed.(map[string]interface{})

     

       25
       +
       	if !ok {

     

       26
       +
       		return

     

       27
       +
       	}

     

       28
       +
       

     

       29
       +
       	// Check embed type

     

       30
       +
       	embedType, ok := embedMap["$type"].(string)

     

       31
       +
       	if !ok {

     

       32
       +
       		return

     

       33
       +
       	}

     

       34
       +
       

     

       35
       +
       	// Only transform external embeds

     

       36
       +
       	if embedType == "social.coves.embed.external" {

     

       37
       +
       		if external, ok := embedMap["external"].(map[string]interface{}); ok {

     

       38
       +
       			transformThumbToURL(external, communityDID, pdsURL)

     

       39
       +
       		}

     

       40
       +
       	}

     

       41
       +
       }

     

       42
       +
       

     

       43
       +
       // transformThumbToURL converts a thumb blob ref to a PDS URL

     

       44
       +
       // This modifies the external map in-place

     

       45
       +
       func transformThumbToURL(external map[string]interface{}, communityDID, pdsURL string) {

     

       46
       +
       	// Check if thumb exists

     

       47
       +
       	thumb, ok := external["thumb"]

     

       48
       +
       	if !ok {

     

       49
       +
       		return

     

       50
       +
       	}

     

       51
       +
       

     

       52
       +
       	// If thumb is already a string (URL), don't transform

     

       53
       +
       	if _, isString := thumb.(string); isString {

     

       54
       +
       		return

     

       55
       +
       	}

     

       56
       +
       

     

       57
       +
       	// Try to parse as blob ref

     

       58
       +
       	thumbMap, ok := thumb.(map[string]interface{})

     

       59
       +
       	if !ok {

     

       60
       +
       		return

     

       61
       +
       	}

     

       62
       +
       

     

       63
       +
       	// Extract CID from blob ref

     

       64
       +
       	ref, ok := thumbMap["ref"].(map[string]interface{})

     

       65
       +
       	if !ok {

     

       66
       +
       		return

     

       67
       +
       	}

     

       68
       +
       

     

       69
       +
       	cid, ok := ref["$link"].(string)

     

       70
       +
       	if !ok || cid == "" {

     

       71
       +
       		return

     

       72
       +
       	}

     

       73
       +
       

     

       74
       +
       	// Transform to PDS blob endpoint URL

     

       75
       +
       	// Format: {pds_url}/xrpc/com.atproto.sync.getBlob?did={community_did}&cid={cid}

     

       76
       +
       	blobURL := fmt.Sprintf("%s/xrpc/com.atproto.sync.getBlob?did=%s&cid=%s",

     

       77
       +
       		pdsURL, communityDID, cid)

     

       78
       +
       

     

       79
       +
       	// Replace blob ref with URL string

     

       80
       +
       	external["thumb"] = blobURL

     

       81
       +
       }

+312

internal/core/posts/blob_transform_test.go

···

       1
       +
       package posts

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"testing"

     

       5
       +
       

     

       6
       +
       	"github.com/stretchr/testify/assert"

     

       7
       +
       	"github.com/stretchr/testify/require"

     

       8
       +
       )

     

       9
       +
       

     

       10
       +
       func TestTransformBlobRefsToURLs(t *testing.T) {

     

       11
       +
       	t.Run("transforms external embed thumb from blob to URL", func(t *testing.T) {

     

       12
       +
       		post := &PostView{

     

       13
       +
       			Community: &CommunityRef{

     

       14
       +
       				DID:    "did:plc:testcommunity",

     

       15
       +
       				PDSURL: "http://localhost:3001",

     

       16
       +
       			},

     

       17
       +
       			Embed: map[string]interface{}{

     

       18
       +
       				"$type": "social.coves.embed.external",

     

       19
       +
       				"external": map[string]interface{}{

     

       20
       +
       					"uri": "https://example.com",

     

       21
       +
       					"thumb": map[string]interface{}{

     

       22
       +
       						"$type": "blob",

     

       23
       +
       						"ref": map[string]interface{}{

     

       24
       +
       							"$link": "bafyreib6tbnql2ux3whnfysbzabthaj2vvck53nimhbi5g5a7jgvgr5eqm",

     

       25
       +
       						},

     

       26
       +
       						"mimeType": "image/jpeg",

     

       27
       +
       						"size":     52813,

     

       28
       +
       					},

     

       29
       +
       				},

     

       30
       +
       			},

     

       31
       +
       		}

     

       32
       +
       

     

       33
       +
       		TransformBlobRefsToURLs(post)

     

       34
       +
       

     

       35
       +
       		// Verify embed is still a map

     

       36
       +
       		embedMap, ok := post.Embed.(map[string]interface{})

     

       37
       +
       		require.True(t, ok, "embed should still be a map")

     

       38
       +
       

     

       39
       +
       		// Verify external is still a map

     

       40
       +
       		external, ok := embedMap["external"].(map[string]interface{})

     

       41
       +
       		require.True(t, ok, "external should be a map")

     

       42
       +
       

     

       43
       +
       		// Verify thumb is now a URL string

     

       44
       +
       		thumbURL, ok := external["thumb"].(string)

     

       45
       +
       		require.True(t, ok, "thumb should be a string URL")

     

       46
       +
       		assert.Equal(t,

     

       47
       +
       			"http://localhost:3001/xrpc/com.atproto.sync.getBlob?did=did:plc:testcommunity&cid=bafyreib6tbnql2ux3whnfysbzabthaj2vvck53nimhbi5g5a7jgvgr5eqm",

     

       48
       +
       			thumbURL)

     

       49
       +
       	})

     

       50
       +
       

     

       51
       +
       	t.Run("handles missing thumb gracefully", func(t *testing.T) {

     

       52
       +
       		post := &PostView{

     

       53
       +
       			Community: &CommunityRef{

     

       54
       +
       				DID:    "did:plc:testcommunity",

     

       55
       +
       				PDSURL: "http://localhost:3001",

     

       56
       +
       			},

     

       57
       +
       			Embed: map[string]interface{}{

     

       58
       +
       				"$type": "social.coves.embed.external",

     

       59
       +
       				"external": map[string]interface{}{

     

       60
       +
       					"uri": "https://example.com",

     

       61
       +
       					// No thumb field

     

       62
       +
       				},

     

       63
       +
       			},

     

       64
       +
       		}

     

       65
       +
       

     

       66
       +
       		// Should not panic

     

       67
       +
       		TransformBlobRefsToURLs(post)

     

       68
       +
       

     

       69
       +
       		// Verify external is unchanged

     

       70
       +
       		embedMap := post.Embed.(map[string]interface{})

     

       71
       +
       		external := embedMap["external"].(map[string]interface{})

     

       72
       +
       		_, hasThumb := external["thumb"]

     

       73
       +
       		assert.False(t, hasThumb, "thumb should not be added")

     

       74
       +
       	})

     

       75
       +
       

     

       76
       +
       	t.Run("handles already-transformed URL thumb", func(t *testing.T) {

     

       77
       +
       		expectedURL := "http://localhost:3001/xrpc/com.atproto.sync.getBlob?did=did:plc:test&cid=bafytest"

     

       78
       +
       		post := &PostView{

     

       79
       +
       			Community: &CommunityRef{

     

       80
       +
       				DID:    "did:plc:testcommunity",

     

       81
       +
       				PDSURL: "http://localhost:3001",

     

       82
       +
       			},

     

       83
       +
       			Embed: map[string]interface{}{

     

       84
       +
       				"$type": "social.coves.embed.external",

     

       85
       +
       				"external": map[string]interface{}{

     

       86
       +
       					"uri":   "https://example.com",

     

       87
       +
       					"thumb": expectedURL, // Already a URL string

     

       88
       +
       				},

     

       89
       +
       			},

     

       90
       +
       		}

     

       91
       +
       

     

       92
       +
       		// Should not error or change the URL

     

       93
       +
       		TransformBlobRefsToURLs(post)

     

       94
       +
       

     

       95
       +
       		// Verify thumb is unchanged

     

       96
       +
       		embedMap := post.Embed.(map[string]interface{})

     

       97
       +
       		external := embedMap["external"].(map[string]interface{})

     

       98
       +
       		thumbURL, ok := external["thumb"].(string)

     

       99
       +
       		require.True(t, ok, "thumb should still be a string")

     

       100
       +
       		assert.Equal(t, expectedURL, thumbURL, "thumb URL should be unchanged")

     

       101
       +
       	})

     

       102
       +
       

     

       103
       +
       	t.Run("handles missing embed", func(t *testing.T) {

     

       104
       +
       		post := &PostView{

     

       105
       +
       			Community: &CommunityRef{

     

       106
       +
       				DID:    "did:plc:testcommunity",

     

       107
       +
       				PDSURL: "http://localhost:3001",

     

       108
       +
       			},

     

       109
       +
       			Embed: nil,

     

       110
       +
       		}

     

       111
       +
       

     

       112
       +
       		// Should not panic

     

       113
       +
       		TransformBlobRefsToURLs(post)

     

       114
       +
       

     

       115
       +
       		// Verify embed is still nil

     

       116
       +
       		assert.Nil(t, post.Embed, "embed should remain nil")

     

       117
       +
       	})

     

       118
       +
       

     

       119
       +
       	t.Run("handles nil post", func(t *testing.T) {

     

       120
       +
       		// Should not panic

     

       121
       +
       		TransformBlobRefsToURLs(nil)

     

       122
       +
       	})

     

       123
       +
       

     

       124
       +
       	t.Run("handles missing community", func(t *testing.T) {

     

       125
       +
       		post := &PostView{

     

       126
       +
       			Community: nil,

     

       127
       +
       			Embed: map[string]interface{}{

     

       128
       +
       				"$type": "social.coves.embed.external",

     

       129
       +
       				"external": map[string]interface{}{

     

       130
       +
       					"uri": "https://example.com",

     

       131
       +
       					"thumb": map[string]interface{}{

     

       132
       +
       						"$type": "blob",

     

       133
       +
       						"ref": map[string]interface{}{

     

       134
       +
       							"$link": "bafyreib6tbnql2ux3whnfysbzabthaj2vvck53nimhbi5g5a7jgvgr5eqm",

     

       135
       +
       						},

     

       136
       +
       					},

     

       137
       +
       				},

     

       138
       +
       			},

     

       139
       +
       		}

     

       140
       +
       

     

       141
       +
       		// Should not panic or transform

     

       142
       +
       		TransformBlobRefsToURLs(post)

     

       143
       +
       

     

       144
       +
       		// Verify thumb is unchanged (still a blob)

     

       145
       +
       		embedMap := post.Embed.(map[string]interface{})

     

       146
       +
       		external := embedMap["external"].(map[string]interface{})

     

       147
       +
       		thumb, ok := external["thumb"].(map[string]interface{})

     

       148
       +
       		require.True(t, ok, "thumb should still be a map (blob ref)")

     

       149
       +
       		assert.Equal(t, "blob", thumb["$type"], "blob type should be unchanged")

     

       150
       +
       	})

     

       151
       +
       

     

       152
       +
       	t.Run("handles missing PDS URL", func(t *testing.T) {

     

       153
       +
       		post := &PostView{

     

       154
       +
       			Community: &CommunityRef{

     

       155
       +
       				DID:    "did:plc:testcommunity",

     

       156
       +
       				PDSURL: "", // Empty PDS URL

     

       157
       +
       			},

     

       158
       +
       			Embed: map[string]interface{}{

     

       159
       +
       				"$type": "social.coves.embed.external",

     

       160
       +
       				"external": map[string]interface{}{

     

       161
       +
       					"uri": "https://example.com",

     

       162
       +
       					"thumb": map[string]interface{}{

     

       163
       +
       						"$type": "blob",

     

       164
       +
       						"ref": map[string]interface{}{

     

       165
       +
       							"$link": "bafyreib6tbnql2ux3whnfysbzabthaj2vvck53nimhbi5g5a7jgvgr5eqm",

     

       166
       +
       						},

     

       167
       +
       					},

     

       168
       +
       				},

     

       169
       +
       			},

     

       170
       +
       		}

     

       171
       +
       

     

       172
       +
       		// Should not panic or transform

     

       173
       +
       		TransformBlobRefsToURLs(post)

     

       174
       +
       

     

       175
       +
       		// Verify thumb is unchanged (still a blob)

     

       176
       +
       		embedMap := post.Embed.(map[string]interface{})

     

       177
       +
       		external := embedMap["external"].(map[string]interface{})

     

       178
       +
       		thumb, ok := external["thumb"].(map[string]interface{})

     

       179
       +
       		require.True(t, ok, "thumb should still be a map (blob ref)")

     

       180
       +
       		assert.Equal(t, "blob", thumb["$type"], "blob type should be unchanged")

     

       181
       +
       	})

     

       182
       +
       

     

       183
       +
       	t.Run("handles malformed blob ref gracefully", func(t *testing.T) {

     

       184
       +
       		post := &PostView{

     

       185
       +
       			Community: &CommunityRef{

     

       186
       +
       				DID:    "did:plc:testcommunity",

     

       187
       +
       				PDSURL: "http://localhost:3001",

     

       188
       +
       			},

     

       189
       +
       			Embed: map[string]interface{}{

     

       190
       +
       				"$type": "social.coves.embed.external",

     

       191
       +
       				"external": map[string]interface{}{

     

       192
       +
       					"uri": "https://example.com",

     

       193
       +
       					"thumb": map[string]interface{}{

     

       194
       +
       						"$type": "blob",

     

       195
       +
       						"ref":   "invalid-ref-format", // Should be a map with $link

     

       196
       +
       					},

     

       197
       +
       				},

     

       198
       +
       			},

     

       199
       +
       		}

     

       200
       +
       

     

       201
       +
       		// Should not panic

     

       202
       +
       		TransformBlobRefsToURLs(post)

     

       203
       +
       

     

       204
       +
       		// Verify thumb is unchanged (malformed blob)

     

       205
       +
       		embedMap := post.Embed.(map[string]interface{})

     

       206
       +
       		external := embedMap["external"].(map[string]interface{})

     

       207
       +
       		thumb, ok := external["thumb"].(map[string]interface{})

     

       208
       +
       		require.True(t, ok, "thumb should still be a map")

     

       209
       +
       		assert.Equal(t, "invalid-ref-format", thumb["ref"], "malformed ref should be unchanged")

     

       210
       +
       	})

     

       211
       +
       

     

       212
       +
       	t.Run("ignores non-external embed types", func(t *testing.T) {

     

       213
       +
       		post := &PostView{

     

       214
       +
       			Community: &CommunityRef{

     

       215
       +
       				DID:    "did:plc:testcommunity",

     

       216
       +
       				PDSURL: "http://localhost:3001",

     

       217
       +
       			},

     

       218
       +
       			Embed: map[string]interface{}{

     

       219
       +
       				"$type": "social.coves.embed.images",

     

       220
       +
       				"images": []interface{}{

     

       221
       +
       					map[string]interface{}{

     

       222
       +
       						"image": map[string]interface{}{

     

       223
       +
       							"$type": "blob",

     

       224
       +
       							"ref": map[string]interface{}{

     

       225
       +
       								"$link": "bafyreib6tbnql2ux3whnfysbzabthaj2vvck53nimhbi5g5a7jgvgr5eqm",

     

       226
       +
       							},

     

       227
       +
       						},

     

       228
       +
       					},

     

       229
       +
       				},

     

       230
       +
       			},

     

       231
       +
       		}

     

       232
       +
       

     

       233
       +
       		// Should not transform non-external embeds

     

       234
       +
       		TransformBlobRefsToURLs(post)

     

       235
       +
       

     

       236
       +
       		// Verify images embed is unchanged

     

       237
       +
       		embedMap := post.Embed.(map[string]interface{})

     

       238
       +
       		images := embedMap["images"].([]interface{})

     

       239
       +
       		imageObj := images[0].(map[string]interface{})

     

       240
       +
       		imageBlob := imageObj["image"].(map[string]interface{})

     

       241
       +
       		assert.Equal(t, "blob", imageBlob["$type"], "image blob should be unchanged")

     

       242
       +
       	})

     

       243
       +
       }

     

       244
       +
       

     

       245
       +
       func TestTransformThumbToURL(t *testing.T) {

     

       246
       +
       	t.Run("transforms valid blob ref to URL", func(t *testing.T) {

     

       247
       +
       		external := map[string]interface{}{

     

       248
       +
       			"uri": "https://example.com",

     

       249
       +
       			"thumb": map[string]interface{}{

     

       250
       +
       				"$type": "blob",

     

       251
       +
       				"ref": map[string]interface{}{

     

       252
       +
       					"$link": "bafyreib6tbnql2ux3whnfysbzabthaj2vvck53nimhbi5g5a7jgvgr5eqm",

     

       253
       +
       				},

     

       254
       +
       				"mimeType": "image/jpeg",

     

       255
       +
       				"size":     52813,

     

       256
       +
       			},

     

       257
       +
       		}

     

       258
       +
       

     

       259
       +
       		transformThumbToURL(external, "did:plc:test", "http://localhost:3001")

     

       260
       +
       

     

       261
       +
       		thumbURL, ok := external["thumb"].(string)

     

       262
       +
       		require.True(t, ok, "thumb should be a string URL")

     

       263
       +
       		assert.Equal(t,

     

       264
       +
       			"http://localhost:3001/xrpc/com.atproto.sync.getBlob?did=did:plc:test&cid=bafyreib6tbnql2ux3whnfysbzabthaj2vvck53nimhbi5g5a7jgvgr5eqm",

     

       265
       +
       			thumbURL)

     

       266
       +
       	})

     

       267
       +
       

     

       268
       +
       	t.Run("does not transform if thumb is already string", func(t *testing.T) {

     

       269
       +
       		expectedURL := "http://localhost:3001/xrpc/com.atproto.sync.getBlob?did=did:plc:test&cid=bafytest"

     

       270
       +
       		external := map[string]interface{}{

     

       271
       +
       			"uri":   "https://example.com",

     

       272
       +
       			"thumb": expectedURL,

     

       273
       +
       		}

     

       274
       +
       

     

       275
       +
       		transformThumbToURL(external, "did:plc:test", "http://localhost:3001")

     

       276
       +
       

     

       277
       +
       		thumbURL, ok := external["thumb"].(string)

     

       278
       +
       		require.True(t, ok, "thumb should still be a string")

     

       279
       +
       		assert.Equal(t, expectedURL, thumbURL, "thumb should be unchanged")

     

       280
       +
       	})

     

       281
       +
       

     

       282
       +
       	t.Run("does not transform if thumb is missing", func(t *testing.T) {

     

       283
       +
       		external := map[string]interface{}{

     

       284
       +
       			"uri": "https://example.com",

     

       285
       +
       		}

     

       286
       +
       

     

       287
       +
       		transformThumbToURL(external, "did:plc:test", "http://localhost:3001")

     

       288
       +
       

     

       289
       +
       		_, hasThumb := external["thumb"]

     

       290
       +
       		assert.False(t, hasThumb, "thumb should not be added")

     

       291
       +
       	})

     

       292
       +
       

     

       293
       +
       	t.Run("does not transform if CID is empty", func(t *testing.T) {

     

       294
       +
       		external := map[string]interface{}{

     

       295
       +
       			"uri": "https://example.com",

     

       296
       +
       			"thumb": map[string]interface{}{

     

       297
       +
       				"$type": "blob",

     

       298
       +
       				"ref": map[string]interface{}{

     

       299
       +
       					"$link": "", // Empty CID

     

       300
       +
       				},

     

       301
       +
       			},

     

       302
       +
       		}

     

       303
       +
       

     

       304
       +
       		transformThumbToURL(external, "did:plc:test", "http://localhost:3001")

     

       305
       +
       

     

       306
       +
       		// Verify thumb is unchanged

     

       307
       +
       		thumb, ok := external["thumb"].(map[string]interface{})

     

       308
       +
       		require.True(t, ok, "thumb should still be a map")

     

       309
       +
       		ref := thumb["ref"].(map[string]interface{})

     

       310
       +
       		assert.Equal(t, "", ref["$link"], "empty CID should be unchanged")

     

       311
       +
       	})

     

       312
       +
       }

+2 -2

internal/db/postgres/discover_repo.go

···

       47
        
       		SELECT

     

       48
        
       			p.uri, p.cid, p.rkey,

     

       49
        
       			p.author_did, u.handle as author_handle,

     

       50
       -
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar,

     

       51
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       52
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       53
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,

     
···

       58
        
       		SELECT

     

       59
        
       			p.uri, p.cid, p.rkey,

     

       60
        
       			p.author_did, u.handle as author_handle,

     

       61
       -
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar,

     

       62
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       63
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       64
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,

···

       47
        
       		SELECT

     

       48
        
       			p.uri, p.cid, p.rkey,

     

       49
        
       			p.author_did, u.handle as author_handle,

     

       50
       +
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar, c.pds_url as community_pds_url,

     

       51
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       52
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       53
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,

     
···

       58
        
       		SELECT

     

       59
        
       			p.uri, p.cid, p.rkey,

     

       60
        
       			p.author_did, u.handle as author_handle,

     

       61
       +
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar, c.pds_url as community_pds_url,

     

       62
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       63
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       64
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,

+2 -2

internal/db/postgres/feed_repo.go

···

       53
        
       		SELECT

     

       54
        
       			p.uri, p.cid, p.rkey,

     

       55
        
       			p.author_did, u.handle as author_handle,

     

       56
       -
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar,

     

       57
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       58
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       59
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,

     
···

       64
        
       		SELECT

     

       65
        
       			p.uri, p.cid, p.rkey,

     

       66
        
       			p.author_did, u.handle as author_handle,

     

       67
       -
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar,

     

       68
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       69
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       70
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,

···

       53
        
       		SELECT

     

       54
        
       			p.uri, p.cid, p.rkey,

     

       55
        
       			p.author_did, u.handle as author_handle,

     

       56
       +
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar, c.pds_url as community_pds_url,

     

       57
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       58
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       59
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,

     
···

       64
        
       		SELECT

     

       65
        
       			p.uri, p.cid, p.rkey,

     

       66
        
       			p.author_did, u.handle as author_handle,

     

       67
       +
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar, c.pds_url as community_pds_url,

     

       68
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       69
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       70
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,

+5 -1

internal/db/postgres/feed_repo_base.go

···

       285
        
       		editedAt        sql.NullTime

     

       286
        
       		communityHandle sql.NullString

     

       287
        
       		communityAvatar sql.NullString

     

       0
        
       
     

       288
        
       		hotRank         sql.NullFloat64

     

       289
        
       	)

     

       290
        
       

     

       291
        
       	err := rows.Scan(

     

       292
        
       		&postView.URI, &postView.CID, &postView.RKey,

     

       293
        
       		&authorView.DID, &authorView.Handle,

     

       294
       -
       		&communityRef.DID, &communityHandle, &communityRef.Name, &communityAvatar,

     

       295
        
       		&title, &content, &facets, &embed, &labelsJSON,

     

       296
        
       		&postView.CreatedAt, &editedAt, &postView.IndexedAt,

     

       297
        
       		&postView.UpvoteCount, &postView.DownvoteCount, &postView.Score, &postView.CommentCount,

     
···

       309
        
       		communityRef.Handle = communityHandle.String

     

       310
        
       	}

     

       311
        
       	communityRef.Avatar = nullStringPtr(communityAvatar)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       312
        
       	postView.Community = &communityRef

     

       313
        
       

     

       314
        
       	// Set optional fields

···

       285
        
       		editedAt        sql.NullTime

     

       286
        
       		communityHandle sql.NullString

     

       287
        
       		communityAvatar sql.NullString

     

       288
       +
       		communityPDSURL sql.NullString

     

       289
        
       		hotRank         sql.NullFloat64

     

       290
        
       	)

     

       291
        
       

     

       292
        
       	err := rows.Scan(

     

       293
        
       		&postView.URI, &postView.CID, &postView.RKey,

     

       294
        
       		&authorView.DID, &authorView.Handle,

     

       295
       +
       		&communityRef.DID, &communityHandle, &communityRef.Name, &communityAvatar, &communityPDSURL,

     

       296
        
       		&title, &content, &facets, &embed, &labelsJSON,

     

       297
        
       		&postView.CreatedAt, &editedAt, &postView.IndexedAt,

     

       298
        
       		&postView.UpvoteCount, &postView.DownvoteCount, &postView.Score, &postView.CommentCount,

     
···

       310
        
       		communityRef.Handle = communityHandle.String

     

       311
        
       	}

     

       312
        
       	communityRef.Avatar = nullStringPtr(communityAvatar)

     

       313
       +
       	if communityPDSURL.Valid {

     

       314
       +
       		communityRef.PDSURL = communityPDSURL.String

     

       315
       +
       	}

     

       316
        
       	postView.Community = &communityRef

     

       317
        
       

     

       318
        
       	// Set optional fields

+2 -2

internal/db/postgres/timeline_repo.go

···

       51
        
       		SELECT

     

       52
        
       			p.uri, p.cid, p.rkey,

     

       53
        
       			p.author_did, u.handle as author_handle,

     

       54
       -
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar,

     

       55
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       56
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       57
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,

     
···

       62
        
       		SELECT

     

       63
        
       			p.uri, p.cid, p.rkey,

     

       64
        
       			p.author_did, u.handle as author_handle,

     

       65
       -
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar,

     

       66
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       67
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       68
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,

···

       51
        
       		SELECT

     

       52
        
       			p.uri, p.cid, p.rkey,

     

       53
        
       			p.author_did, u.handle as author_handle,

     

       54
       +
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar, c.pds_url as community_pds_url,

     

       55
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       56
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       57
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,

     
···

       62
        
       		SELECT

     

       63
        
       			p.uri, p.cid, p.rkey,

     

       64
        
       			p.author_did, u.handle as author_handle,

     

       65
       +
       			p.community_did, c.handle as community_handle, c.name as community_name, c.avatar_cid as community_avatar, c.pds_url as community_pds_url,

     

       66
        
       			p.title, p.content, p.content_facets, p.embed, p.content_labels,

     

       67
        
       			p.created_at, p.edited_at, p.indexed_at,

     

       68
        
       			p.upvote_count, p.downvote_count, p.score, p.comment_count,