Remove reader and writer and hide opfs API.

Author: Eason0729

core/src/services/opfs/backend.rs

@@ -18,11 +18,7 @@
 use serde::Deserialize;
 use std::sync::Arc;
 
-use super::{lister::OpfsLister, reader::OpfsReader, writer::OpfsWriter};
-use crate::{
-    raw::{Access, AccessorInfo, OpRead, OpWrite, RpRead, RpWrite},
-    Builder, Capability, Error, Result, Scheme,
-};
+use crate::raw::{Access, AccessorInfo};
 use std::fmt::Debug;
 
 /// Origin private file system (OPFS) configuration
@@ -52,101 +48,38 @@ impl Debug for OpfsBuilder {
     }
 }
 
-impl Builder for OpfsBuilder {
-    const SCHEME: Scheme = Scheme::Opfs;
-
-    type Config = ();
-
-    fn build(self) -> Result<impl Access> {
-        Ok(OpfsBackend {})
-    }
-}
+// impl Builder for OpfsBuilder {
+//     const SCHEME: Scheme = Scheme::Opfs;
+//
+//     type Config = ();
+//
+//     fn build(self) -> Result<impl Access> {
+//         Ok(OpfsBackend {})
+//     }
+// }
 
 /// OPFS Service backend
 #[derive(Debug, Clone)]
 pub struct OpfsBackend {}
 
 impl Access for OpfsBackend {
-    type Reader = OpfsReader;
+    type Reader = ();
 
-    type Writer = OpfsWriter;
+    type Writer = ();
 
-    type Lister = OpfsLister;
+    type Lister = ();
 
     type Deleter = ();
 
     type BlockingReader = ();
 
     type BlockingWriter = ();
 
-    type BlockingLister = OpfsLister;
+    type BlockingLister = ();
 
     type BlockingDeleter = ();
 
     fn info(&self) -> Arc<AccessorInfo> {
-        let access_info = AccessorInfo::default();
-        access_info
-            .set_scheme(Scheme::Opfs)
-            .set_native_capability(Capability {
-                stat: false,
-                read: true,
-                write: true,
-                write_can_empty: true,
-                write_can_append: true,
-                write_can_multi: true,
-                create_dir: false,
-                delete: false,
-                list: false,
-                copy: false,
-                rename: false,
-                blocking: true,
-                ..Default::default()
-            });
-        Arc::new(access_info)
-    }
-
-    async fn read(&self, path: &str, args: OpRead) -> Result<(RpRead, Self::Reader)> {
-        let path = path.to_owned();
-
-        Ok::<(RpRead, Self::Reader), Error>((
-            RpRead::default(),
-            OpfsReader::new(args.range(), path),
-        ))
-    }
-    async fn write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::Writer)> {
-        // Access the OPFS
-        let path = path.to_owned();
-
-        Ok((RpWrite::default(), OpfsWriter::new(path, args.append())))
-    }
-}
-
-#[cfg(test)]
-#[cfg(target_arch = "wasm32")]
-mod opfs_tests {
-    use wasm_bindgen::prelude::*;
-    use wasm_bindgen_test::*;
-
-    use std::collections::HashMap;
-
-    use crate::Operator;
-
-    use super::*;
-
-    wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
-
-    #[wasm_bindgen]
-    pub async fn test_opfs() -> String {
-        let map = HashMap::new();
-        let op = Operator::via_map(Scheme::Opfs, map).unwrap();
-        let bs = op.read("path/to/file").await.unwrap();
-        "ok".to_string()
-    }
-
-    #[wasm_bindgen_test]
-    async fn basic_test() -> Result<()> {
-        let s = test_opfs().await;
-        assert_eq!(s, "ok".to_string());
-        Ok(())
+        todo!()
     }
 }

core/src/services/opfs/core.rs

@@ -15,46 +15,25 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::Error;
 use crate::Result;
 use std::fmt::Debug;
-use std::future::Future;
-use tokio::sync::oneshot;
 
 use web_sys::{
     window, File, FileSystemDirectoryHandle, FileSystemFileHandle, FileSystemGetFileOptions,
     FileSystemWritableFileStream,
 };
 
 use wasm_bindgen::{JsCast, JsValue};
-use wasm_bindgen_futures::JsFuture;
-
-fn spawn_local<F, T>(fut: F) -> impl Future<Output = T> + Send
-where
-    F: Future<Output = T> + 'static,
-    T: 'static + Send + Sync,
-{
-    let (tx, rx) = oneshot::channel();
-    wasm_bindgen_futures::spawn_local(async move {
-        let item = fut.await;
-        tx.send(item).expect_err("Failed to send completion signal");
-    });
-    async move { rx.await.unwrap() }
-}
 
-#[derive(Default, Clone)]
+use wasm_bindgen_futures::JsFuture;
+#[derive(Default, Clone, Debug)]
 pub struct OpfsCore {}
 
-impl Debug for OpfsCore {
-    fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        panic!()
-    }
-}
-
 impl OpfsCore {
     /// Write whole file
-    ///
-    /// Return future is not send, because JsValue rely on slab(table to map JsValue(rust) to js variable).
+    // Return future is not send, because JsValue rely on slab(table to map JsValue(rust) to js variable).
+    //
+    // consider using wasm_bindgen_futures::spawn_local
     async fn store_file(&self, file_name: &str, content: &[u8]) -> Result<(), JsValue> {
         // Access the OPFS
         let navigator = window().unwrap().navigator();
@@ -90,18 +69,11 @@ impl OpfsCore {
 
         Ok(())
     }
-    pub async fn store_file_send(self, filename: String, content: Vec<u8>) -> Result<(), Error> {
-        spawn_local(async move {
-            self.store_file(&filename, &content)
-                .await
-                .map_err(Error::from)
-        })
-        .await
-    }
 
     /// Read whole file
-    ///
-    /// Return future is not send, because JsValue rely on slab(table to map JsValue(rust) to js variable).
+    // Return future is not send, because JsValue rely on slab(table to map JsValue(rust) to js variable).
+    //
+    // consider using wasm_bindgen_futures::spawn_local
     async fn read_file(&self, file_name: &str) -> Result<Vec<u8>, JsValue> {
         // Access the OPFS
         let navigator = window()
@@ -128,7 +100,4 @@ impl OpfsCore {
 
         Ok(vec)
     }
-    pub async fn read_file_send(self, file_name: String) -> Result<Vec<u8>, Error> {
-        spawn_local(async move { self.read_file(&file_name).await.map_err(Error::from) }).await
-    }
 }

core/src/services/opfs/helper.rs

@@ -21,14 +21,5 @@ mod backend;
 mod core;
 #[cfg(feature = "services-opfs")]
 mod error;
-#[cfg(feature = "services-opfs")]
-mod helper;
-#[cfg(feature = "services-opfs")]
-mod lister;
-#[cfg(feature = "services-opfs")]
-mod reader;
-#[cfg(feature = "services-opfs")]
-mod writer;
-
 #[cfg(feature = "services-opfs")]
 pub use backend::OpfsBuilder as Opfs;