20231115 oauth2 authreq (#2310)

* fix oauth2 requests
* Fix json compat of wasm bindgen

server/web_ui/admin/src/components/admin_groups.rs

@@ -10,6 +10,8 @@ use crate::components::admin_menu::{Entity, EntityType, GetError};
 use crate::router::AdminRoute;
 use kanidmd_web_ui_shared::constants::{CSS_CELL, CSS_TABLE};
 use kanidmd_web_ui_shared::{alpha_warning_banner, do_request, RequestMethod};
+#[cfg(debug_assertions)]
+use serde::Serialize;
 
 impl From<GetError> for AdminListGroupsMsg {
     fn from(ge: GetError) -> Self {
@@ -142,7 +144,10 @@ impl Component for AdminListGroups {
                 for key in response.keys() {
                     let j = response
                         .get(key)
-                        .and_then(|k| serde_wasm_bindgen::to_value(&k).ok())
+                        .and_then(|k| {
+                            k.serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+                                .ok()
+                        })
                         .and_then(|jsv| js_sys::JSON::stringify(&jsv).ok().map(|s| s.into()))
                         .unwrap_or_else(|| "Failed to dump response key".to_string());
                     console::log!("response: {}", j);

server/web_ui/admin/src/components/admin_oauth2.rs

@@ -10,6 +10,9 @@ use crate::components::admin_menu::{Entity, EntityType, GetError};
 use crate::router::AdminRoute;
 use kanidmd_web_ui_shared::constants::{CSS_CELL, CSS_TABLE};
 
+#[cfg(debug_assertions)]
+use serde::Serialize;
+
 impl From<GetError> for AdminListOAuth2Msg {
     fn from(ge: GetError) -> Self {
         AdminListOAuth2Msg::Failed {
@@ -138,7 +141,10 @@ impl Component for AdminListOAuth2 {
                 for key in response.keys() {
                     let j = response
                         .get(key)
-                        .and_then(|k| serde_wasm_bindgen::to_value(&k).ok())
+                        .and_then(|k| {
+                            k.serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+                                .ok()
+                        })
                         .and_then(|jsv| js_sys::JSON::stringify(&jsv).ok().map(|s| s.into()))
                         .unwrap_or_else(|| "Failed to dump response key".to_string());
                     console::log!("response: {}", j);

server/web_ui/login_flows/src/components.rs

@@ -26,6 +26,7 @@ use kanidmd_web_ui_shared::models::{
     pop_login_remember_me, pop_return_location, push_login_remember_me, set_bearer_token,
 };
 use kanidmd_web_ui_shared::{do_request, error::FetchError, utils, RequestMethod};
+use serde::Serialize;
 use yew_router::BrowserRouter;
 
 #[derive(Clone)]
@@ -160,8 +161,9 @@ impl LoginApp {
                 privileged: false,
             },
         };
-        let req_jsvalue =
+        let req_jsvalue = authreq
-            serde_wasm_bindgen::to_value(&authreq).expect("Failed to serialise request");
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 
         let (kopid, status, value, _) =
@@ -186,8 +188,9 @@ impl LoginApp {
 
     async fn reauth_init() -> Result<LoginAppMsg, FetchError> {
         let issue = AuthIssueSession::Token;
-        let req_jsvalue =
+        let req_jsvalue = issue
-            serde_wasm_bindgen::to_value(&issue).expect("Failed to serialise request");
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
         let url = "/v1/reauth";
         let (kopid, status, value, _) =
@@ -211,8 +214,9 @@ impl LoginApp {
     }
 
     async fn auth_step(authreq: AuthRequest) -> Result<LoginAppMsg, FetchError> {
-        let req_jsvalue =
+        let req_jsvalue = authreq
-            serde_wasm_bindgen::to_value(&authreq).expect("Failed to serialise request");
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 
         let (kopid, status, value, _) =

server/web_ui/login_flows/src/oauth2.rs

@@ -20,6 +20,7 @@ use kanidmd_web_ui_shared::models::{
 };
 use kanidmd_web_ui_shared::{do_request, error::FetchError, utils, RequestMethod};
 
+use serde::Serialize;
 use std::collections::BTreeSet;
 
 enum State {
@@ -92,9 +93,14 @@ impl Oauth2App {
     }
 
     async fn fetch_authreq(authreq: AuthorisationRequest) -> Result<Oauth2Msg, FetchError> {
+        let req_jsvalue_1 = authreq
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue =
-            serde_wasm_bindgen::to_value(&authreq).expect("Failed to serialise request");
+            js_sys::JSON::stringify(&req_jsvalue_1).expect_throw("failed to stringify");
-        let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
+
+        #[cfg(debug_assertions)]
+        console::debug!(&format!("fetch_authreq post {}", req_jsvalue));
 
         let (kopid, status, value, headers) =
             do_request(OAUTH2_AUTHORISE, RequestMethod::POST, Some(req_jsvalue)).await?;
@@ -141,8 +147,9 @@ impl Oauth2App {
     }
 
     async fn fetch_consent_token(consent_token: String) -> Result<Oauth2Msg, FetchError> {
-        let req_jsvalue =
+        let req_jsvalue = consent_token
-            serde_wasm_bindgen::to_value(&consent_token).expect("Failed to serialise request");
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 
         let mut opts = RequestInit::new();

server/web_ui/pkg/kanidmd_web_ui_admin.js

@@ -223,7 +223,7 @@ function addBorrowedObject(obj) {
 }
 function __wbg_adapter_38(arg0, arg1, arg2) {
     try {
-        wasm._dyn_core__ops__function__FnMut___A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h73d508a13868b8cd(arg0, arg1, addBorrowedObject(arg2));
+        wasm._dyn_core__ops__function__FnMut___A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h3e88c381a9b0da08(arg0, arg1, addBorrowedObject(arg2));
     } finally {
         heap[stack_pointer++] = undefined;
     }

server/web_ui/pkg/kanidmd_web_ui_login_flows.js

@@ -232,7 +232,7 @@ function addBorrowedObject(obj) {
 }
 function __wbg_adapter_48(arg0, arg1, arg2) {
     try {
-        wasm._dyn_core__ops__function__FnMut___A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h7bf04a09fe2e4b23(arg0, arg1, addBorrowedObject(arg2));
+        wasm._dyn_core__ops__function__FnMut___A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h3592199ac636c7ab(arg0, arg1, addBorrowedObject(arg2));
     } finally {
         heap[stack_pointer++] = undefined;
     }
@@ -1094,15 +1094,15 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper1407 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper1388 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 501, __wbg_adapter_48);
+        const ret = makeMutClosure(arg0, arg1, 488, __wbg_adapter_48);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper1770 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper1773 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 630, __wbg_adapter_51);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper1852 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper1855 = function(arg0, arg1, arg2) {
         const ret = makeMutClosure(arg0, arg1, 661, __wbg_adapter_54);
         return addHeapObject(ret);
     };

server/web_ui/pkg/kanidmd_web_ui_user.js

@@ -225,7 +225,7 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     return real;
 }
 function __wbg_adapter_48(arg0, arg1) {
-    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h0b7ba1f7c88fe439(arg0, arg1);
+    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h4b3f7f6f56bc064a(arg0, arg1);
 }
 
 let stack_pointer = 128;
@@ -237,7 +237,7 @@ function addBorrowedObject(obj) {
 }
 function __wbg_adapter_51(arg0, arg1, arg2) {
     try {
-        wasm._dyn_core__ops__function__FnMut___A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h8b40848531fa9e32(arg0, arg1, addBorrowedObject(arg2));
+        wasm._dyn_core__ops__function__FnMut___A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__ha7af6bbd80504275(arg0, arg1, addBorrowedObject(arg2));
     } finally {
         heap[stack_pointer++] = undefined;
     }
@@ -1141,20 +1141,20 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper1042 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper1393 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 574, __wbg_adapter_48);
+        const ret = makeMutClosure(arg0, arg1, 770, __wbg_adapter_48);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper3684 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper3682 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 1705, __wbg_adapter_51);
+        const ret = makeMutClosure(arg0, arg1, 1704, __wbg_adapter_51);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper3783 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper3781 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 1747, __wbg_adapter_54);
+        const ret = makeMutClosure(arg0, arg1, 1746, __wbg_adapter_54);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_closure_wrapper3865 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbindgen_closure_wrapper3863 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 1778, __wbg_adapter_57);
+        const ret = makeMutClosure(arg0, arg1, 1777, __wbg_adapter_57);
         return addHeapObject(ret);
     };
 

server/web_ui/user/src/components/change_unix_password.rs

@@ -3,6 +3,7 @@ use kanidmd_web_ui_shared::constants::ID_UNIX_PASSWORDCHANGE;
 use kanidmd_web_ui_shared::do_request;
 use kanidmd_web_ui_shared::error::FetchError;
 use kanidmd_web_ui_shared::RequestMethod;
+use serde::Serialize;
 use uuid::Uuid;
 use wasm_bindgen::{JsCast, UnwrapThrowExt};
 use web_sys::{FormData, HtmlFormElement};
@@ -247,9 +248,11 @@ impl Component for ChangeUnixPassword {
 
 impl ChangeUnixPassword {
     async fn update_unix_password(id: Uuid, new_password: String) -> Result<Msg, FetchError> {
-        let req_jsvalue = serde_wasm_bindgen::to_value(&SingleStringRequest {
+        let req = SingleStringRequest {
             value: new_password,
-        })
+        };
+        let req_jsvalue = req
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
             .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 

server/web_ui/user/src/components/totpdisplay.rs

@@ -3,6 +3,7 @@ use gloo::console;
 use gloo_timers::callback::{Interval, Timeout};
 use kanidm_proto::internal::{IdentifyUserRequest, IdentifyUserResponse};
 use kanidmd_web_ui_shared::constants::ID_IDENTITY_VERIFICATION_SYSTEM_TOTP_MODAL;
+use serde::Serialize;
 use wasm_bindgen::UnwrapThrowExt;
 use wasm_timer::SystemTime;
 use yew::prelude::*;
@@ -56,8 +57,9 @@ impl TotpDisplayApp {
         let uri = format!("/v1/person/{}/_identify_user", other_id);
         let request = IdentifyUserRequest::DisplayCode;
 
-        let req_jsvalue =
+        let req_jsvalue = request
-            serde_wasm_bindgen::to_value(&request).expect("Failed to serialise request");
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 
         let response = match do_request(&uri, RequestMethod::POST, Some(req_jsvalue)).await {

server/web_ui/user/src/credential/delete.rs

@@ -3,6 +3,7 @@ use gloo::console;
 use kanidm_proto::v1::{CURequest, CUSessionToken, CUStatus};
 use kanidmd_web_ui_shared::error::FetchError;
 use kanidmd_web_ui_shared::utils::modal_hide_by_id;
+use serde::Serialize;
 use wasm_bindgen::UnwrapThrowExt;
 use yew::prelude::*;
 
@@ -47,8 +48,10 @@ impl DeleteApp {
         req: CURequest,
         cb: Callback<EventBusMsg>,
     ) -> Result<Msg, FetchError> {
-        let req_jsvalue =
+        let request = (req, token);
-            serde_wasm_bindgen::to_value(&(req, token)).expect("Failed to serialise request");
+        let req_jsvalue = request
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 
         let (kopid, status, value, _) = do_request(

server/web_ui/user/src/credential/passkey.rs

@@ -3,6 +3,7 @@ use kanidm_proto::v1::{CURegState, CURequest, CUSessionToken, CUStatus};
 use kanidm_proto::webauthn::{CreationChallengeResponse, RegisterPublicKeyCredential};
 use kanidmd_web_ui_shared::constants::CLASS_BUTTON_SUCCESS;
 use kanidmd_web_ui_shared::error::FetchError;
+use serde::Serialize;
 use wasm_bindgen::UnwrapThrowExt;
 use wasm_bindgen_futures::JsFuture;
 use yew::prelude::*;
@@ -57,8 +58,10 @@ impl PasskeyModalApp {
         req: CURequest,
         cb: Callback<EventBusMsg>,
     ) -> Result<Msg, FetchError> {
-        let req_jsvalue =
+        let request = (req, token);
-            serde_wasm_bindgen::to_value(&(req, token)).expect("Failed to serialise request");
+        let req_jsvalue = request
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 
         let (kopid, status, value, _) = do_request(

server/web_ui/user/src/credential/passkeyremove.rs

@@ -1,6 +1,7 @@
 #[cfg(debug_assertions)]
 use gloo::console;
 use kanidm_proto::v1::{CURegState, CURequest, CUSessionToken, CUStatus};
+use serde::Serialize;
 use uuid::Uuid;
 use wasm_bindgen::UnwrapThrowExt;
 use yew::prelude::*;
@@ -63,8 +64,10 @@ impl PasskeyRemoveModalApp {
         req: CURequest,
         cb: Callback<EventBusMsg>,
     ) -> Result<Msg, FetchError> {
-        let req_jsvalue =
+        let request = (req, token);
-            serde_wasm_bindgen::to_value(&(req, token)).expect("Failed to serialise request");
+        let req_jsvalue = request
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 
         // this really should require a DELETE not a post!

server/web_ui/user/src/credential/pwmodal.rs

@@ -2,6 +2,7 @@ use gloo::console;
 use kanidm_proto::v1::{CURequest, CUSessionToken, CUStatus, OperationError, PasswordFeedback};
 use wasm_bindgen::UnwrapThrowExt;
 
+use serde::Serialize;
 use yew::prelude::*;
 
 use super::reset::{EventBusMsg, ModalProps};
@@ -55,7 +56,9 @@ impl PwModalApp {
     }
 
     async fn submit_password_update(token: CUSessionToken, pw: String) -> Result<Msg, FetchError> {
-        let req_jsvalue = serde_wasm_bindgen::to_value(&(CURequest::Password(pw), token))
+        let request = (CURequest::Password(pw), token);
+        let req_jsvalue = request
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
             .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 

server/web_ui/user/src/credential/reset.rs

@@ -8,6 +8,7 @@ use kanidmd_web_ui_shared::constants::{CSS_ALERT_DANGER, URL_USER_HOME};
 use kanidmd_web_ui_shared::models::{get_cred_update_session, pop_return_location};
 use kanidmd_web_ui_shared::utils::{autofocus, do_footer};
 use kanidmd_web_ui_shared::{add_body_form_classes, logo_img, remove_body_form_classes};
+use serde::Serialize;
 use uuid::Uuid;
 use wasm_bindgen::UnwrapThrowExt;
 use yew::prelude::*;
@@ -700,7 +701,9 @@ impl CredentialResetApp {
     }
 
     async fn exchange_intent_token(token: String) -> Result<Msg, FetchError> {
-        let req_jsvalue = serde_wasm_bindgen::to_value(&CUIntentToken { token })
+        let request = CUIntentToken { token };
+        let req_jsvalue = request
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
             .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 
@@ -722,8 +725,9 @@ impl CredentialResetApp {
     }
 
     async fn end_session(token: CUSessionToken, url: &str) -> Result<Msg, FetchError> {
-        let req_jsvalue =
+        let req_jsvalue = token
-            serde_wasm_bindgen::to_value(&token).expect("Failed to serialise request");
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 
         let (kopid, status, value, _) =

server/web_ui/user/src/credential/totpremove.rs

@@ -4,6 +4,7 @@ use gloo::console;
 use kanidm_proto::v1::{CURequest, CUSessionToken, CUStatus};
 use kanidmd_web_ui_shared::RequestMethod;
 use kanidmd_web_ui_shared::{do_request, error::FetchError};
+use serde::Serialize;
 use wasm_bindgen::UnwrapThrowExt;
 use yew::prelude::*;
 
@@ -101,8 +102,10 @@ impl TotpRemoveComp {
         req: CURequest,
         cb: Callback<EventBusMsg>,
     ) -> Result<Msg, FetchError> {
-        let req_jsvalue =
+        let request = (req, token);
-            serde_wasm_bindgen::to_value(&(req, token)).expect("Failed to serialise request");
+        let req_jsvalue = request
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 
         let (kopid, status, value, _) = do_request(

server/web_ui/user/src/views/identityverification.rs

@@ -3,6 +3,7 @@ use gloo::console;
 use kanidm_proto::internal::{IdentifyUserRequest, IdentifyUserResponse};
 use kanidmd_web_ui_shared::logo_img;
 use regex::Regex;
+use serde::Serialize;
 use wasm_bindgen::{JsValue, UnwrapThrowExt};
 use yew::prelude::*;
 
@@ -491,8 +492,9 @@ impl IdentityVerificationApp {
     ) -> Result<IdentifyUserResponse, String> {
         let uri = format!("/v1/person/{}/_identify_user", other_id);
 
-        let req_jsvalue =
+        let req_jsvalue = request
-            serde_wasm_bindgen::to_value(&request).expect("Failed to serialise request");
+            .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
+            .expect("Failed to serialise request");
         let req_jsvalue = js_sys::JSON::stringify(&req_jsvalue).expect_throw("failed to stringify");
 
         let (_, status, response, _) = do_request(&uri, RequestMethod::POST, Some(req_jsvalue))