···

       
437
       
437
       
 
       
            Ok(did) => did,

     

       
438
       
438
       
 
       
            Err(_) => {

     

       
439
       
439
       
 
       
                let Ok(alleged_handle) = Handle::new(identifier) else {

     

       
440
       
440
       
-
       
                    return invalid("identifier was not a valid DID or handle");

     

       
440
       
440
       
+
       
                    return invalid("Identifier was not a valid DID or handle");

     

       
441
       
441
       
 
       
                };

     

       
442
       
442
       
 
       


     

       
443
       
443
       
 
       
                match self.identity.handle_to_did(alleged_handle.clone()).await {

     
···

       
453
       
453
       
 
       
                    Err(e) => {

     

       
454
       
454
       
 
       
                        log::debug!("failed to resolve handle: {e}");

     

       
455
       
455
       
 
       
                        // TODO: ServerError not BadRequest

     

       
456
       
456
       
-
       
                        return invalid("errored while trying to resolve handle to DID");

     

       
456
       
456
       
+
       
                        return invalid("Errored while trying to resolve handle to DID");

     

       
457
       
457
       
 
       
                    }

     

       
458
       
458
       
 
       
                }

     

       
459
       
459
       
 
       
            }

     

       
460
       
460
       
 
       
        };

     

       
461
       
461
       
 
       
        let Ok(partial_doc) = self.identity.did_to_partial_mini_doc(&did).await else {

     

       
462
       
462
       
-
       
            return invalid("failed to get DID doc");

     

       
462
       
462
       
+
       
            return invalid("Failed to get DID doc");

     

       
463
       
463
       
 
       
        };

     

       
464
       
464
       
 
       
        let Some(partial_doc) = partial_doc else {

     

       
465
       
465
       
-
       
            return invalid("failed to find DID doc");

     

       
465
       
465
       
+
       
            return invalid("Failed to find DID doc");

     

       
466
       
466
       
 
       
        };

     

       
467
       
467
       
 
       


     

       
468
       
468
       
 
       
        // ok so here's where we're at:

     
···

       
483
       
483
       
 
       
                .handle_to_did(partial_doc.unverified_handle.clone())

     

       
484
       
484
       
 
       
                .await

     

       
485
       
485
       
 
       
            else {

     

       
486
       
486
       
-
       
                return invalid("failed to get did doc's handle");

     

       
486
       
486
       
+
       
                return invalid("Failed to get DID doc's handle");

     

       
487
       
487
       
 
       
            };

     

       
488
       
488
       
 
       
            let Some(handle_did) = handle_did else {

     

       
489
       
489
       
-
       
                return invalid("failed to resolve did doc's handle");

     

       
489
       
489
       
+
       
                return invalid("Failed to resolve DID doc's handle");

     

       
490
       
490
       
 
       
            };

     

       
491
       
491
       
 
       
            if handle_did == did {

     

       
492
       
492
       
 
       
                partial_doc.unverified_handle.to_string()

     
···

       
516
       
516
       
 
       
                let Ok(handle) = Handle::new(repo) else {

     

       
517
       
517
       
 
       
                    return GetRecordResponse::BadRequest(xrpc_error(

     

       
518
       
518
       
 
       
                        "InvalidRequest",

     

       
519
       
519
       
-
       
                        "repo was not a valid DID or handle",

     

       
519
       
519
       
+
       
                        "Repo was not a valid DID or handle",

     

       
520
       
520
       
 
       
                    ));

     

       
521
       
521
       
 
       
                };

     

       
522
       
522
       
 
       
                match self.identity.handle_to_did(handle).await {

     
···

       
534
       
534
       
 
       
                        log::debug!("handle resolution failed: {e}");

     

       
535
       
535
       
 
       
                        return GetRecordResponse::ServerError(xrpc_error(

     

       
536
       
536
       
 
       
                            "ResolutionFailed",

     

       
537
       
537
       
-
       
                            "errored while trying to resolve handle to DID",

     

       
537
       
537
       
+
       
                            "Errored while trying to resolve handle to DID",

     

       
538
       
538
       
 
       
                        ));

     

       
539
       
539
       
 
       
                    }

     

       
540
       
540
       
 
       
                }

     
···

       
544
       
544
       
 
       
        let Ok(collection) = Nsid::new(collection) else {

     

       
545
       
545
       
 
       
            return GetRecordResponse::BadRequest(xrpc_error(

     

       
546
       
546
       
 
       
                "InvalidRequest",

     

       
547
       
547
       
-
       
                "invalid NSID for collection",

     

       
547
       
547
       
+
       
                "Invalid NSID for collection",

     

       
548
       
548
       
 
       
            ));

     

       
549
       
549
       
 
       
        };

     

       
550
       
550
       
 
       


     

       
551
       
551
       
 
       
        let Ok(rkey) = RecordKey::new(rkey) else {

     

       
552
       
552
       
-
       
            return GetRecordResponse::BadRequest(xrpc_error("InvalidRequest", "invalid rkey"));

     

       
552
       
552
       
+
       
            return GetRecordResponse::BadRequest(xrpc_error("InvalidRequest", "Invalid rkey"));

     

       
553
       
553
       
 
       
        };

     

       
554
       
554
       
 
       


     

       
555
       
555
       
 
       
        let cid: Option<Cid> = if let Some(cid) = cid {

     

       
556
       
556
       
 
       
            let Ok(cid) = Cid::from_str(&cid) else {

     

       
557
       
557
       
-
       
                return GetRecordResponse::BadRequest(xrpc_error("InvalidRequest", "invalid CID"));

     

       
557
       
557
       
+
       
                return GetRecordResponse::BadRequest(xrpc_error("InvalidRequest", "Invalid CID"));

     

       
558
       
558
       
 
       
            };

     

       
559
       
559
       
 
       
            Some(cid)

     

       
560
       
560
       
 
       
        } else {