Merge pull request #19 from tantaraio/GH-18/core-engine-api

feat: core engine api

Author: DawChihLiou

Cargo.toml

@@ -11,7 +11,8 @@ crate-type = ["cdylib", "rlib"]
 default = ["console_error_panic_hook"]
 
 [dependencies]
-wasm-bindgen = "0.2.63"
+wasm-bindgen = "0.2.83"
+getrandom = { version = "0.2", features = ["js"] }
 
 # The `console_error_panic_hook` crate provides better debugging of panics by
 # logging them with `console.error`. This is great for development, but requires
@@ -27,6 +28,7 @@ wee_alloc = { version = "0.4.5", optional = true }
 tantivy = "0.19.0"
 serde = { version = "1.0.150", features = ["derive"] }
 serde_json = "1.0.89"
+serde-wasm-bindgen = "0.4"
 
 [dev-dependencies]
 wasm-bindgen-test = "0.3.13"

src/engine/mod.rs

@@ -0,0 +1,84 @@
+use schema::{create_schema, SchemaConfig};
+use tantivy::collector::TopDocs;
+use tantivy::query::QueryParser;
+use tantivy::schema::*;
+use tantivy::DocAddress;
+use tantivy::IndexReader;
+use tantivy::IndexWriter;
+use tantivy::ReloadPolicy;
+use tantivy::Result;
+
+mod schema;
+
+pub struct Registry {
+    index: tantivy::Index,
+    schema: Schema,
+    fields: Vec<Field>,
+    writer: IndexWriter,
+    reader: IndexReader,
+}
+
+pub struct Input {
+    schema: SchemaConfig,
+}
+
+pub fn create(input: Input) -> Result<Registry> {
+    let mut schema_builder = Schema::builder();
+
+    create_schema(&input.schema, &mut schema_builder);
+
+    let fields = vec![];
+    let schema = schema_builder.build();
+    let index = tantivy::Index::create_in_ram(schema.clone());
+    let writer = index.writer(50_000_000)?;
+    let reader = index
+        .reader_builder()
+        .reload_policy(ReloadPolicy::OnCommit)
+        .try_into()?;
+
+    Ok(Registry {
+        index,
+        schema,
+        fields,
+        writer,
+        reader,
+    })
+}
+
+pub fn add(index: Registry, docs: Vec<Document>) -> Result<Registry> {
+    docs.iter().try_for_each(|doc| -> Result<()> {
+        index.writer.add_document(doc.clone())?;
+        Ok(())
+    })?;
+
+    Ok(index)
+}
+
+pub fn commit(mut index: Registry) -> Result<Registry> {
+    index.writer.commit()?;
+    index.reader.reload()?;
+
+    Ok(index)
+}
+
+pub fn remove(index: Registry, field: Field, text: &str) -> Result<Registry> {
+    let term = Term::from_field_text(field, text);
+
+    index.writer.delete_term(term);
+
+    Ok(index)
+}
+
+pub fn search(
+    index: Registry,
+    query: &str,
+    limit: Option<usize>,
+) -> tantivy::Result<Vec<(f32, DocAddress)>> {
+    let limit = limit.unwrap_or(10);
+    let parser = QueryParser::for_index(&index.index, index.fields);
+    let query = parser.parse_query(query)?;
+    let searcher = index.reader.searcher();
+    let result = searcher.search(&query, &TopDocs::with_limit(limit))?;
+
+    Ok(result)
+}

src/engine/schema.rs

@@ -0,0 +1,57 @@
+use tantivy::schema::{NumericOptions, SchemaBuilder, TextOptions};
+
+struct FieldOptions {
+    stored: bool,
+    indexed: bool,
+}
+
+enum FieldType {
+    Text,
+    U64,
+}
+
+pub struct Field {
+    name: String,
+    field_type: FieldType,
+    options: FieldOptions,
+}
+
+pub type SchemaConfig = Vec<Field>;
+
+pub fn create_schema(config: &SchemaConfig, schema_builder: &mut SchemaBuilder) {
+    config.iter().for_each(|field| {
+        match field.field_type {
+            FieldType::Text => {
+                let options = get_text_options(&field.options);
+                schema_builder.add_text_field(&field.name, options);
+            }
+            FieldType::U64 => {
+                let options = get_u64_options(&field.options);
+                schema_builder.add_u64_field(&field.name, options);
+            }
+        };
+    })
+}
+
+fn get_text_options(config: &FieldOptions) -> TextOptions {
+    let mut options = TextOptions::default();
+
+    if config.stored {
+        options = options.set_stored();
+    }
+
+    options
+}
+
+fn get_u64_options(config: &FieldOptions) -> NumericOptions {
+    let mut options = NumericOptions::default();
+
+    if config.stored {
+        options = options.set_stored();
+    }
+    if config.indexed {
+        options = options.set_indexed();
+    }
+
+    options
+}

src/lib.rs

@@ -1,44 +1,9 @@
+mod engine;
+mod log;
 mod utils;
 
-use wasm_bindgen::prelude::*;
-
 // When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
 // allocator.
 #[cfg(feature = "wee_alloc")]
 #[global_allocator]
 static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
-
-#[wasm_bindgen]
-extern "C" {
-    fn alert(s: &str);
-
-    // Use `js_namespace` here to bind `console.log(..)` instead of just
-    // `log(..)`
-    #[wasm_bindgen(js_namespace = console)]
-    fn log(s: &str);
-
-    // The `console.log` is quite polymorphic, so we can bind it with multiple
-    // signatures. Note that we need to use `js_name` to ensure we always call
-    // `log` in JS.
-    #[wasm_bindgen(js_namespace = console, js_name = log)]
-    fn log_u32(a: u32);
-
-    // Multiple arguments too!
-    #[wasm_bindgen(js_namespace = console, js_name = log)]
-    fn log_many(a: &str, b: &str);
-}
-
-// Next let's define a macro that's like `println!`, only it works for
-// `console.log`. Note that `println!` doesn't actually work on the wasm target
-// because the standard library currently just eats all output. To get
-// `println!`-like behavior in your app you'll likely want a macro like this.
-macro_rules! console_log {
-    // Note that this is using the `log` function imported above during
-    // `bare_bones`
-    ($($t:tt)*) => (log(&format_args!($($t)*).to_string()))
-}
-
-#[wasm_bindgen]
-pub fn greet() {
-    console_log!("Hello from WASM🦀🕸!")
-}

src/log.rs

@@ -0,0 +1,31 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+extern "C" {
+    fn alert(s: &str);
+
+    // Use `js_namespace` here to bind `console.log(..)` instead of just
+    // `log(..)`
+    #[wasm_bindgen(js_namespace = console)]
+    fn log(s: &str);
+
+    // The `console.log` is quite polymorphic, so we can bind it with multiple
+    // signatures. Note that we need to use `js_name` to ensure we always call
+    // `log` in JS.
+    #[wasm_bindgen(js_namespace = console, js_name = log)]
+    fn log_u32(a: u32);
+
+    // Multiple arguments too!
+    #[wasm_bindgen(js_namespace = console, js_name = log)]
+    fn log_many(a: &str, b: &str);
+}
+
+// Next let's define a macro that's like `println!`, only it works for
+// `console.log`. Note that `println!` doesn't actually work on the wasm target
+// because the standard library currently just eats all output. To get
+// `println!`-like behavior in your app you'll likely want a macro like this.
+macro_rules! console_log {
+    // Note that this is using the `log` function imported above during
+    // `bare_bones`
+    ($($t:tt)*) => (log(&format_args!($($t)*).to_string()))
+}