use std::collections::HashMap;
use wasm_bindgen::prelude::*;
use crate::compiler::dialects;
use crate::compiler::universe::{LogicaProgram, Pagination};
use crate::parser::{parse_file, Json};
use crate::verifier::validate;
fn err(e: impl std::fmt::Display) -> JsValue {
JsValue::from_str(&e.to_string())
}
fn engine_arg(engine: &str) -> Result<Option<&str>, JsValue> {
match engine {
"" => Ok(None),
e if dialects::SUPPORTED_ENGINES.contains(&e) => Ok(Some(e)),
e => Err(err(format!(
"Unsupported engine '{}'. Supported engines: {}.",
e,
dialects::SUPPORTED_ENGINES.join(", ")
))),
}
}
fn parse(source: &str) -> Result<Json, JsValue> {
parse_file(source, None, &[]).map_err(err)
}
fn build(parsed: &Json, engine: Option<&str>) -> Result<LogicaProgram, JsValue> {
LogicaProgram::new_with_engine(
parsed,
HashMap::new(),
HashMap::new(),
engine,
)
.map_err(err)
}
#[wasm_bindgen]
pub fn supported_engines() -> Vec<String> {
dialects::SUPPORTED_ENGINES
.iter()
.map(|s| s.to_string())
.collect()
}
#[wasm_bindgen]
pub fn predicates(source: &str, engine: &str) -> Result<Vec<String>, JsValue> {
let engine = engine_arg(engine)?;
let parsed = parse(source)?;
let program = build(&parsed, engine)?;
Ok(program.user_defined_predicates())
}
#[wasm_bindgen]
pub fn compile(source: &str, predicate: &str, engine: &str) -> Result<String, JsValue> {
let engine = engine_arg(engine)?;
let parsed = parse(source)?;
let program = build(&parsed, engine)?;
let pagination = Pagination { limit: None, offset: None };
program
.formatted_predicate_sql_with_pagination(predicate, &pagination)
.map_err(err)
}
#[wasm_bindgen]
pub fn check(source: &str, engine: &str) -> Result<Vec<String>, JsValue> {
engine_arg(engine)?;
let parsed = parse(source)?;
let result = validate(&parsed);
Ok(result.errors.iter().map(|e| e.to_string()).collect())
}