~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/atlibs-identlink

ident.link agent-of walk with grants over CAR-verified sync.getRecord: Rust crate identlink, wasm, JS

1 collaborator
0
0
main
116 lines · 4.3 KB Raw History
use chrono::{DateTime, Utc};
use js_sys::{Array, Date, Function, Object, Promise, Reflect, JSON};
use serde::Serialize;
use serde_json::Value;
use wasm_bindgen::prelude::*;
use wasm_bindgen_futures::JsFuture;

use crate::{market_contract_held, DidDoc, Error, HttpIo, Io, Options, StrongRef};

struct JsIo {
    io: JsValue,
    http: HttpIo,
}

fn js_err(v: JsValue) -> Error {
    format!("{v:?}").into()
}

fn to_js<T: Serialize>(v: &T) -> Result<JsValue, JsValue> {
    JSON::parse(&serde_json::to_string(v).map_err(|e| e.to_string())?)
}

fn from_js<T: serde::de::DeserializeOwned>(v: &JsValue) -> Result<T, JsValue> {
    let s = JSON::stringify(v)?.as_string().unwrap_or_default();
    serde_json::from_str(&s).map_err(|e| e.to_string().into())
}

impl JsIo {
    fn func(&self, name: &str) -> Option<Function> {
        Reflect::get(&self.io, &name.into()).ok()?.dyn_into().ok()
    }

    async fn call(&self, f: &Function, args: &[JsValue]) -> Result<Option<String>, Error> {
        let args: Array = args.iter().collect();
        let v = JsFuture::from(Promise::resolve(&f.apply(&self.io, &args).map_err(js_err)?)).await.map_err(js_err)?;
        if v.is_null() || v.is_undefined() {
            return Ok(None);
        }
        Ok(JSON::stringify(&v).map_err(js_err)?.as_string())
    }
}

impl Io for JsIo {
    async fn resolve_did(&self, did: &str) -> Result<Option<DidDoc>, Error> {
        let Some(f) = self.func("resolveDid") else {
            return self.http.resolve_did(did).await;
        };
        Ok(match self.call(&f, &[did.into()]).await? {
            Some(s) => Some(serde_json::from_str(&s)?),
            None => None,
        })
    }

    async fn get_record(&self, repo: &str, collection: &str, rkey: &str) -> Result<Option<Value>, Error> {
        let Some(f) = self.func("getRecord") else {
            return self.http.get_record(repo, collection, rkey).await;
        };
        Ok(match self.call(&f, &[repo.into(), collection.into(), rkey.into()]).await? {
            Some(s) => Some(serde_json::from_str(&s)?),
            None => None,
        })
    }

    async fn contract_held(&self, contract: &StrongRef, authorities: &[String]) -> Result<bool, Error> {
        let Some(f) = self.func("contractHeld") else {
            return market_contract_held(self, contract, authorities).await;
        };
        let authorities: Array = authorities.iter().map(|a| JsValue::from_str(a)).collect();
        let contract = to_js(contract).map_err(js_err)?;
        Ok(self.call(&f, &[contract, authorities.into()]).await?.as_deref() == Some("true"))
    }

    fn now(&self) -> DateTime<Utc> {
        let ms = self
            .func("now")
            .and_then(|f| f.call0(&self.io).ok())
            .map(|v| Date::new(&v).get_time())
            .filter(|ms| ms.is_finite())
            .unwrap_or_else(Date::now);
        DateTime::from_timestamp_millis(ms as i64).unwrap_or(DateTime::<Utc>::MAX_UTC)
    }
}

#[wasm_bindgen(js_name = walk)]
pub async fn walk_js(io: JsValue, agent: String, options: JsValue) -> Result<JsValue, JsValue> {
    let options: Options = if options.is_object() { from_js(&options)? } else { Options::default() };
    let io = js_io(io);
    to_js(&crate::walk(&io, &agent, options).await)
}

fn js_io(io: JsValue) -> JsIo {
    JsIo { io: if io.is_object() { io } else { Object::new().into() }, http: HttpIo::default() }
}

#[wasm_bindgen(js_name = marketContractHeld)]
pub async fn market_contract_held_js(io: JsValue, contract: JsValue, authorities: Vec<String>) -> Result<bool, JsValue> {
    let contract: StrongRef = from_js(&contract)?;
    market_contract_held(&js_io(io), &contract, &authorities).await.map_err(|e| JsValue::from_str(&e.to_string()))
}

#[wasm_bindgen(js_name = recordCid)]
pub fn record_cid_js(value: JsValue) -> Result<String, JsValue> {
    crate::record_cid(&from_js(&value)?).map_err(|e| JsValue::from_str(&e.to_string()))
}

#[wasm_bindgen(js_name = agentOf)]
pub fn agent_of_js(also_known_as: Vec<String>) -> Vec<String> {
    crate::agent_of(&also_known_as)
}

#[wasm_bindgen(js_name = verifyRecord)]
pub fn verify_record_js(car: &[u8], doc: JsValue, repo: &str, collection: &str, rkey: &str) -> Result<JsValue, JsValue> {
    let doc: DidDoc = from_js(&doc)?;
    let value = crate::verify_record(car, &doc, repo, collection, rkey).map_err(|e| JsValue::from_str(&e.to_string()))?;
    to_js(&value)
}