Fix issues rebase

atomicdata-dev · Feb 3, 2025 · 02d76d3 · 02d76d3
1 parent c69e268
commit 02d76d3
Show file tree

Hide file tree

Showing 12 changed files with 8,476 additions and 74 deletions.
diff --git a/browser/data-browser/src/views/TablePage/TableExportDialog.tsx b/browser/data-browser/src/views/TablePage/TableExportDialog.tsx
@@ -33,7 +33,7 @@ export function TableExportDialog({
   bindShow,
 }: TableExportDialogProps): React.JSX.Element {
   const store = useStore();
-  const [dialogProps, showDialog] = useDialog({ bindShow });
+  const { dialogProps, show: showDialog } = useDialog({ bindShow });
   const [refAsSubject, setRefAsSubject] = useState(false);
 
   const url = buildLink(subject, refAsSubject, store);

diff --git a/browser/deno.lock b/browser/deno.lock
diff --git a/lib/src/db.rs b/lib/src/db.rs
@@ -213,6 +213,12 @@ impl Db {
         Ok(())
     }
 
+    /// Closes the database.
+    pub fn flush(&self) -> AtomicResult<()> {
+        self.db.flush()?;
+        Ok(())
+    }
+
     /// Internal method for fetching Resource data.
     #[instrument(skip(self))]
     fn set_propvals(&self, subject: &str, propvals: &PropVals) -> AtomicResult<()> {

diff --git a/lib/src/db/migrations.rs b/lib/src/db/migrations.rs
@@ -97,7 +97,7 @@ fn res_v1_to_v2(store: &Db) -> AtomicResult<()> {
                 Ok(url) => url,
                 Err(e) => {
                     tracing::error!(
-                        "Unable to parse subject URL of '{}', skipping: {}",
+                        "Unable to parse subject URL of '{}', keeping original: {}",
                         subject,
                         e
                     );

diff --git a/lib/src/db/query_index.rs b/lib/src/db/query_index.rs
@@ -491,79 +491,95 @@ pub mod test {
 
     #[test]
     fn should_update_or_not() {
-        let store = &Db::init_temp("should_update_or_not").unwrap();
+        let instant = std::time::Instant::now();
 
-        let prop = urls::IS_A.to_string();
-        let class = urls::AGENT;
+        {
+            let store = &Db::init_temp("should_update_or_not").unwrap();
 
-        let qf_prop_val = QueryFilter {
-            property: Some(prop.clone()),
-            value: Some(Value::AtomicUrl(class.to_string())),
-            sort_by: None,
-        };
+            let prop = urls::IS_A.to_string();
+            let class = urls::AGENT;
 
-        let qf_prop = QueryFilter {
-            property: Some(prop.clone()),
-            value: None,
-            sort_by: None,
-        };
+            let qf_prop_val = QueryFilter {
+                property: Some(prop.clone()),
+                value: Some(Value::AtomicUrl(class.to_string())),
+                sort_by: None,
+            };
 
-        let qf_val = QueryFilter {
-            property: None,
-            value: Some(Value::AtomicUrl(class.to_string())),
-            sort_by: None,
-        };
+            let qf_prop = QueryFilter {
+                property: Some(prop.clone()),
+                value: None,
+                sort_by: None,
+            };
 
-        let resource_correct_class = Resource::new_instance(class, store).unwrap();
+            let qf_val = QueryFilter {
+                property: None,
+                value: Some(Value::AtomicUrl(class.to_string())),
+                sort_by: None,
+            };
 
-        let subject: String = "https://example.com/someAgent".into();
+            let resource_correct_class = Resource::new_instance(class, store).unwrap();
 
-        let index_atom = IndexAtom {
-            subject,
-            property: prop.clone(),
-            ref_value: class.to_string(),
-            sort_value: class.to_string(),
-        };
+            let subject: String = "https://example.com/someAgent".into();
 
-        // We should be able to find the resource by propval, val, and / or prop.
-        assert!(should_update_property(&qf_val, &index_atom, &resource_correct_class).is_some());
-        assert!(
-            should_update_property(&qf_prop_val, &index_atom, &resource_correct_class,).is_some()
-        );
-        assert!(should_update_property(&qf_prop, &index_atom, &resource_correct_class).is_some());
-
-        // Test when a different value is passed
-        let resource_wrong_class = Resource::new_instance(urls::PARAGRAPH, store).unwrap();
-        assert!(should_update_property(&qf_prop, &index_atom, &resource_wrong_class).is_some());
-        assert!(should_update_property(&qf_val, &index_atom, &resource_wrong_class).is_none());
-        assert!(should_update_property(&qf_prop_val, &index_atom, &resource_wrong_class).is_none());
-
-        let qf_prop_val_sort = QueryFilter {
-            property: Some(prop.clone()),
-            value: Some(Value::AtomicUrl(class.to_string())),
-            sort_by: Some(urls::DESCRIPTION.to_string()),
-        };
-        let qf_prop_sort = QueryFilter {
-            property: Some(prop.clone()),
-            value: None,
-            sort_by: Some(urls::DESCRIPTION.to_string()),
-        };
-        let qf_val_sort = QueryFilter {
-            property: Some(prop),
-            value: Some(Value::AtomicUrl(class.to_string())),
-            sort_by: Some(urls::DESCRIPTION.to_string()),
-        };
+            let index_atom = IndexAtom {
+                subject,
+                property: prop.clone(),
+                ref_value: class.to_string(),
+                sort_value: class.to_string(),
+            };
 
-        // We should update with a sort_by attribute
-        assert!(
-            should_update_property(&qf_prop_val_sort, &index_atom, &resource_correct_class,)
-                .is_some()
-        );
-        assert!(
-            should_update_property(&qf_prop_sort, &index_atom, &resource_correct_class,).is_some()
-        );
-        assert!(
-            should_update_property(&qf_val_sort, &index_atom, &resource_correct_class,).is_some()
-        );
+            // We should be able to find the resource by propval, val, and / or prop.
+            assert!(
+                should_update_property(&qf_val, &index_atom, &resource_correct_class).is_some()
+            );
+            assert!(
+                should_update_property(&qf_prop_val, &index_atom, &resource_correct_class,)
+                    .is_some()
+            );
+            assert!(
+                should_update_property(&qf_prop, &index_atom, &resource_correct_class).is_some()
+            );
+
+            // Test when a different value is passed
+            let resource_wrong_class = Resource::new_instance(urls::PARAGRAPH, store).unwrap();
+            assert!(should_update_property(&qf_prop, &index_atom, &resource_wrong_class).is_some());
+            assert!(should_update_property(&qf_val, &index_atom, &resource_wrong_class).is_none());
+            assert!(
+                should_update_property(&qf_prop_val, &index_atom, &resource_wrong_class).is_none()
+            );
+
+            let qf_prop_val_sort = QueryFilter {
+                property: Some(prop.clone()),
+                value: Some(Value::AtomicUrl(class.to_string())),
+                sort_by: Some(urls::DESCRIPTION.to_string()),
+            };
+            let qf_prop_sort = QueryFilter {
+                property: Some(prop.clone()),
+                value: None,
+                sort_by: Some(urls::DESCRIPTION.to_string()),
+            };
+            let qf_val_sort = QueryFilter {
+                property: Some(prop),
+                value: Some(Value::AtomicUrl(class.to_string())),
+                sort_by: Some(urls::DESCRIPTION.to_string()),
+            };
+
+            // We should update with a sort_by attribute
+            assert!(should_update_property(
+                &qf_prop_val_sort,
+                &index_atom,
+                &resource_correct_class,
+            )
+            .is_some());
+            assert!(
+                should_update_property(&qf_prop_sort, &index_atom, &resource_correct_class,)
+                    .is_some()
+            );
+            assert!(
+                should_update_property(&qf_val_sort, &index_atom, &resource_correct_class,)
+                    .is_some()
+            );
+        }
+        println!("Took {:?}", instant.elapsed())
     }
 }
diff --git a/lib/src/resources.rs b/lib/src/resources.rs
@@ -697,7 +697,6 @@ mod test {
                     validate_signature: true,
                     validate_timestamp: true,
                     validate_rights: false,
-                    validate_subject_url_parent: true,
                     validate_previous_commit: true,
                     validate_for_agent: None,
                     update_index: true,

diff --git a/lib/src/serialize.rs b/lib/src/serialize.rs
@@ -265,7 +265,7 @@ mod test {
 
     #[test]
     fn serialize_json_ad() {
-        let mut store = crate::Store::init().unwrap();
+        let store = crate::Store::init().unwrap();
         store.populate().unwrap();
         let json = store
             .get_resource(crate::urls::AGENT)

diff --git a/lib/src/store.rs b/lib/src/store.rs
@@ -265,7 +265,7 @@ mod test {
     use crate::{agents::ForAgent, urls, Value};
 
     fn init_store() -> Store {
-        let mut store = Store::init().unwrap();
+        let store = Store::init().unwrap();
         store.populate().unwrap();
         store
     }

diff --git a/server/build.rs b/server/build.rs
@@ -22,9 +22,6 @@ fn main() -> std::io::Result<()> {
     // return Ok(());
     const BROWSER_ROOT: &str = "../browser/";
     println!("cargo:rerun-if-changed={}", BROWSER_ROOT);
-    // Check if we're likely running in a check-like context
-    let opt_level = std::env::var("OPT_LEVEL").unwrap_or_else(|_| "0".to_string());
-    let profile = std::env::var("PROFILE").unwrap_or_else(|_| "release".to_string());
 
     let is_check_like = false; // profile == "debug" && opt_level == "0";
 

diff --git a/server/src/appstate.rs b/server/src/appstate.rs
@@ -136,6 +136,7 @@ impl AppState {
     /// Cleanup code, writing buffers, committing changes, etc.
     fn exit(&self) -> AtomicServerResult<()> {
         self.search_state.writer.write()?.commit()?;
+        self.store.flush()?;
         Ok(())
     }
 }

diff --git a/server/src/commit_monitor.rs b/server/src/commit_monitor.rs
@@ -160,7 +160,7 @@ impl CommitMonitor {
 impl Handler<CommitMessage> for CommitMonitor {
     type Result = ();
 
-    #[tracing::instrument(name = "handle_commit_message", skip_all, fields(subscriptions = &self.subscriptions.len(), s = %msg.commit_response.commit_resource.get_subject()))]
+    #[tracing::instrument(name = "handle_commit_message", level="debug", skip_all, fields(subscriptions = &self.subscriptions.len(), s = %msg.commit_response.commit_resource.get_subject()))]
     fn handle(&mut self, msg: CommitMessage, _: &mut Context<Self>) {
         // We have moved the logic to the `handle_internal` function for decent error handling
         match self.handle_internal(msg) {

diff --git a/server/src/serve.rs b/server/src/serve.rs
@@ -112,6 +112,7 @@ pub async fn serve(config: crate::config::Config) -> AtomicServerResult<()> {
     if let Some(guard) = tracing_chrome_flush_guard {
         guard.flush()
     }
+    drop(config);
 
     tracing::info!("Server stopped");
     Ok(())