derec-library 0.0.1-alpha.8

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 DeRec Alliance. All rights reserved.

use crate::{
    primitives::unpairing::request,
    wasm::{
        primitives::{
            helpers::{parse_optional_transport_protocol, parse_shared_key, to_js},
            pairing::TransportProtocol,
            types::Timestamp,
        },
        ts_bindings_utils::js_error_from_lib,
    },
};
use serde::{Deserialize, Serialize};
use wasm_bindgen::prelude::*;

#[derive(Serialize, Deserialize, Clone)]
pub struct UnpairRequestMessage {
    pub memo: String,
    pub timestamp: Option<Timestamp>,
    /// Optional ephemeral response endpoint. See `replyTo` on the request
    /// proto for the routing semantics.
    pub reply_to: Option<TransportProtocol>,
}

impl From<derec_proto::UnpairRequestMessage> for UnpairRequestMessage {
    fn from(value: derec_proto::UnpairRequestMessage) -> Self {
        Self {
            memo: value.memo,
            timestamp: value.timestamp.map(Into::into),
            reply_to: value.reply_to.map(Into::into),
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct ProduceResult {
    #[serde(with = "serde_bytes")]
    pub envelope: Vec<u8>,
}

#[derive(Serialize, Deserialize)]
pub struct ExtractResult {
    pub request: UnpairRequestMessage,
}

#[wasm_bindgen(js_name = "unpairing_request_produce")]
pub fn produce(
    channel_id: u64,
    memo: &str,
    shared_key: &[u8],
    // Optional `TransportProtocol`. Pass null/undefined for no override.
    reply_to: JsValue,
) -> Result<JsValue, JsValue> {
    let shared_key = parse_shared_key(shared_key)?;
    let reply_to_proto = parse_optional_transport_protocol(reply_to)?;
    let result = request::produce(channel_id.into(), memo, &shared_key, reply_to_proto)
        .map_err(js_error_from_lib)?;
    to_js(&ProduceResult {
        envelope: result.envelope,
    })
}

#[wasm_bindgen(js_name = "unpairing_request_extract")]
pub fn extract(envelope_bytes: &[u8], shared_key: &[u8]) -> Result<JsValue, JsValue> {
    let shared_key = parse_shared_key(shared_key)?;
    let result = request::extract(envelope_bytes, &shared_key).map_err(js_error_from_lib)?;
    to_js(&ExtractResult {
        request: result.request.into(),
    })
}