filters are now entities and auto-generated for all table backed types

src/database/compile/filters.rs

@@ -0,0 +1,78 @@
+use crate::database::object::{SchemaObject, SchemaTypeOrArray};
+use crate::database::schema::Schema;
+use crate::database::Database;
+use std::collections::BTreeMap;
+use std::sync::Arc;
+
+impl Schema {
+  pub fn compile_filter(
+    &self,
+    _db: &Database,
+    _root_id: &str,
+    _errors: &mut Vec<crate::drop::Error>,
+  ) -> Option<Schema> {
+    if let Some(props) = self.obj.compiled_properties.get() {
+      let mut filter_props = BTreeMap::new();
+      for (key, child) in props {
+        if let Some(mut filter_type) = Self::resolve_filter_type(child) {
+          filter_type.push("null".to_string());
+
+          let mut child_obj = SchemaObject::default();
+          child_obj.type_ = Some(SchemaTypeOrArray::Multiple(filter_type));
+
+          filter_props.insert(key.clone(), Arc::new(Schema { obj: child_obj, always_fail: false }));
+        }
+      }
+
+      if !filter_props.is_empty() {
+        let mut wrapper_obj = SchemaObject::default();
+        wrapper_obj.type_ = Some(SchemaTypeOrArray::Single("object".to_string()));
+        wrapper_obj.properties = Some(filter_props);
+
+        return Some(Schema { obj: wrapper_obj, always_fail: false });
+      }
+    }
+    None
+  }
+
+  fn resolve_filter_type(schema: &Arc<Schema>) -> Option<Vec<String>> {
+    if let Some(type_) = &schema.obj.type_ {
+      match type_ {
+        SchemaTypeOrArray::Single(t) => {
+          return Self::map_filter_string(t, schema);
+        }
+        SchemaTypeOrArray::Multiple(types) => {
+          for t in types {
+            if t != "null" {
+              return Self::map_filter_string(t, schema);
+            }
+          }
+        }
+      }
+    }
+    None
+  }
+
+  fn map_filter_string(t: &str, schema: &Arc<Schema>) -> Option<Vec<String>> {
+    match t {
+      "string" => {
+        if let Some(fmt) = &schema.obj.format {
+          if fmt == "date-time" {
+            return Some(vec!["date.condition".to_string()]);
+          }
+        }
+        Some(vec!["string.condition".to_string()])
+      }
+      "integer" => Some(vec!["integer.condition".to_string()]),
+      "number" => Some(vec!["number.condition".to_string()]),
+      "boolean" => Some(vec!["boolean.condition".to_string()]),
+      "object" => None, // Inline structures are ignored in Composed References
+      "array" => None,  // We don't filter primitive arrays or map complex arrays yet
+      "null" => None,
+      custom => {
+        // Assume anything else is a Relational cross-boundary that already has its own .filter dynamically built
+        Some(vec![format!("{}.filter", custom)])
+      }
+    }
+  }
+}

src/database/compile/mod.rs

@@ -1,5 +1,6 @@
 pub mod collection;
 pub mod edges;
+pub mod filters;
 pub mod polymorphism;
 
 use crate::database::schema::Schema;