+6 -4

migrations/005_initimages.up.sql

··· 1 1 - CREATE TABLE medias ( 1 1 + CREATE TABLE iamges ( 2 2 uri TEXT PRIMARY KEY, 3 3 did TEXT NOT NULL, 4 4 signet_uri TEXT NOT NULL, 5 5 FOREIGN KEY (signet_uri) REFERENCES signets(uri) ON DELETE CASCADE, 6 6 - media_cid TEXT, 7 7 - media_mime TEXT, 6 6 + blob_cid TEXT, 7 7 + blob_mime TEXT, 8 8 alt TEXT, 9 9 + height INTEGER, 10 10 + width INTEGER, 9 11 nick TEXT NOT NULL, 10 12 color INTEGER CHECK (color BETWEEN 0 AND 16777215), 11 13 cid TEXT NOT NULL, ··· 13 15 indexed_at TIMESTAMPTZ NOT NULL DEFAULT now() 14 16 ); 15 17 16 16 - CREATE INDEX ON medias (signet_uri); 18 18 + CREATE INDEX ON images (signet_uri);

+4 -1

server/gen/main.go

··· 10 10 lex.ProfileRecord{}, 11 11 lex.ChannelRecord{}, 12 12 lex.MessageRecord{}, 13 13 - lex.SignetRecord{}); err != nil { 13 13 + lex.SignetRecord{}, 14 14 + lex.AspectRatio{}, 15 15 + lex.Image{}, 16 16 + lex.MediaRecord{}); err != nil { 14 17 panic(err) 15 18 } 16 19 }

-2

server/go.sum

··· 117 117 github.com/prometheus/common v0.54.0/go.mod h1:/TQgMJP5CuVYveyT7n/0Ix8yLNNXy9yRSkhnLTHPDIQ= 118 118 github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= 119 119 github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= 120 120 - github.com/rachel-mp4/lrcd v0.0.0-20250906202657-38adb092ac1a h1:AWXrdTM1ew/J6mup1xBKkmg/nC6xx6BkL4wT6INdAWI= 121 121 - github.com/rachel-mp4/lrcd v0.0.0-20250906202657-38adb092ac1a/go.mod h1:aWUVglSyrLf2RGpQdqTucX498b434yWBFJkD6Yzr0OE= 122 120 github.com/rachel-mp4/lrcd v0.0.1 h1:9d5if0HJ/+TLKdupd7Zu9dISA5fF3QRtI/yr+gYVqXM= 123 121 github.com/rachel-mp4/lrcd v0.0.1/go.mod h1:aWUVglSyrLf2RGpQdqTucX498b434yWBFJkD6Yzr0OE= 124 122 github.com/rachel-mp4/lrcproto v0.0.0-20250905154858-2ddb78e31d0c h1:t33xVlfSwvB80nj1jroRXUaq/RTgjWwD4l7p/ISatUQ=

+28 -16

server/internal/db/lexicon.go

