use new impl

Author: ChristianPavilonis

Cargo.lock

@@ -43,6 +43,7 @@ sha2 = { workspace = true }
 tokio = { workspace = true }
 toml = { workspace = true }
 trusted-server-js = { path = "../js" }
+trusted-server-openrtb = { path = "../openrtb" }
 url = { workspace = true }
 urlencoding = { workspace = true }
 uuid = { workspace = true }

crates/common/Cargo.toml

@@ -16,7 +16,10 @@ use crate::auction::context::ContextValue;
 use crate::creative;
 use crate::error::TrustedServerError;
 use crate::geo::GeoInfo;
-use crate::openrtb::{OpenRtbBid, OpenRtbResponse, ResponseExt, SeatBid};
+use crate::openrtb::{
+    build_openrtb_bid, build_openrtb_response, build_seat_bid, maybe_object_from_serializable,
+    OpenRtbBidFields, ResponseExt,
+};
 use crate::settings::Settings;
 use crate::synthetic::{generate_synthetic_id, get_or_generate_synthetic_id};
 
@@ -240,21 +243,18 @@ pub fn convert_to_openrtb_response(
             String::new()
         };
 
-        let openrtb_bid = OpenRtbBid {
+        let openrtb_bid = build_openrtb_bid(OpenRtbBidFields {
             id: format!("{}-{}", bid.bidder, slot_id),
             impid: slot_id.to_string(),
             price,
             adm: Some(creative_html),
             crid: Some(format!("{}-creative", bid.bidder)),
-            w: Some(bid.width),
-            h: Some(bid.height),
+            width: Some(bid.width),
+            height: Some(bid.height),
             adomain: Some(bid.adomain.clone().unwrap_or_default()),
-        };
-
-        seatbids.push(SeatBid {
-            seat: Some(bid.bidder.clone()),
-            bid: vec![openrtb_bid],
         });
+
+        seatbids.push(build_seat_bid(Some(bid.bidder.clone()), vec![openrtb_bid]));
     }
 
     // Determine strategy name for response metadata
@@ -271,10 +271,10 @@ pub fn convert_to_openrtb_response(
         .map(ProviderSummary::from)
         .collect();
 
-    let response_body = OpenRtbResponse {
-        id: auction_request.id.to_string(),
-        seatbid: seatbids,
-        ext: Some(ResponseExt {
+    let response_body = build_openrtb_response(
+        auction_request.id.to_string(),
+        seatbids,
+        maybe_object_from_serializable(&ResponseExt {
             orchestrator: OrchestratorExt {
                 strategy: strategy_name.to_string(),
                 providers: result.provider_responses.len(),
@@ -283,7 +283,7 @@ pub fn convert_to_openrtb_response(
                 provider_details,
             },
         }),
-    };
+    );
 
     let body_bytes =
         serde_json::to_vec(&response_body).change_context(TrustedServerError::Auction {

crates/common/src/auction/formats.rs

@@ -23,8 +23,9 @@ use crate::integrations::{
     IntegrationRegistration,
 };
 use crate::openrtb::{
-    Banner, Device, Format, Geo, Imp, ImpExt, OpenRtbRequest, PrebidExt, PrebidImpExt, Regs,
-    RegsExt, RequestExt, Site, TrustedServerExt, User, UserExt,
+    build_banner, build_device, build_format, build_geo, build_imp, build_openrtb_request,
+    build_regs, build_site, build_user, maybe_object_from_serializable, ImpExt, OpenRtbRequest,
+    PrebidExt, PrebidImpExt, RegsExt, RequestExt, TrustedServerExt, UserExt,
 };
 use crate::request_signing::{RequestSigner, SigningParams, SIGNING_VERSION};
 use crate::settings::{IntegrationConfig, Settings};
@@ -488,18 +489,15 @@ impl PrebidAuctionProvider {
         context: &AuctionContext<'_>,
         signer: Option<(&RequestSigner, String, &SigningParams)>,
     ) -> OpenRtbRequest {
-        let imps: Vec<Imp> = request
+        let imps = request
             .slots
             .iter()
             .map(|slot| {
-                let formats: Vec<Format> = slot
+                let formats = slot
                     .formats
                     .iter()
                     .filter(|f| f.media_type == MediaType::Banner)
-                    .map(|f| Format {
-                        w: f.width,
-                        h: f.height,
-                    })
+                    .map(|f| build_format(f.width, f.height))
                     .collect();
 
                 // Extract zone from trustedServer params (sent by the JS
@@ -552,13 +550,13 @@ impl PrebidAuctionProvider {
                     }
                 }
 
-                Imp {
-                    id: slot.id.clone(),
-                    banner: Some(Banner { format: formats }),
-                    ext: Some(ImpExt {
+                build_imp(
+                    slot.id.clone(),
+                    Some(build_banner(formats)),
+                    maybe_object_from_serializable(&ImpExt {
                         prebid: PrebidImpExt { bidder },
                     }),
-                }
+                )
             })
             .collect();
 
@@ -572,35 +570,36 @@ impl PrebidAuctionProvider {
         });
 
         // Build user object
-        let user = Some(User {
-            id: Some(request.user.id.clone()),
-            ext: Some(UserExt {
+        let user = Some(build_user(
+            Some(request.user.id.clone()),
+            maybe_object_from_serializable(&UserExt {
                 synthetic_fresh: Some(request.user.fresh_id.clone()),
             }),
-        });
+        ));
 
         // Build device object with user-agent, client IP, and geo if available.
         // Forwarding the real client IP is critical: without it PBS infers the
         // IP from the incoming connection (a data-center / edge IP), causing
         // bidders like PubMatic to filter the traffic as non-human.
-        let device = request.device.as_ref().map(|d| Device {
-            ua: d.user_agent.clone(),
-            ip: d.ip.clone(),
-            geo: d.geo.as_ref().map(|geo| Geo {
-                geo_type: 2, // IP address per OpenRTB spec
-                country: Some(geo.country.clone()),
-                city: Some(geo.city.clone()),
-                region: geo.region.clone(),
-            }),
+        let device = request.device.as_ref().map(|d| {
+            build_device(
+                d.user_agent.clone(),
+                d.ip.clone(),
+                d.geo.as_ref().map(|geo| {
+                    build_geo(
+                        Some(geo.country.clone()),
+                        Some(geo.city.clone()),
+                        geo.region.clone(),
+                    )
+                }),
+            )
         });
 
         // Build regs object if Sec-GPC header is present
         let regs = if context.request.get_header("Sec-GPC").is_some() {
-            Some(Regs {
-                ext: Some(RegsExt {
-                    us_privacy: Some("1YYN".to_string()),
-                }),
-            })
+            Some(build_regs(maybe_object_from_serializable(&RegsExt {
+                us_privacy: Some("1YYN".to_string()),
+            })))
         } else {
             None
         };
@@ -620,7 +619,7 @@ impl PrebidAuctionProvider {
 
         let debug_enabled = self.config.debug;
 
-        let ext = Some(RequestExt {
+        let ext = maybe_object_from_serializable(&RequestExt {
             prebid: Some(PrebidExt {
                 debug: debug_enabled.then_some(true),
                 returnallbidstatus: debug_enabled.then_some(true),
@@ -635,19 +634,16 @@ impl PrebidAuctionProvider {
             }),
         });
 
-        OpenRtbRequest {
-            id: request.id.clone(),
-            imp: imps,
-            site: Some(Site {
-                domain: Some(request.publisher.domain.clone()),
-                page: page_url,
-            }),
+        build_openrtb_request(
+            request.id.clone(),
+            imps,
+            Some(build_site(Some(request.publisher.domain.clone()), page_url)),
             user,
             device,
             regs,
-            test: self.config.test_mode.then_some(1),
+            self.config.test_mode.then_some(1),
             ext,
-        }
+        )
     }
 
     /// Parse `OpenRTB` response into auction response.