app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

mod.rs (17427B)


      1 // SPDX-License-Identifier: GPL-3.0-only
      2 // Public fixture recipes and API readback follow Radroots Lib revision
      3 // 189c49b74b4bafc142b00b76b296477931139e72's food_availability_conformance.rs
      4 // (MIT OR Apache-2.0). This tool never signs or receives private keys.
      5 #![forbid(unsafe_code)]
      6 
      7 use radroots_blossom::{BlobDescriptor, BlobUrl, MediaType, Sha256};
      8 use radroots_event::envelope::EventEnvelope;
      9 use radroots_event::food::availability::{
     10     FoodAvailabilityDetails, FoodAvailabilityDetailsParts, FoodAvailabilityError,
     11     FoodAvailabilityImage, FoodAvailabilityStatus, FoodContent, FoodCurrency, FoodIdentifier,
     12     FoodImageDimensions, FoodPrice, FoodPublishedAt, FoodQuantity, FoodText, FoodUnit,
     13 };
     14 use radroots_event::listing::classified::ClassifiedListingPartition;
     15 use radroots_event::media::AuthoredImage;
     16 use radroots_event::wire::Nip01EventWire;
     17 use radroots_event_codec::admission::food_availability::{
     18     RadrootsFoodAvailabilityAdmissionOutcome, validate_food_availability_revision,
     19     verify_and_admit_food_availability_event,
     20 };
     21 use radroots_event_codec::decode::food_availability::{
     22     RadrootsFoodAvailabilityProjectionOutcome, RadrootsInboundFoodAvailabilityProjection,
     23     project_verified_food_availability_event,
     24 };
     25 use radroots_event_codec::encode::food_availability::{
     26     RadrootsFoodAvailabilityEncodeError, authored_food_availability_build_tags,
     27     authored_food_availability_to_wire_parts,
     28 };
     29 use radroots_event_codec::verify::{RadrootsSignatureVerifiedEvent, verify_nip01_event};
     30 use serde::Deserialize;
     31 use serde_json::{Value, json};
     32 
     33 #[derive(Deserialize)]
     34 #[serde(deny_unknown_fields)]
     35 struct Details {
     36     content: Value,
     37     identifier: String,
     38     title: String,
     39     summary: String,
     40     published_at: u64,
     41     location: String,
     42     price: Price,
     43     quantity: Option<Quantity>,
     44     status: String,
     45     images: Vec<Image>,
     46 }
     47 #[derive(Deserialize)]
     48 #[serde(deny_unknown_fields)]
     49 struct Price {
     50     amount: String,
     51     currency: String,
     52     unit: String,
     53 }
     54 #[derive(Deserialize)]
     55 #[serde(deny_unknown_fields)]
     56 struct Quantity {
     57     amount: String,
     58     unit: String,
     59 }
     60 #[derive(Deserialize)]
     61 #[serde(deny_unknown_fields)]
     62 struct Image {
     63     bytes_utf8: String,
     64     url: String,
     65     media_type: String,
     66     uploaded_at: u64,
     67     dimensions: String,
     68 }
     69 
     70 fn text(recipe: &Value) -> String {
     71     if let Some(value) = recipe.get("value").and_then(Value::as_str) {
     72         assert_eq!(recipe.as_object().unwrap().len(), 1);
     73         value.to_owned()
     74     } else {
     75         assert_eq!(recipe.as_object().unwrap().len(), 2);
     76         let character = recipe["repeat"].as_str().unwrap();
     77         assert_eq!(character.chars().count(), 1);
     78         let count = usize::try_from(recipe["count"].as_u64().unwrap()).unwrap();
     79         assert!(count <= 262_144, "fixture recipe exceeds tooling bound");
     80         character.repeat(count)
     81     }
     82 }
     83 
     84 fn details(input: &Value) -> FoodAvailabilityDetails {
     85     let input: Details = serde_json::from_value(input.clone()).unwrap();
     86     let images = input
     87         .images
     88         .iter()
     89         .map(|image| {
     90             let bytes = image.bytes_utf8.as_bytes();
     91             let media_type = MediaType::parse(&image.media_type).unwrap();
     92             let verified = BlobDescriptor::new(
     93                 BlobUrl::parse(&image.url).unwrap(),
     94                 Sha256::digest(bytes),
     95                 u64::try_from(bytes.len()).unwrap(),
     96                 media_type.clone(),
     97                 image.uploaded_at,
     98             )
     99             .unwrap()
    100             .approve_reference()
    101             .unwrap()
    102             .verify_bytes(bytes, &media_type)
    103             .unwrap();
    104             FoodAvailabilityImage::new(
    105                 AuthoredImage::try_from_verified_descriptor(verified).unwrap(),
    106                 FoodImageDimensions::parse(&image.dimensions).unwrap(),
    107             )
    108         })
    109         .collect();
    110     FoodAvailabilityDetails::new(FoodAvailabilityDetailsParts {
    111         content: FoodContent::new(text(&input.content)).unwrap(),
    112         identifier: FoodIdentifier::parse(&input.identifier).unwrap(),
    113         title: FoodText::new(input.title).unwrap(),
    114         summary: FoodText::new(input.summary).unwrap(),
    115         published_at: FoodPublishedAt::new(input.published_at).unwrap(),
    116         location: FoodText::new(input.location).unwrap(),
    117         price: FoodPrice::new(
    118             input.price.amount,
    119             FoodCurrency::parse(&input.price.currency).unwrap(),
    120             FoodUnit::parse(&input.price.unit).unwrap(),
    121         )
    122         .unwrap(),
    123         quantity: input.quantity.map(|quantity| {
    124             FoodQuantity::new(quantity.amount, FoodUnit::parse(&quantity.unit).unwrap()).unwrap()
    125         }),
    126         status: FoodAvailabilityStatus::parse(&input.status).unwrap(),
    127         images,
    128     })
    129     .unwrap()
    130 }
    131 
    132 fn envelope(value: &Value) -> EventEnvelope {
    133     let raw = serde_json::to_string(value).unwrap();
    134     let wire = Nip01EventWire::parse_json(&raw).unwrap();
    135     wire.verify_id().unwrap();
    136     let event = wire.into_envelope().unwrap();
    137     // Check every signed field after the real wire parser, before admission.
    138     assert_eq!(event.id_hex(), value["id"].as_str().unwrap());
    139     assert_eq!(event.author().to_hex(), value["pubkey"].as_str().unwrap());
    140     assert_eq!(
    141         event.created_at_u64(),
    142         value["created_at"].as_u64().unwrap()
    143     );
    144     assert_eq!(u64::from(event.kind_u32()), value["kind"].as_u64().unwrap());
    145     assert_eq!(json!(event.tags_as_vec()), value["tags"]);
    146     assert_eq!(event.content(), value["content"].as_str().unwrap());
    147     event
    148 }
    149 
    150 fn verified(value: &Value) -> RadrootsSignatureVerifiedEvent {
    151     verify_nip01_event(envelope(value)).unwrap()
    152 }
    153 
    154 fn partition(value: ClassifiedListingPartition) -> &'static str {
    155     match value {
    156         ClassifiedListingPartition::FocusedFoodAvailability => "focused_food_availability",
    157         ClassifiedListingPartition::OperationalListing => "operational_listing",
    158         ClassifiedListingPartition::GenericNip99 => "generic_nip99",
    159         ClassifiedListingPartition::Ambiguous => "ambiguous",
    160     }
    161 }
    162 
    163 fn projection(value: &RadrootsInboundFoodAvailabilityProjection) -> Value {
    164     let images: Vec<_> = value
    165         .images()
    166         .iter()
    167         .map(|image| {
    168             let dimensions = image
    169                 .dimensions()
    170                 .map(|size| json!({"width":size.width(),"height":size.height()}));
    171             json!({
    172                 "raw_tag":image.raw_tag(),"url":image.url(),"dimensions":dimensions,
    173                 "diagnostics":image.diagnostics().iter().map(|d|d.code()).collect::<Vec<_>>(),
    174                 "qualifies":image.qualifies()
    175             })
    176         })
    177         .collect();
    178     json!({
    179         "content":value.content().as_str(),"identifier":value.identifier().as_str(),
    180         "title":value.title().as_str(),"summary":value.summary().as_str(),
    181         "published_at":value.published_at().as_u64(),"location":value.location().as_str(),
    182         "price":{"amount":value.price().amount(),"currency":value.price().currency().as_str(),"unit":value.price().unit().as_str()},
    183         "quantity":value.quantity().map(|q|json!({"amount":q.amount(),"unit":q.unit().as_str()})),
    184         "status":value.status().as_str(),"images":images,
    185         "diagnostics":value.diagnostics().iter().map(|d|d.code()).collect::<Vec<_>>()
    186     })
    187 }
    188 
    189 fn authored_error(error: &RadrootsFoodAvailabilityEncodeError) -> Value {
    190     match error {
    191         RadrootsFoodAvailabilityEncodeError::Domain(FoodAvailabilityError::PublishedAtFuture {
    192             published_at,
    193             created_at,
    194         }) => {
    195             json!({"code":error.code(),"message":error.to_string(),"published_at":published_at,"created_at":created_at})
    196         }
    197         RadrootsFoodAvailabilityEncodeError::EventWireTooLarge { max, actual } => {
    198             json!({"code":error.code(),"message":error.to_string(),"max":max,"actual":actual})
    199         }
    200         _ => json!({"code":error.code(),"message":error.to_string()}),
    201     }
    202 }
    203 
    204 pub(super) fn actual(vector: &Value) -> Value {
    205     let kind = vector["kind"].as_str().unwrap();
    206     let input = &vector["input"];
    207     match kind {
    208         "food_availability.build_authored_draft.valid"
    209         | "food_availability.build_authored_draft.invalid" => {
    210             let details = details(&input["details"]);
    211             let created_at = input["created_at"].as_u64().unwrap();
    212             match authored_food_availability_to_wire_parts(&details, created_at) {
    213                 Ok(wire) => {
    214                     assert_eq!(
    215                         wire.tags,
    216                         authored_food_availability_build_tags(&details, created_at).unwrap()
    217                     );
    218                     if vector["expected"]["wire_parts"]
    219                         .get("content_length")
    220                         .is_some()
    221                     {
    222                         json!({"wire_parts":{"kind":wire.kind,"content_length":wire.content.len(),"tags":wire.tags}})
    223                     } else {
    224                         json!({"wire_parts":{"kind":wire.kind,"content":wire.content,"tags":wire.tags}})
    225                     }
    226                 }
    227                 Err(error) => json!({"error":authored_error(&error)}),
    228             }
    229         }
    230         "food_availability.project_verified_event.valid"
    231         | "food_availability.project_verified_event.invalid" => {
    232             let event = verified(&input["event"]);
    233             match project_verified_food_availability_event(&event) {
    234                 Ok(RadrootsFoodAvailabilityProjectionOutcome::Focused(value))
    235                     if vector["expected"].get("projection").is_some() =>
    236                 {
    237                     json!({"outcome":"focused","event_id":event.event().id_hex(),"projection":projection(&value)})
    238                 }
    239                 Ok(RadrootsFoodAvailabilityProjectionOutcome::Focused(value)) => {
    240                     json!({"outcome":"focused","event_id":event.event().id_hex(),"image_count":value.images().len(),"diagnostics":value.diagnostics().iter().map(|d|d.code()).collect::<Vec<_>>(),"first_raw_tag":value.images().first().unwrap().raw_tag(),"last_raw_tag":value.images().last().unwrap().raw_tag()})
    241                 }
    242                 Ok(RadrootsFoodAvailabilityProjectionOutcome::Excluded(value)) => {
    243                     json!({"outcome":"excluded","event_id":event.event().id_hex(),"partition":partition(value)})
    244                 }
    245                 Ok(_) => panic!("unqualified projection outcome"),
    246                 Err(error) => json!({"error":{"code":error.code(),"message":error.to_string()}}),
    247             }
    248         }
    249         "food_availability.verify_and_admit_event.valid"
    250         | "food_availability.verify_and_admit_event.invalid" => {
    251             match verify_and_admit_food_availability_event(envelope(&input["event"])) {
    252                 Ok(RadrootsFoodAvailabilityAdmissionOutcome::Admitted(event)) => {
    253                     json!({"outcome":"admitted","event_id":event.event().id_hex(),"projection":projection(event.projection())})
    254                 }
    255                 Ok(RadrootsFoodAvailabilityAdmissionOutcome::Excluded(event)) => {
    256                     json!({"outcome":"excluded","event_id":event.event().id_hex(),"partition":partition(event.partition())})
    257                 }
    258                 Ok(_) => panic!("unqualified admission outcome"),
    259                 Err(error) => json!({"error":{"code":error.code(),"message":error.to_string()}}),
    260             }
    261         }
    262         "food_availability.validate_revision.valid"
    263         | "food_availability.validate_revision.invalid" => {
    264             let previous = verified(&input["previous"]);
    265             let current = verified(&input["current"]);
    266             match validate_food_availability_revision(&previous, &current) {
    267                 Ok(()) => json!({"result":"accepted","current_event_id":current.event().id_hex()}),
    268                 Err(error) => json!({"error":{"code":error.code(),"message":error.to_string()}}),
    269             }
    270         }
    271         _ => panic!("unqualified vector kind {kind}"),
    272     }
    273 }
    274 
    275 #[derive(Deserialize)]
    276 #[serde(deny_unknown_fields)]
    277 pub(super) struct WebTemplate {
    278     id: String,
    279     created_at: u64,
    280     wire_parts: WebParts,
    281     summary: String,
    282 }
    283 #[derive(Deserialize)]
    284 #[serde(deny_unknown_fields)]
    285 struct WebParts {
    286     kind: u32,
    287     content: String,
    288     tags: Vec<Vec<String>>,
    289 }
    290 
    291 pub(super) fn consume_template(template: &WebTemplate) -> Result<Value, String> {
    292     if template.id.is_empty()
    293         || template.id.len() > 128
    294         || template.created_at > 9_007_199_254_740_991
    295         || template.wire_parts.kind != 30402
    296         || template.wire_parts.content.len() > 16 * 1024
    297         || template.wire_parts.tags.len() > 9
    298     {
    299         return Err("unsupported bounded website template".into());
    300     }
    301     let value = |name: &str| -> Result<&str, String> {
    302         let tags = template
    303             .wire_parts
    304             .tags
    305             .iter()
    306             .filter(|tag| tag.first().is_some_and(|key| key == name))
    307             .collect::<Vec<_>>();
    308         match tags.as_slice() {
    309             [tag] if tag.len() == 2 => Ok(tag[1].as_str()),
    310             _ => Err("invalid website singleton tag".into()),
    311         }
    312     };
    313     let price_tags = template
    314         .wire_parts
    315         .tags
    316         .iter()
    317         .filter(|tag| tag.first().is_some_and(|key| key == "price"))
    318         .collect::<Vec<_>>();
    319     let price = match price_tags.as_slice() {
    320         [tag] if tag.len() == 3 => *tag,
    321         _ => return Err("invalid website price tag".into()),
    322     };
    323     let quantity_tags = template
    324         .wire_parts
    325         .tags
    326         .iter()
    327         .filter(|tag| tag.first().is_some_and(|key| key == "radroots:quantity"))
    328         .collect::<Vec<_>>();
    329     let quantity = match quantity_tags.as_slice() {
    330         [] => None,
    331         [tag] if tag.len() == 3 => Some(
    332             FoodQuantity::new(
    333                 &tag[1],
    334                 FoodUnit::parse(&tag[2]).map_err(|error| error.to_string())?,
    335             )
    336             .map_err(|error| error.to_string())?,
    337         ),
    338         _ => return Err("invalid website quantity tag".into()),
    339     };
    340     if value("summary")? != template.summary {
    341         return Err("website review summary differs from public template".into());
    342     }
    343     // Actual pinned public constructors and codec consume the website fields.
    344     // No synthetic signature, signer, native runtime or private key is involved.
    345     let details = FoodAvailabilityDetails::new(FoodAvailabilityDetailsParts {
    346         content: FoodContent::new(&template.wire_parts.content)
    347             .map_err(|error| error.to_string())?,
    348         identifier: FoodIdentifier::parse(value("d")?).map_err(|error| error.to_string())?,
    349         title: FoodText::new(value("title")?).map_err(|error| error.to_string())?,
    350         summary: FoodText::new(value("summary")?).map_err(|error| error.to_string())?,
    351         published_at: FoodPublishedAt::parse(value("published_at")?)
    352             .map_err(|error| error.to_string())?,
    353         location: FoodText::new(value("location")?).map_err(|error| error.to_string())?,
    354         price: FoodPrice::new(
    355             &price[1],
    356             FoodCurrency::parse(&price[2]).map_err(|error| error.to_string())?,
    357             FoodUnit::parse(value("radroots:price_unit")?).map_err(|error| error.to_string())?,
    358         )
    359         .map_err(|error| error.to_string())?,
    360         quantity,
    361         status: FoodAvailabilityStatus::parse(value("status")?)
    362             .map_err(|error| error.to_string())?,
    363         images: Vec::new(),
    364     })
    365     .map_err(|error| error.to_string())?;
    366     let actual = authored_food_availability_to_wire_parts(&details, template.created_at)
    367         .map_err(|error| error.to_string())?;
    368     if actual.kind != template.wire_parts.kind
    369         || actual.content != template.wire_parts.content
    370         || actual.tags != template.wire_parts.tags
    371     {
    372         return Err("website wire parts differ from actual pinned Rust codec".into());
    373     }
    374     Ok(
    375         json!({"id":template.id,"result":"accepted","wire_parts":{"kind":actual.kind,"content":actual.content,"tags":actual.tags}}),
    376     )
    377 }
    378 
    379 pub(super) fn boundary(row: &Value) -> Value {
    380     let value = row["value"].as_str().unwrap();
    381     let (identifier, timestamp) = match row["kind"].as_str().unwrap() {
    382         "timestamp" => match FoodPublishedAt::parse(value) {
    383             Ok(timestamp) => ("boundary-id", timestamp.as_u64()),
    384             Err(error) => return json!({"result":"rejected","code":error.code()}),
    385         },
    386         "identifier" => (value, 1),
    387         _ => panic!("unknown boundary kind"),
    388     };
    389     let recipe = json!({
    390         "content":{"value":"Fresh food available locally."},
    391         "identifier":identifier,"title":"Fresh food","summary":"Fresh food available locally.",
    392         "published_at":timestamp,"location":"Victoria",
    393         "price":{"amount":"1","currency":"CAD","unit":"g"},
    394         "quantity":null,"status":"active","images":[]
    395     });
    396     let wire = authored_food_availability_to_wire_parts(&details(&recipe), timestamp).unwrap();
    397     let tag = |name: &str| {
    398         wire.tags
    399             .iter()
    400             .find(|tag| tag.first().is_some_and(|key| key == name))
    401             .unwrap()[1]
    402             .clone()
    403     };
    404     if row["kind"] == "identifier" {
    405         json!({"result":"accepted","identifier":tag("d")})
    406     } else {
    407         json!({"result":"accepted","timestamp":timestamp.to_string(),"encoded_published_at":tag("published_at")})
    408     }
    409 }