use rete_core::{
batch_reach_serial, build_adjacency, build_dendrogram, choose_round_for_budget, eval_query,
eval_query_reasoned, eval_select_communities, eval_sparql, project_graph, schema_classes,
schema_summary, summary_query_shape, tile_by_community, validate_shacl, BlockCacheReader,
ByteRange, CountingReader, DataGraph, Header, QueryOutput, RangeReader, Rete, ReteGraph,
ShaclShapes, SliceReader, SummaryQueryShape, SummaryView, TripleProvenance, ValidationReport,
DEFAULT_BLOCK, DEFAULT_TILE_BUDGET,
};
use wasm_bindgen::prelude::*;
pub const JSON_SCHEMA_VERSION: u8 = 1;
#[wasm_bindgen(start)]
pub fn __start() {
#[cfg(feature = "asyncify")]
std::panic::set_hook(Box::new(|info| {
if let Some(loc) = info.location() {
let f = loc.file();
unsafe { rete_panic_report(f.as_ptr(), f.len(), loc.line()) };
} else {
unsafe { rete_panic_report(std::ptr::null(), 0, 0) };
}
}));
#[cfg(not(feature = "asyncify"))]
std::panic::set_hook(Box::new(|info| {
web_sys::console::error_1(&JsValue::from_str(&format!("rete-wasm panic: {info}")));
}));
}
#[wasm_bindgen]
pub fn info(bytes: &[u8]) -> Result<String, JsValue> {
let rete = open(bytes)?;
let h = rete.header();
Ok(format!(
r#"{{"schemaVersion":1,"quads":{},"terms":{},"pyramidLevels":{},"namedGraphs":{}}}"#,
h.quad_count,
h.term_count,
h.pyramid_levels,
rete.graph_names().len()
))
}
#[wasm_bindgen]
pub fn graph_names(bytes: &[u8]) -> Result<String, JsValue> {
let rete = open(bytes)?;
serde_json::to_string(&rete.graph_names()).map_err(err)
}
#[wasm_bindgen]
pub fn build(text: &str, format: &str) -> Result<Vec<u8>, JsValue> {
let quads = rete_core::ingest::parse_statements(text, format).map_err(err)?;
if quads.is_empty() {
return Err(js_error(
"no statements parsed (empty input or only comments)",
));
}
let (bytes, _stats) = rete_core::ingest::assemble_dataset(quads, &[]);
Ok(bytes)
}
#[wasm_bindgen]
pub fn query_triples(
bytes: &[u8],
subject: Option<String>,
predicate: Option<String>,
object: Option<String>,
) -> Result<String, JsValue> {
let rete = open(bytes)?;
let rows = rete.query(subject.as_deref(), predicate.as_deref(), object.as_deref());
serde_json::to_string(&rows).map_err(err)
}
#[wasm_bindgen]
pub fn why_triples(
bytes: &[u8],
subject: Option<String>,
predicate: Option<String>,
object: Option<String>,
) -> Result<String, JsValue> {
why_triples_json(
bytes,
subject.as_deref(),
predicate.as_deref(),
object.as_deref(),
)
.map_err(js_error)
}
pub fn why_triples_json(
bytes: &[u8],
subject: Option<&str>,
predicate: Option<&str>,
object: Option<&str>,
) -> Result<String, String> {
use serde_json::json;
let rete = Rete::open(bytes).map_err(|e| e.to_string())?;
let results = rete.query_with_provenance(subject, predicate, object);
let out = json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"pattern": {
"subject": subject,
"predicate": predicate,
"object": object,
},
"resultCount": results.len(),
"results": results.iter().map(provenance_json).collect::<Vec<_>>(),
});
serde_json::to_string(&out).map_err(|e| e.to_string())
}
#[wasm_bindgen]
pub fn query_sparql(bytes: &[u8], query: &str) -> Result<String, JsValue> {
let rete = open(bytes)?;
let (_vars, solutions) = eval_sparql(&rete, query).map_err(err)?;
serde_json::to_string(&solutions).map_err(err)
}
#[wasm_bindgen]
pub fn schema(bytes: &[u8]) -> Result<String, JsValue> {
let rete = open(bytes)?;
let classes = schema_classes(&rete);
let relations = schema_summary(&rete);
serde_json::to_string(&serde_json::json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"classes": classes,
"relations": relations,
}))
.map_err(err)
}
#[wasm_bindgen]
pub fn schema_packed(bytes: &[u8]) -> Result<String, JsValue> {
use serde_json::json;
let (classes, relations) = rete_core::read_schema_summary_ranged(&SliceReader::new(bytes))
.map_err(err)?
.ok_or_else(|| js_error("file has no schema pyramid"))?;
let classes: Vec<serde_json::Value> = classes.iter().map(|(c, n)| json!([c, n])).collect();
let relations: Vec<serde_json::Value> = relations
.iter()
.map(|(s, p, o, n)| json!([s, p, o, n]))
.collect();
Ok(json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"classes": classes,
"relations": relations,
})
.to_string())
}
#[wasm_bindgen]
pub fn card(bytes: &[u8]) -> Result<Option<String>, JsValue> {
let bytes = rete_core::read_metadata_ranged(&SliceReader::new(bytes)).map_err(err)?;
Ok(bytes.map(|b| String::from_utf8_lossy(&b).into_owned()))
}
#[wasm_bindgen]
pub fn card_url(url: &str) -> Result<Option<String>, JsValue> {
let reader = XhrRangeReader::open(url)?;
let bytes = rete_core::read_metadata_ranged(&reader).map_err(err)?;
Ok(bytes.map(|b| String::from_utf8_lossy(&b).into_owned()))
}
#[wasm_bindgen]
pub struct Graph {
rete: Rete,
file_len: usize,
}
#[wasm_bindgen]
impl Graph {
#[wasm_bindgen(constructor)]
pub fn new(bytes: &[u8]) -> Result<Graph, JsValue> {
Ok(Graph {
rete: open(bytes)?,
file_len: bytes.len(),
})
}
pub fn info(&self) -> String {
let h = self.rete.header();
format!(
r#"{{"schemaVersion":1,"quads":{},"terms":{},"pyramidLevels":{},"namedGraphs":{}}}"#,
h.quad_count,
h.term_count,
h.pyramid_levels,
self.rete.graph_names().len()
)
}
pub fn graph_names(&self) -> Result<String, JsValue> {
serde_json::to_string(&self.rete.graph_names()).map_err(err)
}
pub fn query(&self, query: &str, format: &str) -> Result<String, JsValue> {
query_json(&self.rete, query, format, "")
}
pub fn query_reasoned(&self, query: &str, format: &str) -> Result<String, JsValue> {
query_json_reasoned(&self.rete, query, format, "")
}
pub fn query_triples(
&self,
subject: Option<String>,
predicate: Option<String>,
object: Option<String>,
) -> Result<String, JsValue> {
let rows = self
.rete
.query(subject.as_deref(), predicate.as_deref(), object.as_deref());
serde_json::to_string(&rows).map_err(err)
}
pub fn prefix_search(&self, prefix: &str, limit: usize) -> Result<String, JsValue> {
prefix_search_json(&self.rete, prefix, limit)
}
pub fn text_search(
&self,
words: Vec<String>,
contains_prefix: Option<String>,
limit: usize,
) -> Result<String, JsValue> {
text_search_json(&self.rete, &words, contains_prefix.as_deref(), limit)
}
pub fn why_triples(
&self,
subject: Option<String>,
predicate: Option<String>,
object: Option<String>,
) -> Result<String, JsValue> {
use serde_json::json;
let results = self.rete.query_with_provenance(
subject.as_deref(),
predicate.as_deref(),
object.as_deref(),
);
let out = json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"pattern": { "subject": subject, "predicate": predicate, "object": object },
"resultCount": results.len(),
"results": results.iter().map(provenance_json).collect::<Vec<_>>(),
});
serde_json::to_string(&out).map_err(err)
}
pub fn schema(&self) -> Result<String, JsValue> {
serde_json::to_string(&serde_json::json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"classes": schema_classes(&self.rete),
"relations": schema_summary(&self.rete),
}))
.map_err(err)
}
pub fn card(&self) -> Option<String> {
self.rete
.metadata()
.map(|b| String::from_utf8_lossy(b).into_owned())
}
pub fn query_communities(&self, query: &str, round: Option<usize>) -> Result<String, JsValue> {
query_communities_value(&self.rete, query, round)
}
pub fn reach(&self, predicate: &str, seeds: &str, reverse: bool) -> Result<String, JsValue> {
reach_rete(&self.rete, predicate, seeds, reverse)
}
pub fn shacl(
&self,
shapes_turtle: &str,
graph: Option<String>,
format: &str,
) -> Result<String, JsValue> {
shacl_rete(&self.rete, shapes_turtle, graph.as_deref(), format)
}
pub fn reason(&self, graph: Option<String>) -> String {
let base = self.rete.dump(graph.as_deref());
reasoning_json(&rete_core::reason(&base), None)
}
pub fn pyramid_tree(&self) -> Result<String, JsValue> {
pyramid_tree_value(&self.rete)
}
pub fn file_layout(&self) -> Result<String, JsValue> {
use serde_json::json;
let segments: Vec<serde_json::Value> = self
.rete
.file_layout()
.iter()
.map(|s| json!({ "kind": s.kind, "label": s.label, "offset": s.offset, "len": s.len }))
.collect();
serde_json::to_string(&json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"fileLength": self.file_len,
"segments": segments,
}))
.map_err(err)
}
}
#[wasm_bindgen]
pub struct RemoteGraph {
reader: std::sync::Arc<CountingReader<XhrRangeReader>>,
rete: Rete,
}
#[wasm_bindgen]
impl RemoteGraph {
#[wasm_bindgen(constructor)]
pub fn new(url: &str) -> Result<RemoteGraph, JsValue> {
let (reader, rete) = open_url(url)?;
Ok(RemoteGraph { reader, rete })
}
pub fn stats(&self) -> String {
format!(
r#"{{"schemaVersion":1,"fileLength":{},"bytes":{},"requests":{}}}"#,
self.reader.len(),
self.reader.bytes_read(),
self.reader.requests()
)
}
pub fn content_hash(&self) -> String {
self.rete
.header()
.content_hash
.iter()
.map(|b| format!("{b:02x}"))
.collect()
}
pub fn query(&self, query: &str, format: &str) -> Result<String, JsValue> {
self.rete.reset_load_failures();
let s = query_json(&self.rete, query, format, "")?;
incomplete_guard(&self.rete, "query")?;
Ok(s)
}
pub fn query_reasoned(&self, query: &str, format: &str) -> Result<String, JsValue> {
self.rete.reset_load_failures();
let s = query_json_reasoned(&self.rete, query, format, "")?;
incomplete_guard(&self.rete, "query")?;
Ok(s)
}
pub fn prefix_search(&self, prefix: &str, limit: usize) -> Result<String, JsValue> {
prefix_search_json(&self.rete, prefix, limit)
}
pub fn text_search(
&self,
words: Vec<String>,
contains_prefix: Option<String>,
limit: usize,
) -> Result<String, JsValue> {
text_search_json(&self.rete, &words, contains_prefix.as_deref(), limit)
}
pub fn card(&self) -> Result<Option<String>, JsValue> {
let bytes = rete_core::read_metadata_ranged(&*self.reader).map_err(err)?;
Ok(bytes.map(|b| String::from_utf8_lossy(&b).into_owned()))
}
pub fn schema(&self) -> Result<String, JsValue> {
use serde_json::json;
let (classes, relations) = rete_core::read_schema_summary_ranged(&*self.reader)
.map_err(err)?
.ok_or_else(|| js_error("file has no schema pyramid"))?;
let classes: Vec<serde_json::Value> = classes.iter().map(|(c, n)| json!([c, n])).collect();
let relations: Vec<serde_json::Value> = relations
.iter()
.map(|(s, p, o, n)| json!([s, p, o, n]))
.collect();
Ok(json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"kind": "schema",
"classes": classes,
"relations": relations,
})
.to_string())
}
pub fn info(&self) -> String {
let h = self.rete.header();
format!(
r#"{{"schemaVersion":1,"quads":{},"terms":{},"pyramidLevels":{},"namedGraphs":{}}}"#,
h.quad_count,
h.term_count,
h.pyramid_levels,
self.rete.graph_names().len()
)
}
pub fn graph_names(&self) -> Result<String, JsValue> {
serde_json::to_string(&self.rete.graph_names()).map_err(err)
}
pub fn shacl(
&self,
shapes_turtle: &str,
graph: Option<String>,
format: &str,
) -> Result<String, JsValue> {
self.rete.reset_load_failures();
let out = shacl_rete(&self.rete, shapes_turtle, graph.as_deref(), format)?;
incomplete_guard(&self.rete, "validation")?;
Ok(out)
}
}
fn prefix_search_json(rete: &Rete, prefix: &str, limit: usize) -> Result<String, JsValue> {
use serde_json::json;
let hits: Vec<serde_json::Value> = rete
.prefix_search(prefix, limit)
.into_iter()
.map(|(label, subject)| json!({ "label": label, "subject": subject }))
.collect();
serde_json::to_string(&hits).map_err(err)
}
fn text_search_json(
rete: &Rete,
words: &[String],
contains_prefix: Option<&str>,
limit: usize,
) -> Result<String, JsValue> {
use serde_json::json;
let word_refs: Vec<&str> = words.iter().map(String::as_str).collect();
let hits: Vec<serde_json::Value> = rete
.text_search(&word_refs, contains_prefix, limit)
.into_iter()
.map(|subject| json!({ "subject": subject }))
.collect();
serde_json::to_string(&hits).map_err(err)
}
#[wasm_bindgen]
pub fn header_ranges(head: &[u8]) -> Result<String, JsValue> {
let h = Header::from_bytes(head).map_err(err)?;
Ok(format!(
r#"{{"schemaVersion":1,"dictOffset":{},"dictLen":{},"pyramidOffset":{},"pyramidLen":{},"indexOffset":{},"indexLen":{},"metadataOffset":{},"metadataLen":{}}}"#,
h.dictionary_offset,
h.dictionary_len,
h.pyramid_meta_offset,
h.pyramid_meta_len,
h.root_dir_offset,
h.root_dir_len,
h.metadata_offset,
h.metadata_len,
))
}
#[wasm_bindgen]
pub fn summary_overview(bytes: &[u8]) -> Result<String, JsValue> {
let view = SummaryView::open_ranged(&SliceReader::new(bytes))
.map_err(err)?
.ok_or_else(|| js_error("file has no pyramid summary"))?;
serde_json::to_string(&serde_json::json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"round": view.round,
"communities": view.community_count(),
"predicateTotals": view.predicate_totals(),
}))
.map_err(err)
}
#[wasm_bindgen]
pub fn progressive_query(bytes: &[u8], query: &str) -> Result<String, JsValue> {
progressive_query_json(bytes, query).map_err(js_error)
}
pub fn progressive_query_json(bytes: &[u8], query: &str) -> Result<String, String> {
use serde_json::json;
let shape = summary_query_shape(query)
.map_err(|e| e.to_string())?
.ok_or_else(|| "query is not exactly answerable from the summary".to_string())?;
let reader = CountingReader::new(SliceReader::new(bytes));
let file_bytes = reader.len();
let view = SummaryView::open_ranged(&reader)
.map_err(|e| e.to_string())?
.ok_or_else(|| "file has no pyramid summary".to_string())?;
let value = match shape {
SummaryQueryShape::PredicateCount {
predicate,
variable,
} => {
let count = u64::from(view.predicate_total(&predicate));
select_count_response(
&variable,
count,
progressive_meta(
&reader,
file_bytes,
"predicate_count",
Some(&predicate),
json!(count),
),
)
}
SummaryQueryShape::TripleCount { variable } => {
let count = summary_total(&view);
select_count_response(
&variable,
count,
progressive_meta(&reader, file_bytes, "triple_count", None, json!(count)),
)
}
SummaryQueryShape::PredicateTotals {
predicate_variable,
count_variable,
} => {
let totals = view.predicate_totals();
select_predicate_totals_response(
&predicate_variable,
&count_variable,
&totals,
progressive_meta(
&reader,
file_bytes,
"predicate_totals",
None,
json!(&totals),
),
)
}
SummaryQueryShape::PredicateList { variable } => {
let predicates = predicate_list(&view);
select_predicate_list_response(
&variable,
&predicates,
progressive_meta(
&reader,
file_bytes,
"predicate_list",
None,
json!(&predicates),
),
)
}
SummaryQueryShape::PredicateDistinctCount { variable } => {
let count = predicate_count(&view);
select_count_response(
&variable,
count,
progressive_meta(
&reader,
file_bytes,
"predicate_distinct_count",
None,
json!(count),
),
)
}
SummaryQueryShape::TripleExists => {
let exists = summary_total(&view) > 0;
json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"kind": "ask",
"boolean": exists,
"progressive": progressive_meta(
&reader,
file_bytes,
"triple_exists",
None,
json!(exists),
),
})
}
SummaryQueryShape::PredicateExists { predicate } => {
let exists = view.predicate_total(&predicate) > 0;
json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"kind": "ask",
"boolean": exists,
"progressive": progressive_meta(
&reader,
file_bytes,
"predicate_exists",
Some(&predicate),
json!(exists),
),
})
}
_ => return Err("summary query shape is not supported by this WASM build".to_string()),
};
serde_json::to_string(&value).map_err(|e| e.to_string())
}
#[wasm_bindgen]
pub fn query(bytes: &[u8], query: &str, format: &str) -> Result<String, JsValue> {
let rete = open(bytes)?;
query_json(&rete, query, format, "")
}
#[wasm_bindgen]
pub fn prefix_search(bytes: &[u8], prefix: &str, limit: usize) -> Result<String, JsValue> {
let rete = open(bytes)?;
prefix_search_json(&rete, prefix, limit)
}
#[wasm_bindgen]
pub fn text_search(
bytes: &[u8],
words: Vec<String>,
contains_prefix: Option<String>,
limit: usize,
) -> Result<String, JsValue> {
let rete = open(bytes)?;
text_search_json(&rete, &words, contains_prefix.as_deref(), limit)
}
fn query_json(rete: &Rete, query: &str, format: &str, extra: &str) -> Result<String, JsValue> {
query_json_opt(rete, query, format, extra, false)
}
fn query_json_reasoned(
rete: &Rete,
query: &str,
format: &str,
extra: &str,
) -> Result<String, JsValue> {
query_json_opt(rete, query, format, extra, true)
}
fn query_json_opt(
rete: &Rete,
query: &str,
format: &str,
extra: &str,
reason: bool,
) -> Result<String, JsValue> {
let out = if reason {
eval_query_reasoned(rete, query)
} else {
eval_query(rete, query)
}
.map_err(err)?;
Ok(write_query_json(&out, format, extra))
}
fn write_query_json(out: &QueryOutput, format: &str, extra: &str) -> String {
let mut versioned_extra = format!(r#","schemaVersion":{JSON_SCHEMA_VERSION}"#);
versioned_extra.push_str(extra);
if let QueryOutput::Construct(triples) = out {
let text = match format {
"ttl" => Some(("ttl", to_turtle(triples))),
"jsonld" => Some(("jsonld", to_jsonld(triples))),
_ => None,
};
if let Some((fmt, text)) = text {
let mut s = String::from(r#"{"kind":"construct","format":""#);
s.push_str(fmt);
s.push_str(r#"","text":"#);
rete_core::push_json_string(&mut s, &text);
s.push_str(&versioned_extra);
s.push('}');
return s;
}
}
rete_core::results_envelope_json(out, &versioned_extra)
}
struct XhrRangeReader {
url: String,
len: u64,
}
#[cfg(feature = "asyncify")]
#[link(wasm_import_module = "env")]
extern "C" {
fn rete_fetch_ranges(
url_ptr: *const u8,
url_len: usize,
offs_ptr: *const u64,
lens_ptr: *const u32,
n: usize,
dst_ptr: *mut u8,
) -> usize;
fn rete_file_len(url_ptr: *const u8, url_len: usize, out_ptr: *mut u64) -> usize;
fn rete_panic_report(file_ptr: *const u8, file_len: usize, line: u32);
}
fn checked_async_layout(ranges: &[(u64, u64)]) -> std::io::Result<(Vec<u64>, Vec<u32>, usize)> {
let offs: Vec<u64> = ranges.iter().map(|&(offset, _)| offset).collect();
let lens: Vec<u32> = ranges
.iter()
.map(|&(_, len)| {
u32::try_from(len).map_err(|_| {
std::io::Error::new(
std::io::ErrorKind::InvalidInput,
format!("range length {len} exceeds the wasm32 u32 length type"),
)
})
})
.collect::<std::io::Result<_>>()?;
let total = lens.iter().try_fold(0usize, |sum, &len| {
sum.checked_add(len as usize).ok_or_else(|| {
std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"range length sum overflow",
)
})
})?;
let _total_u32 = u32::try_from(total).map_err(|_| {
std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"range response exceeds the wasm32 address space",
)
})?;
Ok((offs, lens, total))
}
fn split_range_response(
ranges: &[(u64, u64)],
dst: Vec<u8>,
got: usize,
source: &str,
) -> std::io::Result<Vec<Vec<u8>>> {
let (_, lens, total) = checked_async_layout(ranges)?;
if dst.len() != total {
return Err(std::io::Error::other(format!(
"async fetch destination has {} bytes, expected {total} for {source}",
dst.len()
)));
}
if got != total {
return Err(std::io::Error::other(format!(
"async fetch returned {got} of {total} bytes for {source}"
)));
}
let mut out = Vec::with_capacity(ranges.len());
let mut pos = 0usize;
for len in lens {
let end = pos + len as usize;
out.push(dst[pos..end].to_vec());
pos = end;
}
Ok(out)
}
#[cfg(test)]
mod async_range_tests {
use super::{checked_async_layout, split_range_response};
#[test]
fn rejects_a_range_larger_than_the_wasm32_length_type() {
let error = checked_async_layout(&[(0, u64::from(u32::MAX) + 1)]).unwrap_err();
assert!(error.to_string().contains("u32"));
}
#[test]
fn rejects_a_total_larger_than_the_wasm32_address_space() {
let error = checked_async_layout(&[(0, u64::from(u32::MAX)), (0, 1)]).unwrap_err();
assert!(error.to_string().contains("address space"));
}
#[test]
fn accepts_no_ranges_and_preserves_zero_length_ranges() {
let (offs, lens, total) = checked_async_layout(&[]).unwrap();
assert!(offs.is_empty());
assert!(lens.is_empty());
assert_eq!(total, 0);
let (_, lens, total) = checked_async_layout(&[(7, 0), (9, 0)]).unwrap();
assert_eq!(lens, vec![0, 0]);
assert_eq!(total, 0);
}
#[test]
fn rejects_a_short_javascript_response() {
let error = split_range_response(&[(0, 4)], vec![1, 2, 3, 4], 3, "fixture").unwrap_err();
assert!(error.to_string().contains("returned 3 of 4 bytes"));
}
}
#[cfg(feature = "asyncify")]
impl XhrRangeReader {
fn read_ranges_async(&self, ranges: &[(u64, u64)]) -> std::io::Result<Vec<Vec<u8>>> {
let (offs, lens, total) = checked_async_layout(ranges)?;
if total == 0 {
return Ok(ranges.iter().map(|_| Vec::new()).collect());
}
let mut dst = vec![0u8; total];
if offs.len() != ranges.len() || lens.len() != ranges.len() || dst.len() != total {
return Err(std::io::Error::other(
"async range layout does not match its allocated buffers",
));
}
let got = unsafe {
rete_fetch_ranges(
self.url.as_ptr(),
self.url.len(),
offs.as_ptr(),
lens.as_ptr(),
ranges.len(),
dst.as_mut_ptr(),
)
};
let out = split_range_response(ranges, dst, got, &self.url)?;
report_progress(total);
Ok(out)
}
}
impl XhrRangeReader {
fn open(url: &str) -> Result<Self, JsValue> {
#[cfg(feature = "asyncify")]
{
let mut len: u64 = 0;
let ok = unsafe { rete_file_len(url.as_ptr(), url.len(), &mut len as *mut u64) };
if ok == 0 || len == 0 {
return Err(js_error(format!("could not determine length of {url}")));
}
Ok(Self {
url: url.to_string(),
len,
})
}
#[cfg(not(feature = "asyncify"))]
{
if let Some(len) = Self::head_len(url) {
return Ok(Self {
url: url.to_string(),
len,
});
}
let mut last = format!("could not determine length of {url}");
for _ in 0..4 {
match Self::probe_len(url) {
Ok(len) => {
return Ok(Self {
url: url.to_string(),
len,
})
}
Err(e) => last = e,
}
}
Err(js_error(last))
}
}
#[cfg(not(feature = "asyncify"))]
fn head_len(url: &str) -> Option<u64> {
let xhr = web_sys::XmlHttpRequest::new().ok()?;
xhr.open_with_async("HEAD", url, false).ok()?;
xhr.send().ok()?;
let status = xhr.status().ok()?;
if !(200..300).contains(&status) {
return None;
}
xhr.get_response_header("Content-Length")
.ok()
.flatten()
.and_then(|v| v.parse::<u64>().ok())
.filter(|&n| n > 0)
}
#[cfg(not(feature = "asyncify"))]
fn probe_len(url: &str) -> Result<u64, String> {
let err = |m: &str| m.to_string();
let xhr = web_sys::XmlHttpRequest::new().map_err(|_| err("xhr"))?;
xhr.open_with_async("GET", url, false)
.map_err(|_| err("open"))?;
xhr.set_response_type(web_sys::XmlHttpRequestResponseType::Arraybuffer);
xhr.set_request_header("Range", "bytes=0-0")
.map_err(|_| err("range header"))?;
xhr.send()
.map_err(|_| format!("probe {url}: network error"))?;
let status = xhr.status().map_err(|_| err("status"))?;
if status != 206 && !(200..300).contains(&status) {
return Err(format!("probe {url}: status {status}"));
}
xhr.get_response_header("Content-Range")
.ok()
.flatten()
.and_then(|v| {
v.rsplit('/')
.next()
.and_then(|t| t.trim().parse::<u64>().ok())
})
.or_else(|| {
xhr.get_response_header("Content-Length")
.ok()
.flatten()
.and_then(|v| v.parse::<u64>().ok())
})
.ok_or_else(|| format!("could not determine length of {url}"))
}
}
impl RangeReader for XhrRangeReader {
fn len(&self) -> u64 {
self.len
}
fn concurrency(&self) -> usize {
#[cfg(feature = "asyncify")]
{
16
}
#[cfg(not(feature = "asyncify"))]
{
let has_pool =
js_sys::Reflect::get(&js_sys::global(), &JsValue::from_str("reteReadMany"))
.map(|h| h.is_function())
.unwrap_or(false);
if has_pool {
16
} else {
1
}
}
}
fn read_at(&self, offset: u64, len: u64) -> std::io::Result<Vec<u8>> {
if len == 0 {
return Ok(Vec::new());
}
#[cfg(feature = "asyncify")]
{
Ok(self
.read_ranges_async(&[(offset, len)])?
.into_iter()
.next()
.unwrap())
}
#[cfg(not(feature = "asyncify"))]
{
let js = |e: JsValue| std::io::Error::other(format!("XHR error: {e:?}"));
let xhr = web_sys::XmlHttpRequest::new().map_err(js)?;
xhr.open_with_async("GET", &self.url, false).map_err(js)?;
xhr.set_response_type(web_sys::XmlHttpRequestResponseType::Arraybuffer);
let end = offset
.checked_add(len - 1)
.ok_or_else(|| std::io::Error::other("HTTP range end overflow"))?;
xhr.set_request_header("Range", &format!("bytes={offset}-{end}"))
.map_err(js)?;
xhr.send().map_err(js)?;
let status = xhr.status().map_err(js)?;
if status != 206 {
return Err(std::io::Error::other(format!(
"server ignored Range (status {status}, expected 206 Partial Content) for {}; \
the host must support HTTP range requests",
self.url
)));
}
let resp = xhr.response().map_err(js)?;
let mut buf = js_sys::Uint8Array::new(&resp).to_vec();
if (buf.len() as u64) < len {
return Err(std::io::Error::other(format!(
"short range response: got {} of {len} bytes at offset {offset} from {}",
buf.len(),
self.url
)));
}
let requested = usize::try_from(len)
.map_err(|_| std::io::Error::other("range exceeds wasm32 memory"))?;
buf.truncate(requested);
report_progress(buf.len());
Ok(buf)
}
}
fn read_many(&self, ranges: &[(u64, u64)]) -> std::io::Result<Vec<Vec<u8>>> {
#[cfg(feature = "asyncify")]
{
self.read_ranges_async(ranges)
}
#[cfg(not(feature = "asyncify"))]
{
let (_, _, total) = checked_async_layout(ranges)?;
if ranges.len() > 1 {
if let Some(buf) = self.read_many_via_pool(ranges) {
if buf.len() == total {
return split_range_response(ranges, buf, total, "globalThis.reteReadMany");
}
}
}
ranges.iter().map(|&(o, l)| self.read_at(o, l)).collect()
}
}
}
fn report_progress(bytes: usize) {
let g = js_sys::global();
if let Ok(f) = js_sys::Reflect::get(&g, &JsValue::from_str("reteProgress")) {
if let Ok(f) = f.dyn_into::<js_sys::Function>() {
let _ = f.call1(&JsValue::NULL, &JsValue::from_f64(bytes as f64));
}
}
}
#[cfg(not(feature = "asyncify"))]
impl XhrRangeReader {
fn read_many_via_pool(&self, ranges: &[(u64, u64)]) -> Option<Vec<u8>> {
let global = js_sys::global();
let hook = js_sys::Reflect::get(&global, &JsValue::from_str("reteReadMany")).ok()?;
if !hook.is_function() {
return None;
}
let hook = hook.dyn_into::<js_sys::Function>().ok()?;
let (_, checked_lens, _) = checked_async_layout(ranges).ok()?;
let count = u32::try_from(ranges.len()).ok()?;
let offs = js_sys::Float64Array::new_with_length(count);
let lens = js_sys::Float64Array::new_with_length(count);
const MAX_SAFE_JS_INTEGER: u64 = (1_u64 << 53) - 1;
for (i, (&(offset, _), &len)) in ranges.iter().zip(&checked_lens).enumerate() {
if offset > MAX_SAFE_JS_INTEGER {
return None;
}
let index = u32::try_from(i).ok()?;
offs.set_index(index, offset as f64);
lens.set_index(index, f64::from(len));
}
let res = hook
.call3(&JsValue::NULL, &JsValue::from_str(&self.url), &offs, &lens)
.ok()?;
if res.is_null() || res.is_undefined() {
return None;
}
Some(js_sys::Uint8Array::new(&res).to_vec())
}
}
struct XhrServiceClient;
impl rete_core::ServiceClient for XhrServiceClient {
fn query(&self, endpoint: &str, query: &str) -> Result<Vec<rete_core::Binding>, String> {
let e = |m: &str| format!("{endpoint}: {m}");
let xhr = web_sys::XmlHttpRequest::new().map_err(|_| e("xhr"))?;
xhr.open_with_async("POST", endpoint, false)
.map_err(|_| e("open"))?;
xhr.set_request_header("Content-Type", "application/x-www-form-urlencoded")
.map_err(|_| e("header"))?;
xhr.set_request_header("Accept", "application/sparql-results+json")
.map_err(|_| e("header"))?;
let body = format!(
"query={}",
String::from(js_sys::encode_uri_component(query))
);
xhr.send_with_opt_str(Some(&body))
.map_err(|_| e("network error (endpoint down or no CORS)"))?;
let status = xhr.status().map_err(|_| e("status"))?;
if !(200..300).contains(&status) {
return Err(e(&format!("HTTP {status}")));
}
let text = xhr
.response_text()
.map_err(|_| e("read"))?
.unwrap_or_default();
rete_core::parse_sparql_json_results(&text).map_err(|m| e(&m))
}
}
fn auto_block(len: u64) -> u64 {
const MB: u64 = 1 << 20;
let mult: u64 = if len > 100 * MB {
8 } else if len > 10 * MB {
4 } else {
2 };
mult * DEFAULT_BLOCK
}
fn open_url(url: &str) -> Result<(std::sync::Arc<CountingReader<XhrRangeReader>>, Rete), JsValue> {
let reader = std::sync::Arc::new(CountingReader::new(XhrRangeReader::open(url)?));
let cached = std::sync::Arc::new(BlockCacheReader::new(
reader.clone(),
auto_block(reader.len()),
));
let mut rete = Rete::open_ranged_lazy(cached).map_err(err)?;
rete.set_service_client(Box::new(XhrServiceClient));
Ok((reader, rete))
}
fn incomplete_guard(rete: &Rete, what: &str) -> Result<(), JsValue> {
if rete.index_incomplete() {
return Err(js_error(format!(
"a range fetch failed mid-{what}; refusing to return incomplete results"
)));
}
Ok(())
}
#[wasm_bindgen]
pub fn why_url(
url: &str,
subject: Option<String>,
predicate: Option<String>,
object: Option<String>,
) -> Result<String, JsValue> {
let (reader, rete) = open_url(url)?;
let out = why_triples_rete(
&rete,
subject.as_deref(),
predicate.as_deref(),
object.as_deref(),
)
.map_err(js_error)?;
incomplete_guard(&rete, "query")?;
let _ = reader;
Ok(out)
}
fn why_triples_rete(
rete: &Rete,
subject: Option<&str>,
predicate: Option<&str>,
object: Option<&str>,
) -> Result<String, String> {
use serde_json::json;
let results = rete.query_with_provenance(subject, predicate, object);
let out = json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"pattern": { "subject": subject, "predicate": predicate, "object": object },
"resultCount": results.len(),
"results": results.iter().map(provenance_json).collect::<Vec<_>>(),
});
serde_json::to_string(&out).map_err(|e| e.to_string())
}
#[wasm_bindgen]
pub fn sparql_url(url: &str, query: &str, format: &str) -> Result<String, JsValue> {
let (reader, rete) = open_url(url)?;
let file_length = reader.len();
let out = eval_query(&rete, query).map_err(err)?;
if rete.index_incomplete() {
return Err(js_error(
"a range fetch failed mid-query; refusing to return incomplete results",
));
}
let extra = format!(
r#","remote":{{"fileLength":{},"bytes":{},"requests":{}}}"#,
file_length,
reader.bytes_read(),
reader.requests(),
);
Ok(write_query_json(&out, format, &extra))
}
#[wasm_bindgen]
pub fn query_communities(
bytes: &[u8],
query: &str,
round: Option<usize>,
) -> Result<String, JsValue> {
query_communities_value(&open(bytes)?, query, round)
}
fn query_communities_value(
rete: &Rete,
query: &str,
round: Option<usize>,
) -> Result<String, JsValue> {
use serde_json::{json, Map, Value};
let (mut vars, solutions, partials) =
eval_select_communities(rete, query, round).map_err(err)?;
if vars.is_empty() {
let mut seen = std::collections::BTreeSet::new();
for s in &solutions {
for k in s.keys() {
if seen.insert(k.clone()) {
vars.push(k.clone());
}
}
}
}
let rows: Vec<Value> = solutions
.iter()
.map(|s| {
let mut obj = Map::new();
for var in &vars {
if let Some(term) = s.get(var) {
obj.insert(var.clone(), Value::String(term.clone()));
}
}
Value::Object(obj)
})
.collect();
let communities: Vec<Value> = partials
.iter()
.map(|p| json!({ "community": p.community, "subjects": p.subjects, "rows": p.rows }))
.collect();
serde_json::to_string(&json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"kind": "select",
"vars": vars,
"rows": rows,
"communities": communities,
}))
.map_err(err)
}
#[wasm_bindgen]
pub fn file_layout(bytes: &[u8]) -> Result<String, JsValue> {
use serde_json::json;
let rete = open(bytes)?;
let segments: Vec<serde_json::Value> = rete
.file_layout()
.iter()
.map(|s| json!({ "kind": s.kind, "label": s.label, "offset": s.offset, "len": s.len }))
.collect();
serde_json::to_string(&json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"fileLength": bytes.len(),
"segments": segments,
}))
.map_err(err)
}
#[wasm_bindgen]
pub fn pyramid_tree(bytes: &[u8]) -> Result<String, JsValue> {
pyramid_tree_value(&open(bytes)?)
}
fn pyramid_tree_value(rete: &Rete) -> Result<String, JsValue> {
use serde_json::json;
use std::collections::BTreeMap;
let dict = rete.dictionary();
let ids = rete.match_ids((None, None, None));
let g = project_graph(dict, &ids);
let dend = build_dendrogram(&g);
let rounds = dend.rounds();
if rounds == 0 {
return serde_json::to_string(&json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"rounds": 0,
"levels": [],
}))
.map_err(err);
}
let n = g.node_count();
let mut levels = Vec::with_capacity(rounds);
for r in 0..rounds {
let mut nodes_per: BTreeMap<usize, usize> = BTreeMap::new();
let mut rep: BTreeMap<usize, usize> = BTreeMap::new();
for node in 0..n {
let c = dend.base_community(node, r);
*nodes_per.entry(c).or_default() += 1;
rep.entry(c).or_insert(node);
}
let mut triples_per: BTreeMap<usize, usize> = BTreeMap::new();
for &(s, _, _) in &ids {
let c = dend.base_community(dict.subject_node(s) as usize, r);
*triples_per.entry(c).or_default() += 1;
}
let level: Vec<serde_json::Value> = nodes_per
.iter()
.map(|(&c, &nodes)| {
let parent = if r + 1 < rounds {
json!(dend.base_community(rep[&c], r + 1))
} else {
json!(null)
};
json!({
"id": c,
"nodes": nodes,
"triples": triples_per.get(&c).copied().unwrap_or(0),
"parent": parent,
})
})
.collect();
levels.push(level);
}
serde_json::to_string(&json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"rounds": rounds,
"levels": levels,
}))
.map_err(err)
}
#[wasm_bindgen]
pub fn communities(bytes: &[u8], round: Option<usize>) -> Result<String, JsValue> {
use std::collections::HashSet;
let rete = open(bytes)?;
let dict = rete.dictionary();
let ids = rete.match_ids((None, None, None));
let g = project_graph(dict, &ids);
let dend = build_dendrogram(&g);
let round =
round.unwrap_or_else(|| choose_round_for_budget(dict, &ids, &dend, DEFAULT_TILE_BUDGET));
let tiles = tile_by_community(dict, &ids, &dend, round);
let arr: Vec<serde_json::Value> = tiles
.iter()
.map(|t| {
let members: HashSet<u32> = t.triples.iter().map(|&(s, _, _)| s).collect();
serde_json::json!({
"community": t.community,
"size": members.len(),
"triples": t.triples.len(),
})
})
.collect();
serde_json::to_string(&arr).map_err(err)
}
#[wasm_bindgen]
pub fn reach(bytes: &[u8], predicate: &str, seeds: &str, reverse: bool) -> Result<String, JsValue> {
reach_rete(&open(bytes)?, predicate, seeds, reverse)
}
#[wasm_bindgen]
pub fn reach_url(
url: &str,
predicate: &str,
seeds: &str,
reverse: bool,
) -> Result<String, JsValue> {
let (reader, rete) = open_url(url)?;
let out = reach_rete(&rete, predicate, seeds, reverse)?;
incomplete_guard(&rete, "reach")?;
let _ = reader;
Ok(out)
}
fn reach_rete(rete: &Rete, predicate: &str, seeds: &str, reverse: bool) -> Result<String, JsValue> {
use std::collections::HashMap;
let dict = rete.dictionary();
let seed_iris: Vec<String> = match serde_json::from_str::<Vec<String>>(seeds) {
Ok(v) => v,
Err(_) => match serde_json::from_str::<String>(seeds) {
Ok(s) => vec![s],
Err(_) => vec![seeds.to_string()],
},
};
let adj: HashMap<u32, Vec<u32>> = if reverse {
let mut m: HashMap<u32, Vec<u32>> = HashMap::new();
for (s, o) in rete.predicate_pairs(predicate) {
m.entry(o).or_default().push(s); }
m
} else {
build_adjacency(rete, predicate)
};
let mut known_idx: Vec<usize> = Vec::new();
let mut seed_nodes: Vec<u32> = Vec::new();
for (i, iri) in seed_iris.iter().enumerate() {
if let Some(n) = dict.node_of_term(iri) {
known_idx.push(i);
seed_nodes.push(n);
}
}
let sets = batch_reach_serial(&adj, &seed_nodes);
let mut by_input: HashMap<usize, &std::collections::BTreeSet<u32>> = HashMap::new();
for (k, &i) in known_idx.iter().enumerate() {
by_input.insert(i, &sets[k]);
}
let arr: Vec<serde_json::Value> = seed_iris
.iter()
.enumerate()
.map(|(i, iri)| match by_input.get(&i) {
Some(set) => {
let reached: Vec<String> = set.iter().filter_map(|&n| dict.node_term(n)).collect();
serde_json::json!({
"seed": iri,
"count": reached.len(),
"reached": reached,
})
}
None => serde_json::json!({ "seed": iri, "error": "not in graph" }),
})
.collect();
serde_json::to_string(&arr).map_err(err)
}
#[wasm_bindgen]
pub fn shacl(
bytes: &[u8],
shapes_turtle: &str,
graph: Option<String>,
format: &str,
) -> Result<String, JsValue> {
shacl_rete(&open(bytes)?, shapes_turtle, graph.as_deref(), format)
}
#[wasm_bindgen]
pub fn shacl_url(
url: &str,
shapes_turtle: &str,
graph: Option<String>,
format: &str,
) -> Result<String, JsValue> {
let (reader, rete) = open_url(url)?;
let out = shacl_rete(&rete, shapes_turtle, graph.as_deref(), format)?;
incomplete_guard(&rete, "validation")?;
let _ = reader;
Ok(out)
}
fn shacl_rete(
rete: &Rete,
shapes_turtle: &str,
graph: Option<&str>,
format: &str,
) -> Result<String, JsValue> {
let shapes = ShaclShapes::parse_turtle(shapes_turtle).map_err(err)?;
let report = match graph {
None => validate_shacl(&ReteGraph::new(rete), &shapes),
Some(g) => validate_shacl(&DataGraph::from_rete(rete, Some(g)), &shapes),
};
Ok(format_report(&report, format))
}
fn shacl_over(data: DataGraph, shapes_turtle: &str, format: &str) -> Result<String, JsValue> {
let shapes = ShaclShapes::parse_turtle(shapes_turtle).map_err(err)?;
Ok(format_report(&validate_shacl(&data, &shapes), format))
}
fn format_report(report: &ValidationReport, format: &str) -> String {
match format {
"json" => report.to_json(),
"ttl" => report.to_turtle(),
_ => format_shacl_text(report),
}
}
#[wasm_bindgen]
pub fn shacl_construct_url(
url: &str,
construct: &str,
shapes_turtle: &str,
format: &str,
) -> Result<String, JsValue> {
let (reader, rete) = open_url(url)?;
let triples = match eval_query(&rete, construct).map_err(err)? {
QueryOutput::Construct(t) => t,
_ => {
return Err(js_error(
"the subset query must be a CONSTRUCT — it builds the subgraph SHACL validates",
))
}
};
incomplete_guard(&rete, "query")?;
let out = shacl_over(DataGraph::from_triples(triples), shapes_turtle, format)?;
let _ = reader;
Ok(out)
}
pub const COHERENCE_CONSTRUCT: &str = r#"
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX owl: <http://www.w3.org/2002/07/owl#>
CONSTRUCT {
?x rdf:type ?c .
?sub rdfs:subClassOf ?sup .
?c1 owl:disjointWith ?c2 .
?s1 owl:sameAs ?s2 .
?f1 owl:differentFrom ?f2 .
}
WHERE {
{ ?x rdf:type ?c }
UNION { ?sub rdfs:subClassOf ?sup }
UNION { ?c1 owl:disjointWith ?c2 }
UNION { ?s1 owl:sameAs ?s2 }
UNION { ?f1 owl:differentFrom ?f2 }
}
"#;
fn reasoning_json(r: &rete_core::Reasoning, remote: Option<(u64, u64, u64)>) -> String {
use serde_json::json;
let inconsistencies: Vec<serde_json::Value> = r
.inconsistencies
.iter()
.map(|i| json!({ "kind": i.kind, "detail": i.detail }))
.collect();
let mut v = json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"kind": "reasoning",
"coherent": r.inconsistencies.is_empty(),
"inferredCount": r.inferred.len(),
"inconsistencies": inconsistencies,
});
if let (Some(obj), Some((file_length, bytes, requests))) = (v.as_object_mut(), remote) {
obj.insert(
"remote".to_string(),
json!({ "fileLength": file_length, "bytes": bytes, "requests": requests }),
);
}
v.to_string()
}
#[wasm_bindgen]
pub fn reason(bytes: &[u8], graph: Option<String>) -> Result<String, JsValue> {
let rete = open(bytes)?;
let base = rete.dump(graph.as_deref());
let result = rete_core::reason(&base);
Ok(reasoning_json(&result, None))
}
#[wasm_bindgen]
pub fn reason_url(url: &str, graph: Option<String>) -> Result<String, JsValue> {
let (reader, rete) = open_url(url)?;
let base = rete.dump(graph.as_deref());
let result = rete_core::reason(&base);
incomplete_guard(&rete, "reasoning")?;
let out = reasoning_json(
&result,
Some((reader.len(), reader.bytes_read(), reader.requests())),
);
let _ = reader;
Ok(out)
}
#[wasm_bindgen]
pub fn reason_construct_url(url: &str, construct: &str) -> Result<String, JsValue> {
let (reader, rete) = open_url(url)?;
let triples =
match eval_query(&rete, construct).map_err(err)? {
QueryOutput::Construct(t) => t,
_ => return Err(js_error(
"the subset query must be a CONSTRUCT — it builds the subgraph the reasoner checks",
)),
};
incomplete_guard(&rete, "query")?;
let result = rete_core::reason(&triples);
let out = reasoning_json(
&result,
Some((reader.len(), reader.bytes_read(), reader.requests())),
);
let _ = reader;
Ok(out)
}
fn schema_coherence_json(
points: &[rete_core::Inconsistency],
remote: Option<(u64, u64, u64)>,
) -> String {
use serde_json::json;
let schema_points: Vec<serde_json::Value> = points
.iter()
.map(|i| json!({ "kind": i.kind, "detail": i.detail }))
.collect();
let mut v = json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"kind": "schemaCoherence",
"coherent": points.is_empty(),
"schemaPoints": schema_points,
"readsIndex": false,
});
if let (Some(obj), Some((file_length, bytes, requests))) = (v.as_object_mut(), remote) {
obj.insert(
"remote".to_string(),
json!({ "fileLength": file_length, "bytes": bytes, "requests": requests }),
);
}
v.to_string()
}
#[wasm_bindgen]
pub fn check_schema(bytes: &[u8]) -> Result<String, JsValue> {
let points = rete_core::read_schema_coherence_ranged(&SliceReader::new(bytes))
.map_err(err)?
.ok_or_else(|| js_error("file has no schema pyramid"))?;
Ok(schema_coherence_json(&points, None))
}
#[wasm_bindgen]
pub fn check_schema_url(url: &str) -> Result<String, JsValue> {
let reader = CountingReader::new(XhrRangeReader::open(url)?);
let points = rete_core::read_schema_coherence_ranged(&reader)
.map_err(err)?
.ok_or_else(|| js_error("file has no schema pyramid"))?;
Ok(schema_coherence_json(
&points,
Some((reader.len(), reader.bytes_read(), reader.requests())),
))
}
#[wasm_bindgen]
pub fn schema_url(url: &str) -> Result<String, JsValue> {
use serde_json::json;
let reader = CountingReader::new(XhrRangeReader::open(url)?);
let (classes, relations) = rete_core::read_schema_summary_ranged(&reader)
.map_err(err)?
.ok_or_else(|| js_error("file has no schema pyramid"))?;
let classes: Vec<serde_json::Value> = classes.iter().map(|(c, n)| json!([c, n])).collect();
let relations: Vec<serde_json::Value> = relations
.iter()
.map(|(s, p, o, n)| json!([s, p, o, n]))
.collect();
Ok(json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"kind": "schema",
"classes": classes,
"relations": relations,
"remote": { "fileLength": reader.len(), "bytes": reader.bytes_read(), "requests": reader.requests() },
})
.to_string())
}
fn format_shacl_text(report: &ValidationReport) -> String {
if report.conforms {
return "conforms: true\n".to_string();
}
let mut out = format!("conforms: false\nresults: {}\n", report.results.len());
for result in &report.results {
out.push_str("\n- focus: ");
out.push_str(&result.focus_node);
if let Some(value) = &result.value_node {
out.push_str("\n value: ");
out.push_str(value);
}
if let Some(path) = &result.result_path {
out.push_str("\n path: ");
out.push_str(path);
}
out.push_str("\n component: ");
out.push_str(&result.source_constraint_component);
out.push_str("\n severity: ");
out.push_str(&result.severity.iri());
for message in &result.messages {
out.push_str("\n message: ");
out.push_str(message);
}
out.push('\n');
}
out
}
#[cfg(feature = "threads")]
pub use wasm_bindgen_rayon::init_thread_pool;
#[cfg(feature = "threads")]
#[wasm_bindgen]
pub fn reach_parallel(
bytes: &[u8],
predicate: &str,
seeds: &str,
reverse: bool,
) -> Result<String, JsValue> {
use std::collections::HashMap;
let rete = open(bytes)?;
let dict = rete.dictionary();
let seed_iris: Vec<String> = match serde_json::from_str::<Vec<String>>(seeds) {
Ok(v) => v,
Err(_) => match serde_json::from_str::<String>(seeds) {
Ok(s) => vec![s],
Err(_) => vec![seeds.to_string()],
},
};
let adj: HashMap<u32, Vec<u32>> = if reverse {
let mut m: HashMap<u32, Vec<u32>> = HashMap::new();
for (s, o) in rete.predicate_pairs(predicate) {
m.entry(o).or_default().push(s); }
m
} else {
build_adjacency(&rete, predicate)
};
let mut known_idx: Vec<usize> = Vec::new();
let mut seed_nodes: Vec<u32> = Vec::new();
for (i, iri) in seed_iris.iter().enumerate() {
if let Some(n) = dict.node_of_term(iri) {
known_idx.push(i);
seed_nodes.push(n);
}
}
let sets = rete_core::parallel::batch_reach_parallel(&adj, &seed_nodes);
let mut by_input: HashMap<usize, &std::collections::BTreeSet<u32>> = HashMap::new();
for (k, &i) in known_idx.iter().enumerate() {
by_input.insert(i, &sets[k]);
}
let arr: Vec<serde_json::Value> = seed_iris
.iter()
.enumerate()
.map(|(i, iri)| match by_input.get(&i) {
Some(set) => {
let reached: Vec<String> = set.iter().filter_map(|&n| dict.node_term(n)).collect();
serde_json::json!({
"seed": iri,
"count": reached.len(),
"reached": reached,
})
}
None => serde_json::json!({ "seed": iri, "error": "not in graph" }),
})
.collect();
serde_json::to_string(&arr).map_err(err)
}
const RDF_TYPE_IRI: &str = "<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>";
const XSD_INTEGER_IRI: &str = "http://www.w3.org/2001/XMLSchema#integer";
fn summary_total(view: &SummaryView) -> u64 {
view.summary.iter().map(|edge| u64::from(edge.count)).sum()
}
fn predicate_list(view: &SummaryView) -> Vec<String> {
view.predicate_totals()
.into_iter()
.map(|(predicate, _)| predicate)
.collect()
}
fn predicate_count(view: &SummaryView) -> u64 {
view.predicate_totals().len() as u64
}
fn select_count_response(
variable: &str,
count: u64,
progressive: serde_json::Value,
) -> serde_json::Value {
use serde_json::{json, Map, Value};
let mut row = Map::new();
row.insert(variable.to_string(), Value::String(integer_literal(count)));
json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"kind": "select",
"vars": [variable],
"rows": [Value::Object(row)],
"progressive": progressive,
})
}
fn select_predicate_list_response(
variable: &str,
predicates: &[String],
progressive: serde_json::Value,
) -> serde_json::Value {
use serde_json::{json, Map, Value};
let rows: Vec<Value> = predicates
.iter()
.map(|predicate| {
let mut row = Map::new();
row.insert(variable.to_string(), Value::String(predicate.clone()));
Value::Object(row)
})
.collect();
json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"kind": "select",
"vars": [variable],
"rows": rows,
"progressive": progressive,
})
}
fn select_predicate_totals_response(
predicate_variable: &str,
count_variable: &str,
totals: &[(String, u32)],
progressive: serde_json::Value,
) -> serde_json::Value {
use serde_json::{json, Map, Value};
let rows: Vec<Value> = totals
.iter()
.map(|(predicate, count)| {
let mut row = Map::new();
row.insert(
predicate_variable.to_string(),
Value::String(predicate.clone()),
);
row.insert(
count_variable.to_string(),
Value::String(integer_literal(u64::from(*count))),
);
Value::Object(row)
})
.collect();
json!({
"schemaVersion": JSON_SCHEMA_VERSION,
"kind": "select",
"vars": [predicate_variable, count_variable],
"rows": rows,
"progressive": progressive,
})
}
fn progressive_meta<R: RangeReader>(
reader: &CountingReader<R>,
file_bytes: u64,
query_shape: &str,
predicate: Option<&str>,
value: serde_json::Value,
) -> serde_json::Value {
use serde_json::{json, Map, Value};
let mut meta = Map::new();
meta.insert("stage".into(), json!("summary"));
meta.insert("exact".into(), json!(true));
meta.insert("readsIndex".into(), json!(false));
meta.insert("queryShape".into(), json!(query_shape));
meta.insert("value".into(), value);
meta.insert("bytes".into(), json!(reader.bytes_read()));
meta.insert("requests".into(), json!(reader.requests()));
meta.insert("fileBytes".into(), json!(file_bytes));
if let Some(predicate) = predicate {
meta.insert("predicate".into(), json!(predicate));
}
Value::Object(meta)
}
fn integer_literal(value: u64) -> String {
format!("\"{}\"^^<{}>", value, XSD_INTEGER_IRI)
}
fn provenance_json(m: &TripleProvenance) -> serde_json::Value {
use serde_json::json;
let tile = match (&m.tile, m.tile_range) {
(Some(id), Some(range)) => json!({
"available": true,
"id": id,
"range": range_json(range),
}),
(Some(id), None) => json!({
"available": true,
"id": id,
}),
_ => json!({
"available": false,
"reason": "not_materialized",
}),
};
json!({
"terms": {
"subject": m.terms.0,
"predicate": m.terms.1,
"object": m.terms.2,
},
"ids": {
"subject": m.ids.0,
"predicate": m.ids.1,
"object": m.ids.2,
},
"provenance": {
"graph": m.graph.as_deref().unwrap_or("default"),
"matchedPattern": {
"subject": m.matched_pattern.0,
"predicate": m.matched_pattern.1,
"object": m.matched_pattern.2,
},
"indexPermutation": m.index_permutation.name(),
"indexSection": m.index_permutation.section_index(),
"dictionaryRange": range_json(m.dictionary_range),
"indexRange": range_json(m.index_range),
"indexSectionRange": range_json(m.index_section_range),
"pyramidRange": m.pyramid_range.map(range_json),
"tile": tile,
},
})
}
fn range_json(range: ByteRange) -> serde_json::Value {
serde_json::json!({
"offset": range.offset,
"len": range.len,
"end": range.end(),
})
}
fn to_turtle(triples: &[(String, String, String)]) -> String {
use std::collections::BTreeMap;
let mut by_subject: BTreeMap<&str, BTreeMap<&str, Vec<&str>>> = BTreeMap::new();
for (s, p, o) in triples {
by_subject
.entry(s)
.or_default()
.entry(p)
.or_default()
.push(o);
}
let mut out = String::new();
for (s, preds) in &by_subject {
out.push_str(s);
out.push('\n');
let pred_count = preds.len();
for (i, (p, objs)) in preds.iter().enumerate() {
let pred = if *p == RDF_TYPE_IRI { "a" } else { p };
let objects = objs.join(" , ");
let terminator = if i + 1 == pred_count { " ." } else { " ;" };
out.push_str(&format!(" {pred} {objects}{terminator}\n"));
}
out.push('\n');
}
out
}
fn to_jsonld(triples: &[(String, String, String)]) -> String {
use serde_json::{json, Map, Value};
use std::collections::BTreeMap;
let mut nodes: BTreeMap<String, BTreeMap<String, Vec<Value>>> = BTreeMap::new();
for (s, p, o) in triples {
let id = node_id(s);
let pred = p
.strip_prefix('<')
.and_then(|x| x.strip_suffix('>'))
.unwrap_or(p)
.to_string();
nodes
.entry(id)
.or_default()
.entry(pred)
.or_default()
.push(object_to_jsonld(o));
}
let arr: Vec<Value> = nodes
.into_iter()
.map(|(id, preds)| {
let mut obj = Map::new();
obj.insert("@id".into(), json!(id));
for (pred, vals) in preds {
obj.insert(pred, Value::Array(vals));
}
Value::Object(obj)
})
.collect();
serde_json::to_string_pretty(&Value::Array(arr)).unwrap_or_default()
}
fn node_id(token: &str) -> String {
token
.strip_prefix('<')
.and_then(|s| s.strip_suffix('>'))
.map(str::to_string)
.unwrap_or_else(|| token.to_string())
}
fn object_to_jsonld(token: &str) -> serde_json::Value {
use serde_json::{json, Map, Value};
if let Some(iri) = token.strip_prefix('<').and_then(|s| s.strip_suffix('>')) {
return json!({ "@id": iri });
}
if let Some(b) = token.strip_prefix("_:") {
return json!({ "@id": format!("_:{b}") });
}
if token.starts_with('"') {
let bytes = token.as_bytes();
let mut i = 1;
while i < bytes.len() {
match bytes[i] {
b'\\' => i += 2,
b'"' => break,
_ => i += 1,
}
}
let value = unescape_nt(&token[1..i.min(token.len())]);
let rest = token.get(i + 1..).unwrap_or("");
let mut obj = Map::new();
obj.insert("@value".into(), Value::String(value));
if let Some(dt) = rest.strip_prefix("^^<").and_then(|s| s.strip_suffix('>')) {
obj.insert("@type".into(), json!(dt));
} else if let Some(lang) = rest.strip_prefix('@') {
obj.insert("@language".into(), json!(lang));
}
return Value::Object(obj);
}
json!({ "@value": token })
}
fn unescape_nt(s: &str) -> String {
rete_core::terms::unescape_literal(s)
}
fn open(bytes: &[u8]) -> Result<Rete, JsValue> {
let mut rete = Rete::open(bytes).map_err(err)?;
rete.set_service_client(Box::new(XhrServiceClient));
Ok(rete)
}
fn err<E: std::fmt::Display>(e: E) -> JsValue {
js_error(e.to_string())
}
fn js_error(message: impl AsRef<str>) -> JsValue {
js_sys::Error::new(message.as_ref()).into()
}