··· 293 293 uri, 294 294 did, 295 295 signet_uri, 296 296 - image_cid, 297 297 - image_mime, 296 296 + blob_cid, 297 297 + blob_mime, 298 298 alt, 299 299 + height, 300 300 + width, 299 301 nick, 300 302 color, 301 303 cid, 302 304 posted_at 303 305 ) VALUES ( 304 304 - $1, $2, $3, $4, $5, $6, $7, $8, $9, $10 306 306 + $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12 305 307 ) ON CONFLICT (uri) DO NOTHING`, 306 308 image.URI, 307 309 image.DID, 308 310 image.SignetURI, 309 309 - image.ImageCID, 310 310 - image.ImageMIME, 311 311 + image.BlobCID, 312 312 + image.BlobMIME, 311 313 image.Alt, 314 314 + image.Height, 315 315 + image.Width, 312 316 image.Nick, 313 317 image.Color, 314 318 image.CID, ··· 320 324 } 321 325 322 326 func (s *Store) UpdateImage(image *types.Image, ctx context.Context) error { 323 323 - _, err := s.pool.Exec(ctx, `INSERT INTO medias ( 327 327 + _, err := s.pool.Exec(ctx, `INSERT INTO images ( 324 328 uri, 325 329 did, 326 330 signet_uri, 327 327 - image_cid, 328 328 - image_mime, 331 331 + blob_cid, 332 332 + blob_mime, 329 333 alt, 334 334 + height, 335 335 + width, 330 336 nick, 331 337 color, 332 338 cid, 333 339 posted_at 334 340 ) VALUES ( 335 335 - $1, $2, $3, $4, $5, $6, $7, $8, $9, $10 341 341 + $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12 336 342 )`, 337 343 image.URI, 338 344 image.DID, 339 345 image.SignetURI, 340 340 - image.ImageCID, 341 341 - image.ImageMIME, 346 346 + image.BlobCID, 347 347 + image.BlobMIME, 342 348 image.Alt, 349 349 + image.Height, 350 350 + image.Width, 343 351 image.Nick, 344 352 image.Color, 345 353 image.CID, ··· 351 359 } 352 360 353 361 func (s *Store) DeleteImage(uri string, ctx context.Context) error { 354 354 - _, err := s.pool.Exec(ctx, `DELETE from medias m WHERE m.uri = $1`, uri) 362 362 + _, err := s.pool.Exec(ctx, `DELETE from images i WHERE i.uri = $1`, uri) 355 363 if err != nil { 356 364 return errors.New("bep bep bop: " + err.Error()) 357 365 } ··· 362 370 row := s.pool.QueryRow(ctx, `SELECT FROM medias ( 363 371 did, 364 372 signet_uri, 365 365 - media_cid, 366 366 - media_mime, 373 373 + blob_cid, 374 374 + blob_mime, 367 375 alt, 376 376 + height, 377 377 + width, 368 378 nick, 369 379 color, 370 380 cid, ··· 373 383 var image types.Image 374 384 err := row.Scan(&image.DID, 375 385 &image.SignetURI, 376 376 - &image.ImageCID, 377 377 - &image.ImageMIME, 386 386 + &image.BlobCID, 387 387 + &image.BlobMIME, 378 388 &image.Alt, 389 389 + &image.Height, 390 390 + &image.Width, 379 391 &image.Nick, 380 392 &image.Color, 381 393 &image.CID,

-1

server/internal/handler/handler.go

··· 34 34 mux.HandleFunc("POST /lrc/image", h.oauthMiddleware(h.uploadImage)) 35 35 mux.HandleFunc("POST /lrc/media", h.oauthMiddleware(h.postMedia)) 36 36 // mux.HandleFunc("GET /lrc/image", h.getImage) 37 37 - mux.HandleFunc("POST /lrc/imagePub", h.oauthMiddleware(h.postImagePub)) 38 37 mux.HandleFunc("POST /lrc/mymessage", h.postMyMessage) 39 38 // xcvr handlers 40 39 mux.HandleFunc("POST /xcvr/profile", h.oauthMiddleware(h.postProfile))

+6 -5

server/internal/handler/lrcHandlers.go

··· 181 181 h.badRequest(w, err) 182 182 return 183 183 } 184 184 - h.rm.PostMedia(cs, mr, r.Context()) 184 184 + err = h.rm.PostMedia(cs, mr, r.Context()) 185 185 + if err != nil { 186 186 + h.serverError(w, errors.New("failing to post the media :c")) 187 187 + return 188 188 + } 189 189 + w.Write(nil) 185 190 } 186 191 187 192 func parseMediaRequest(r *http.Request) (*types.ParseMediaRequest, error) { ··· 225 230 // func syncGetBlob(did string, cid *string) { 226 231 // //TODO: impl 227 232 // } 228 228 - 229 229 - func (h *Handler) postImagePub(cs *atoauth.ClientSession, w http.ResponseWriter, r *http.Request) { 230 230 - 231 231 - }

+736 -36

server/internal/lex/lexicons_cbor.go

··· 969 969 return err 970 970 } 971 971 972 972 - // t.Author (string) (string) 973 973 - if len("nick") > 8192 { 974 974 - return xerrors.Errorf("Value in field \"nick\" was too long") 975 975 - } 976 976 - 977 977 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("nick"))); err != nil { 978 978 - return err 979 979 - } 980 980 - if _, err := cw.WriteString(string("nick")); err != nil { 981 981 - return err 982 982 - } 983 983 - 984 984 - if len(t.AuthorHandle) > 8192 { 985 985 - return xerrors.Errorf("Value in field t.Author was too long") 986 986 - } 987 987 - 988 988 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.AuthorHandle))); err != nil { 989 989 - return err 990 990 - } 991 991 - if _, err := cw.WriteString(string(t.AuthorHandle)); err != nil { 992 992 - return err 993 993 - } 994 994 - 995 972 // t.LexiconTypeID (string) (string) 996 973 if len("$type") > 8192 { 997 974 return xerrors.Errorf("Value in field \"$type\" was too long") ··· 1081 1058 if _, err := cw.WriteString(string(t.ChannelURI)); err != nil { 1082 1059 return err 1083 1060 } 1061 1061 + 1062 1062 + // t.AuthorHandle (string) (string) 1063 1063 + if len("authorHandle") > 8192 { 1064 1064 + return xerrors.Errorf("Value in field \"authorHandle\" was too long") 1065 1065 + } 1066 1066 + 1067 1067 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("authorHandle"))); err != nil { 1068 1068 + return err 1069 1069 + } 1070 1070 + if _, err := cw.WriteString(string("authorHandle")); err != nil { 1071 1071 + return err 1072 1072 + } 1073 1073 + 1074 1074 + if len(t.AuthorHandle) > 8192 { 1075 1075 + return xerrors.Errorf("Value in field t.AuthorHandle was too long") 1076 1076 + } 1077 1077 + 1078 1078 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.AuthorHandle))); err != nil { 1079 1079 + return err 1080 1080 + } 1081 1081 + if _, err := cw.WriteString(string(t.AuthorHandle)); err != nil { 1082 1082 + return err 1083 1083 + } 1084 1084 return nil 1085 1085 } 1086 1086 ··· 1109 1109 1110 1110 n := extra 1111 1111 1112 1112 - nameBuf := make([]byte, 10) 1112 1112 + nameBuf := make([]byte, 12) 1113 1113 for i := uint64(0); i < n; i++ { 1114 1114 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 1115 1115 if err != nil { ··· 1125 1125 } 1126 1126 1127 1127 switch string(nameBuf[:nameLen]) { 1128 1128 - // t.Author (string) (string) 1129 1129 - case "authorHandle": 1130 1130 - 1131 1131 - { 1132 1132 - sval, err := cbg.ReadStringWithMax(cr, 8192) 1133 1133 - if err != nil { 1134 1134 - return err 1135 1135 - } 1136 1136 - 1137 1137 - t.AuthorHandle = string(sval) 1138 1138 - } 1139 1139 - // t.LexiconTypeID (string) (string) 1128 1128 + // t.LexiconTypeID (string) (string) 1140 1129 case "$type": 1141 1130 1142 1131 { ··· 1193 1182 } 1194 1183 1195 1184 t.ChannelURI = string(sval) 1185 1185 + } 1186 1186 + // t.AuthorHandle (string) (string) 1187 1187 + case "authorHandle": 1188 1188 + 1189 1189 + { 1190 1190 + sval, err := cbg.ReadStringWithMax(cr, 8192) 1191 1191 + if err != nil { 1192 1192 + return err 1193 1193 + } 1194 1194 + 1195 1195 + t.AuthorHandle = string(sval) 1196 1196 + } 1197 1197 + 1198 1198 + default: 1199 1199 + // Field doesn't exist on this type, so ignore it 1200 1200 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1201 1201 + return err 1202 1202 + } 1203 1203 + } 1204 1204 + } 1205 1205 + 1206 1206 + return nil 1207 1207 + } 1208 1208 + func (t *AspectRatio) MarshalCBOR(w io.Writer) error { 1209 1209 + if t == nil { 1210 1210 + _, err := w.Write(cbg.CborNull) 1211 1211 + return err 1212 1212 + } 1213 1213 + 1214 1214 + cw := cbg.NewCborWriter(w) 1215 1215 + 1216 1216 + if _, err := cw.Write([]byte{162}); err != nil { 1217 1217 + return err 1218 1218 + } 1219 1219 + 1220 1220 + // t.Width (int64) (int64) 1221 1221 + if len("width") > 8192 { 1222 1222 + return xerrors.Errorf("Value in field \"width\" was too long") 1223 1223 + } 1224 1224 + 1225 1225 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("width"))); err != nil { 1226 1226 + return err 1227 1227 + } 1228 1228 + if _, err := cw.WriteString(string("width")); err != nil { 1229 1229 + return err 1230 1230 + } 1231 1231 + 1232 1232 + if t.Width >= 0 { 1233 1233 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Width)); err != nil { 1234 1234 + return err 1235 1235 + } 1236 1236 + } else { 1237 1237 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Width-1)); err != nil { 1238 1238 + return err 1239 1239 + } 1240 1240 + } 1241 1241 + 1242 1242 + // t.Height (int64) (int64) 1243 1243 + if len("height") > 8192 { 1244 1244 + return xerrors.Errorf("Value in field \"height\" was too long") 1245 1245 + } 1246 1246 + 1247 1247 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("height"))); err != nil { 1248 1248 + return err 1249 1249 + } 1250 1250 + if _, err := cw.WriteString(string("height")); err != nil { 1251 1251 + return err 1252 1252 + } 1253 1253 + 1254 1254 + if t.Height >= 0 { 1255 1255 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Height)); err != nil { 1256 1256 + return err 1257 1257 + } 1258 1258 + } else { 1259 1259 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Height-1)); err != nil { 1260 1260 + return err 1261 1261 + } 1262 1262 + } 1263 1263 + 1264 1264 + return nil 1265 1265 + } 1266 1266 + 1267 1267 + func (t *AspectRatio) UnmarshalCBOR(r io.Reader) (err error) { 1268 1268 + *t = AspectRatio{} 1269 1269 + 1270 1270 + cr := cbg.NewCborReader(r) 1271 1271 + 1272 1272 + maj, extra, err := cr.ReadHeader() 1273 1273 + if err != nil { 1274 1274 + return err 1275 1275 + } 1276 1276 + defer func() { 1277 1277 + if err == io.EOF { 1278 1278 + err = io.ErrUnexpectedEOF 1279 1279 + } 1280 1280 + }() 1281 1281 + 1282 1282 + if maj != cbg.MajMap { 1283 1283 + return fmt.Errorf("cbor input should be of type map") 1284 1284 + } 1285 1285 + 1286 1286 + if extra > cbg.MaxLength { 1287 1287 + return fmt.Errorf("AspectRatio: map struct too large (%d)", extra) 1288 1288 + } 1289 1289 + 1290 1290 + n := extra 1291 1291 + 1292 1292 + nameBuf := make([]byte, 6) 1293 1293 + for i := uint64(0); i < n; i++ { 1294 1294 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 1295 1295 + if err != nil { 1296 1296 + return err 1297 1297 + } 1298 1298 + 1299 1299 + if !ok { 1300 1300 + // Field doesn't exist on this type, so ignore it 1301 1301 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1302 1302 + return err 1303 1303 + } 1304 1304 + continue 1305 1305 + } 1306 1306 + 1307 1307 + switch string(nameBuf[:nameLen]) { 1308 1308 + // t.Width (int64) (int64) 1309 1309 + case "width": 1310 1310 + { 1311 1311 + maj, extra, err := cr.ReadHeader() 1312 1312 + if err != nil { 1313 1313 + return err 1314 1314 + } 1315 1315 + var extraI int64 1316 1316 + switch maj { 1317 1317 + case cbg.MajUnsignedInt: 1318 1318 + extraI = int64(extra) 1319 1319 + if extraI < 0 { 1320 1320 + return fmt.Errorf("int64 positive overflow") 1321 1321 + } 1322 1322 + case cbg.MajNegativeInt: 1323 1323 + extraI = int64(extra) 1324 1324 + if extraI < 0 { 1325 1325 + return fmt.Errorf("int64 negative overflow") 1326 1326 + } 1327 1327 + extraI = -1 - extraI 1328 1328 + default: 1329 1329 + return fmt.Errorf("wrong type for int64 field: %d", maj) 1330 1330 + } 1331 1331 + 1332 1332 + t.Width = int64(extraI) 1333 1333 + } 1334 1334 + // t.Height (int64) (int64) 1335 1335 + case "height": 1336 1336 + { 1337 1337 + maj, extra, err := cr.ReadHeader() 1338 1338 + if err != nil { 1339 1339 + return err 1340 1340 + } 1341 1341 + var extraI int64 1342 1342 + switch maj { 1343 1343 + case cbg.MajUnsignedInt: 1344 1344 + extraI = int64(extra) 1345 1345 + if extraI < 0 { 1346 1346 + return fmt.Errorf("int64 positive overflow") 1347 1347 + } 1348 1348 + case cbg.MajNegativeInt: 1349 1349 + extraI = int64(extra) 1350 1350 + if extraI < 0 { 1351 1351 + return fmt.Errorf("int64 negative overflow") 1352 1352 + } 1353 1353 + extraI = -1 - extraI 1354 1354 + default: 1355 1355 + return fmt.Errorf("wrong type for int64 field: %d", maj) 1356 1356 + } 1357 1357 + 1358 1358 + t.Height = int64(extraI) 1359 1359 + } 1360 1360 + 1361 1361 + default: 1362 1362 + // Field doesn't exist on this type, so ignore it 1363 1363 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1364 1364 + return err 1365 1365 + } 1366 1366 + } 1367 1367 + } 1368 1368 + 1369 1369 + return nil 1370 1370 + } 1371 1371 + func (t *Image) MarshalCBOR(w io.Writer) error { 1372 1372 + if t == nil { 1373 1373 + _, err := w.Write(cbg.CborNull) 1374 1374 + return err 1375 1375 + } 1376 1376 + 1377 1377 + cw := cbg.NewCborWriter(w) 1378 1378 + fieldCount := 4 1379 1379 + 1380 1380 + if t.AspectRatio == nil { 1381 1381 + fieldCount-- 1382 1382 + } 1383 1383 + 1384 1384 + if t.Blob == nil { 1385 1385 + fieldCount-- 1386 1386 + } 1387 1387 + 1388 1388 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 1389 1389 + return err 1390 1390 + } 1391 1391 + 1392 1392 + // t.Alt (string) (string) 1393 1393 + if len("alt") > 8192 { 1394 1394 + return xerrors.Errorf("Value in field \"alt\" was too long") 1395 1395 + } 1396 1396 + 1397 1397 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("alt"))); err != nil { 1398 1398 + return err 1399 1399 + } 1400 1400 + if _, err := cw.WriteString(string("alt")); err != nil { 1401 1401 + return err 1402 1402 + } 1403 1403 + 1404 1404 + if len(t.Alt) > 8192 { 1405 1405 + return xerrors.Errorf("Value in field t.Alt was too long") 1406 1406 + } 1407 1407 + 1408 1408 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Alt))); err != nil { 1409 1409 + return err 1410 1410 + } 1411 1411 + if _, err := cw.WriteString(string(t.Alt)); err != nil { 1412 1412 + return err 1413 1413 + } 1414 1414 + 1415 1415 + // t.Blob (util.BlobSchema) (struct) 1416 1416 + if t.Blob != nil { 1417 1417 + 1418 1418 + if len("blob") > 8192 { 1419 1419 + return xerrors.Errorf("Value in field \"blob\" was too long") 1420 1420 + } 1421 1421 + 1422 1422 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("blob"))); err != nil { 1423 1423 + return err 1424 1424 + } 1425 1425 + if _, err := cw.WriteString(string("blob")); err != nil { 1426 1426 + return err 1427 1427 + } 1428 1428 + 1429 1429 + if err := t.Blob.MarshalCBOR(cw); err != nil { 1430 1430 + return err 1431 1431 + } 1432 1432 + } 1433 1433 + 1434 1434 + // t.LexiconTypeID (string) (string) 1435 1435 + if len("$type") > 8192 { 1436 1436 + return xerrors.Errorf("Value in field \"$type\" was too long") 1437 1437 + } 1438 1438 + 1439 1439 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 1440 1440 + return err 1441 1441 + } 1442 1442 + if _, err := cw.WriteString(string("$type")); err != nil { 1443 1443 + return err 1444 1444 + } 1445 1445 + 1446 1446 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("org.xcvr.lrc.image"))); err != nil { 1447 1447 + return err 1448 1448 + } 1449 1449 + if _, err := cw.WriteString(string("org.xcvr.lrc.image")); err != nil { 1450 1450 + return err 1451 1451 + } 1452 1452 + 1453 1453 + // t.AspectRatio (lex.AspectRatio) (struct) 1454 1454 + if t.AspectRatio != nil { 1455 1455 + 1456 1456 + if len("aspectRatio") > 8192 { 1457 1457 + return xerrors.Errorf("Value in field \"aspectRatio\" was too long") 1458 1458 + } 1459 1459 + 1460 1460 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("aspectRatio"))); err != nil { 1461 1461 + return err 1462 1462 + } 1463 1463 + if _, err := cw.WriteString(string("aspectRatio")); err != nil { 1464 1464 + return err 1465 1465 + } 1466 1466 + 1467 1467 + if err := t.AspectRatio.MarshalCBOR(cw); err != nil { 1468 1468 + return err 1469 1469 + } 1470 1470 + } 1471 1471 + return nil 1472 1472 + } 1473 1473 + 1474 1474 + func (t *Image) UnmarshalCBOR(r io.Reader) (err error) { 1475 1475 + *t = Image{} 1476 1476 + 1477 1477 + cr := cbg.NewCborReader(r) 1478 1478 + 1479 1479 + maj, extra, err := cr.ReadHeader() 1480 1480 + if err != nil { 1481 1481 + return err 1482 1482 + } 1483 1483 + defer func() { 1484 1484 + if err == io.EOF { 1485 1485 + err = io.ErrUnexpectedEOF 1486 1486 + } 1487 1487 + }() 1488 1488 + 1489 1489 + if maj != cbg.MajMap { 1490 1490 + return fmt.Errorf("cbor input should be of type map") 1491 1491 + } 1492 1492 + 1493 1493 + if extra > cbg.MaxLength { 1494 1494 + return fmt.Errorf("Image: map struct too large (%d)", extra) 1495 1495 + } 1496 1496 + 1497 1497 + n := extra 1498 1498 + 1499 1499 + nameBuf := make([]byte, 11) 1500 1500 + for i := uint64(0); i < n; i++ { 1501 1501 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 1502 1502 + if err != nil { 1503 1503 + return err 1504 1504 + } 1505 1505 + 1506 1506 + if !ok { 1507 1507 + // Field doesn't exist on this type, so ignore it 1508 1508 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1509 1509 + return err 1510 1510 + } 1511 1511 + continue 1512 1512 + } 1513 1513 + 1514 1514 + switch string(nameBuf[:nameLen]) { 1515 1515 + // t.Alt (string) (string) 1516 1516 + case "alt": 1517 1517 + 1518 1518 + { 1519 1519 + sval, err := cbg.ReadStringWithMax(cr, 8192) 1520 1520 + if err != nil { 1521 1521 + return err 1522 1522 + } 1523 1523 + 1524 1524 + t.Alt = string(sval) 1525 1525 + } 1526 1526 + // t.Blob (util.BlobSchema) (struct) 1527 1527 + case "blob": 1528 1528 + 1529 1529 + { 1530 1530 + 1531 1531 + b, err := cr.ReadByte() 1532 1532 + if err != nil { 1533 1533 + return err 1534 1534 + } 1535 1535 + if b != cbg.CborNull[0] { 1536 1536 + if err := cr.UnreadByte(); err != nil { 1537 1537 + return err 1538 1538 + } 1539 1539 + t.Blob = new(util.BlobSchema) 1540 1540 + if err := t.Blob.UnmarshalCBOR(cr); err != nil { 1541 1541 + return xerrors.Errorf("unmarshaling t.Blob pointer: %w", err) 1542 1542 + } 1543 1543 + } 1544 1544 + 1545 1545 + } 1546 1546 + // t.LexiconTypeID (string) (string) 1547 1547 + case "$type": 1548 1548 + 1549 1549 + { 1550 1550 + sval, err := cbg.ReadStringWithMax(cr, 8192) 1551 1551 + if err != nil { 1552 1552 + return err 1553 1553 + } 1554 1554 + 1555 1555 + t.LexiconTypeID = string(sval) 1556 1556 + } 1557 1557 + // t.AspectRatio (lex.AspectRatio) (struct) 1558 1558 + case "aspectRatio": 1559 1559 + 1560 1560 + { 1561 1561 + 1562 1562 + b, err := cr.ReadByte() 1563 1563 + if err != nil { 1564 1564 + return err 1565 1565 + } 1566 1566 + if b != cbg.CborNull[0] { 1567 1567 + if err := cr.UnreadByte(); err != nil { 1568 1568 + return err 1569 1569 + } 1570 1570 + t.AspectRatio = new(AspectRatio) 1571 1571 + if err := t.AspectRatio.UnmarshalCBOR(cr); err != nil { 1572 1572 + return xerrors.Errorf("unmarshaling t.AspectRatio pointer: %w", err) 1573 1573 + } 1574 1574 + } 1575 1575 + 1576 1576 + } 1577 1577 + 1578 1578 + default: 1579 1579 + // Field doesn't exist on this type, so ignore it 1580 1580 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1581 1581 + return err 1582 1582 + } 1583 1583 + } 1584 1584 + } 1585 1585 + 1586 1586 + return nil 1587 1587 + } 1588 1588 + func (t *MediaRecord) MarshalCBOR(w io.Writer) error { 1589 1589 + if t == nil { 1590 1590 + _, err := w.Write(cbg.CborNull) 1591 1591 + return err 1592 1592 + } 1593 1593 + 1594 1594 + cw := cbg.NewCborWriter(w) 1595 1595 + fieldCount := 6 1596 1596 + 1597 1597 + if t.Image == nil { 1598 1598 + fieldCount-- 1599 1599 + } 1600 1600 + 1601 1601 + if t.Nick == nil { 1602 1602 + fieldCount-- 1603 1603 + } 1604 1604 + 1605 1605 + if t.Color == nil { 1606 1606 + fieldCount-- 1607 1607 + } 1608 1608 + 1609 1609 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 1610 1610 + return err 1611 1611 + } 1612 1612 + 1613 1613 + // t.Nick (string) (string) 1614 1614 + if t.Nick != nil { 1615 1615 + 1616 1616 + if len("nick") > 8192 { 1617 1617 + return xerrors.Errorf("Value in field \"nick\" was too long") 1618 1618 + } 1619 1619 + 1620 1620 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("nick"))); err != nil { 1621 1621 + return err 1622 1622 + } 1623 1623 + if _, err := cw.WriteString(string("nick")); err != nil { 1624 1624 + return err 1625 1625 + } 1626 1626 + 1627 1627 + if t.Nick == nil { 1628 1628 + if _, err := cw.Write(cbg.CborNull); err != nil { 1629 1629 + return err 1630 1630 + } 1631 1631 + } else { 1632 1632 + if len(*t.Nick) > 8192 { 1633 1633 + return xerrors.Errorf("Value in field t.Nick was too long") 1634 1634 + } 1635 1635 + 1636 1636 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Nick))); err != nil { 1637 1637 + return err 1638 1638 + } 1639 1639 + if _, err := cw.WriteString(string(*t.Nick)); err != nil { 1640 1640 + return err 1641 1641 + } 1642 1642 + } 1643 1643 + } 1644 1644 + 1645 1645 + // t.LexiconTypeID (string) (string) 1646 1646 + if len("$type") > 8192 { 1647 1647 + return xerrors.Errorf("Value in field \"$type\" was too long") 1648 1648 + } 1649 1649 + 1650 1650 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 1651 1651 + return err 1652 1652 + } 1653 1653 + if _, err := cw.WriteString(string("$type")); err != nil { 1654 1654 + return err 1655 1655 + } 1656 1656 + 1657 1657 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("org.xcvr.lrc.media"))); err != nil { 1658 1658 + return err 1659 1659 + } 1660 1660 + if _, err := cw.WriteString(string("org.xcvr.lrc.media")); err != nil { 1661 1661 + return err 1662 1662 + } 1663 1663 + 1664 1664 + // t.Color (uint64) (uint64) 1665 1665 + if t.Color != nil { 1666 1666 + 1667 1667 + if len("color") > 8192 { 1668 1668 + return xerrors.Errorf("Value in field \"color\" was too long") 1669 1669 + } 1670 1670 + 1671 1671 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("color"))); err != nil { 1672 1672 + return err 1673 1673 + } 1674 1674 + if _, err := cw.WriteString(string("color")); err != nil { 1675 1675 + return err 1676 1676 + } 1677 1677 + 1678 1678 + if t.Color == nil { 1679 1679 + if _, err := cw.Write(cbg.CborNull); err != nil { 1680 1680 + return err 1681 1681 + } 1682 1682 + } else { 1683 1683 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.Color)); err != nil { 1684 1684 + return err 1685 1685 + } 1686 1686 + } 1687 1687 + 1688 1688 + } 1689 1689 + 1690 1690 + // t.Image (lex.Image) (struct) 1691 1691 + if t.Image != nil { 1692 1692 + 1693 1693 + if len("image") > 8192 { 1694 1694 + return xerrors.Errorf("Value in field \"image\" was too long") 1695 1695 + } 1696 1696 + 1697 1697 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("image"))); err != nil { 1698 1698 + return err 1699 1699 + } 1700 1700 + if _, err := cw.WriteString(string("image")); err != nil { 1701 1701 + return err 1702 1702 + } 1703 1703 + 1704 1704 + if err := t.Image.MarshalCBOR(cw); err != nil { 1705 1705 + return err 1706 1706 + } 1707 1707 + } 1708 1708 + 1709 1709 + // t.PostedAt (string) (string) 1710 1710 + if len("postedAt") > 8192 { 1711 1711 + return xerrors.Errorf("Value in field \"postedAt\" was too long") 1712 1712 + } 1713 1713 + 1714 1714 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("postedAt"))); err != nil { 1715 1715 + return err 1716 1716 + } 1717 1717 + if _, err := cw.WriteString(string("postedAt")); err != nil { 1718 1718 + return err 1719 1719 + } 1720 1720 + 1721 1721 + if len(t.PostedAt) > 8192 { 1722 1722 + return xerrors.Errorf("Value in field t.PostedAt was too long") 1723 1723 + } 1724 1724 + 1725 1725 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.PostedAt))); err != nil { 1726 1726 + return err 1727 1727 + } 1728 1728 + if _, err := cw.WriteString(string(t.PostedAt)); err != nil { 1729 1729 + return err 1730 1730 + } 1731 1731 + 1732 1732 + // t.SignetURI (string) (string) 1733 1733 + if len("signetURI") > 8192 { 1734 1734 + return xerrors.Errorf("Value in field \"signetURI\" was too long") 1735 1735 + } 1736 1736 + 1737 1737 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("signetURI"))); err != nil { 1738 1738 + return err 1739 1739 + } 1740 1740 + if _, err := cw.WriteString(string("signetURI")); err != nil { 1741 1741 + return err 1742 1742 + } 1743 1743 + 1744 1744 + if len(t.SignetURI) > 8192 { 1745 1745 + return xerrors.Errorf("Value in field t.SignetURI was too long") 1746 1746 + } 1747 1747 + 1748 1748 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.SignetURI))); err != nil { 1749 1749 + return err 1750 1750 + } 1751 1751 + if _, err := cw.WriteString(string(t.SignetURI)); err != nil { 1752 1752 + return err 1753 1753 + } 1754 1754 + return nil 1755 1755 + } 1756 1756 + 1757 1757 + func (t *MediaRecord) UnmarshalCBOR(r io.Reader) (err error) { 1758 1758 + *t = MediaRecord{} 1759 1759 + 1760 1760 + cr := cbg.NewCborReader(r) 1761 1761 + 1762 1762 + maj, extra, err := cr.ReadHeader() 1763 1763 + if err != nil { 1764 1764 + return err 1765 1765 + } 1766 1766 + defer func() { 1767 1767 + if err == io.EOF { 1768 1768 + err = io.ErrUnexpectedEOF 1769 1769 + } 1770 1770 + }() 1771 1771 + 1772 1772 + if maj != cbg.MajMap { 1773 1773 + return fmt.Errorf("cbor input should be of type map") 1774 1774 + } 1775 1775 + 1776 1776 + if extra > cbg.MaxLength { 1777 1777 + return fmt.Errorf("MediaRecord: map struct too large (%d)", extra) 1778 1778 + } 1779 1779 + 1780 1780 + n := extra 1781 1781 + 1782 1782 + nameBuf := make([]byte, 9) 1783 1783 + for i := uint64(0); i < n; i++ { 1784 1784 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192) 1785 1785 + if err != nil { 1786 1786 + return err 1787 1787 + } 1788 1788 + 1789 1789 + if !ok { 1790 1790 + // Field doesn't exist on this type, so ignore it 1791 1791 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1792 1792 + return err 1793 1793 + } 1794 1794 + continue 1795 1795 + } 1796 1796 + 1797 1797 + switch string(nameBuf[:nameLen]) { 1798 1798 + // t.Nick (string) (string) 1799 1799 + case "nick": 1800 1800 + 1801 1801 + { 1802 1802 + b, err := cr.ReadByte() 1803 1803 + if err != nil { 1804 1804 + return err 1805 1805 + } 1806 1806 + if b != cbg.CborNull[0] { 1807 1807 + if err := cr.UnreadByte(); err != nil { 1808 1808 + return err 1809 1809 + } 1810 1810 + 1811 1811 + sval, err := cbg.ReadStringWithMax(cr, 8192) 1812 1812 + if err != nil { 1813 1813 + return err 1814 1814 + } 1815 1815 + 1816 1816 + t.Nick = (*string)(&sval) 1817 1817 + } 1818 1818 + } 1819 1819 + // t.LexiconTypeID (string) (string) 1820 1820 + case "$type": 1821 1821 + 1822 1822 + { 1823 1823 + sval, err := cbg.ReadStringWithMax(cr, 8192) 1824 1824 + if err != nil { 1825 1825 + return err 1826 1826 + } 1827 1827 + 1828 1828 + t.LexiconTypeID = string(sval) 1829 1829 + } 1830 1830 + // t.Color (uint64) (uint64) 1831 1831 + case "color": 1832 1832 + 1833 1833 + { 1834 1834 + 1835 1835 + b, err := cr.ReadByte() 1836 1836 + if err != nil { 1837 1837 + return err 1838 1838 + } 1839 1839 + if b != cbg.CborNull[0] { 1840 1840 + if err := cr.UnreadByte(); err != nil { 1841 1841 + return err 1842 1842 + } 1843 1843 + maj, extra, err = cr.ReadHeader() 1844 1844 + if err != nil { 1845 1845 + return err 1846 1846 + } 1847 1847 + if maj != cbg.MajUnsignedInt { 1848 1848 + return fmt.Errorf("wrong type for uint64 field") 1849 1849 + } 1850 1850 + typed := uint64(extra) 1851 1851 + t.Color = &typed 1852 1852 + } 1853 1853 + 1854 1854 + } 1855 1855 + // t.Image (lex.Image) (struct) 1856 1856 + case "image": 1857 1857 + 1858 1858 + { 1859 1859 + 1860 1860 + b, err := cr.ReadByte() 1861 1861 + if err != nil { 1862 1862 + return err 1863 1863 + } 1864 1864 + if b != cbg.CborNull[0] { 1865 1865 + if err := cr.UnreadByte(); err != nil { 1866 1866 + return err 1867 1867 + } 1868 1868 + t.Image = new(Image) 1869 1869 + if err := t.Image.UnmarshalCBOR(cr); err != nil { 1870 1870 + return xerrors.Errorf("unmarshaling t.Image pointer: %w", err) 1871 1871 + } 1872 1872 + } 1873 1873 + 1874 1874 + } 1875 1875 + // t.PostedAt (string) (string) 1876 1876 + case "postedAt": 1877 1877 + 1878 1878 + { 1879 1879 + sval, err := cbg.ReadStringWithMax(cr, 8192) 1880 1880 + if err != nil { 1881 1881 + return err 1882 1882 + } 1883 1883 + 1884 1884 + t.PostedAt = string(sval) 1885 1885 + } 1886 1886 + // t.SignetURI (string) (string) 1887 1887 + case "signetURI": 1888 1888 + 1889 1889 + { 1890 1890 + sval, err := cbg.ReadStringWithMax(cr, 8192) 1891 1891 + if err != nil { 1892 1892 + return err 1893 1893 + } 1894 1894 + 1895 1895 + t.SignetURI = string(sval) 1196 1896 } 1197 1897 1198 1898 default:

+2 -6

server/internal/lex/types.go

··· 48 48 type MediaRecord struct { 49 49 LexiconTypeID string `json:"$type,const=org.xcvr.lrc.media" cborgen:"$type,const=org.xcvr.lrc.media"` 50 50 SignetURI string `json:"signetURI" cborgen:"signetURI"` 51 51 - Media Media `json:"media" cborgen:"media"` 51 51 + Image *Image `json:"image,omitempty" cborgen:"image,omitempty"` 52 52 Nick *string `json:"nick,omitempty" cborgen:"nick,omitempty"` 53 53 Color *uint64 `json:"color,omitempty" cborgen:"color,omitempty"` 54 54 PostedAt string `json:"postedAt" cborgen:"postedAt"` 55 55 } 56 56 57 57 - type Media struct { 58 58 - Image *Image 59 59 - } 60 60 - 61 57 type Image struct { 62 58 LexiconTypeID string `json:"$type,const=org.xcvr.lrc.image" cborgen:"$type,const=org.xcvr.lrc.image"` 63 59 Alt string `json:"alt" cborgen:"alt"` 64 60 AspectRatio *AspectRatio `json:"aspectRatio,omitempty" cborgen:"aspectRatio,omitempty"` 65 65 - Image *util.BlobSchema `json:"image,omitempty" cborgen:"image,omitempty"` 61 61 + Blob *util.BlobSchema `json:"blob,omitempty" cborgen:"blob,omitempty"` 66 62 } 67 63 68 64 type AspectRatio struct {

+7 -7

server/internal/recordmanager/media.go

··· 51 51 cnum := uint64(*cptr) 52 52 imr.Color = &cnum 53 53 } 54 54 - imr.Media.Image = mr.Image 54 54 + imr.Image = mr.Image 55 55 nowsyn := syntax.DatetimeNow() 56 56 imr.PostedAt = nowsyn.String() 57 57 nt := nowsyn.Time() ··· 68 68 img.URI = uri 69 69 img.DID = cs.Data.AccountDID.String() 70 70 img.SignetURI = imr.SignetURI 71 71 - if imr.Media.Image != nil { 72 72 - img.Alt = imr.Media.Image.Alt 73 73 - if imr.Media.Image.Image != nil { 74 74 - img.ImageMIME = &imr.Media.Image.Image.MimeType 75 75 - icid := imr.Media.Image.Image.Ref.String() 76 76 - img.ImageCID = &icid 71 71 + if imr.Image != nil { 72 72 + img.Alt = imr.Image.Alt 73 73 + if imr.Image.Blob != nil { 74 74 + img.BlobMIME = &imr.Image.Blob.MimeType 75 75 + icid := imr.Image.Blob.Ref.String() 76 76 + img.BlobCID = &icid 77 77 } 78 78 } 79 79 img.Nick = imr.Nick

+4 -2

server/internal/types/lexicons.go

··· 215 215 URI string 216 216 DID string 217 217 SignetURI string 218 218 - ImageCID *string 219 219 - ImageMIME *string 218 218 + BlobCID *string 219 219 + BlobMIME *string 220 220 Alt string 221 221 Nick *string 222 222 Color *uint32 223 223 CID string 224 224 + Width *int64 225 225 + Height *int64 224 226 PostedAt time.Time 225 227 IndexedAt time.Time 226 228 }