diff --git a/interfaces/kits/js/src/mod_fileio/class_file/file_entity.h b/interfaces/kits/js/src/mod_fileio/class_file/file_entity.h
new file mode 100644
index 0000000000000000000000000000000000000000..9a82a6f7900f8364a6a5cedc98794a94ac5a0516
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/class_file/file_entity.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INTERFACES_KITS_JS_SRC_MOD_FILEIO_CLASS_FILE_FILE_ENTITY_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_CLASS_FILE_FILE_ENTITY_H
+
+#include <unistd.h>
+
+#include "../../common/file_helper/fd_guard.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+struct FileEntity {
+    std::unique_ptr<FDGuard> fd_ = { nullptr };
+    std::string path_;
+    std::string uri_;
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/class_file/file_n_exporter.cpp b/interfaces/kits/js/src/mod_fileio/class_file/file_n_exporter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..cc805b835c182d80de4c27ac7f28f2681535298b
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/class_file/file_n_exporter.cpp
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "file_n_exporter.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+
+#include "../../common/log.h"
+#include "../../common/napi/n_async/n_async_work_callback.h"
+#include "../../common/napi/n_async/n_async_work_promise.h"
+#include "../../common/napi/n_class.h"
+#include "../../common/napi/n_func_arg.h"
+#include "../../common/uni_error.h"
+#include "../common_func.h"
+#include "file_entity.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+static FileEntity *GetFileEntity(napi_env env, napi_value raf_entity)
+{
+    auto rafEntity = NClass::GetEntityOf<FileEntity>(env, raf_entity);
+    if (!rafEntity) {
+        UniError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+    if (!rafEntity->fd_) {
+        UniError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+    return rafEntity;
+}
+
+napi_value FileNExporter::GetFD(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ZERO)) {
+        UniError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+    auto rafEntity = GetFileEntity(env, funcArg.GetThisVar());
+    if (!rafEntity) {
+        return nullptr;
+    }
+    return NVal::CreateInt32(env, rafEntity->fd_.get()->GetFD()).val_;
+}
+
+napi_value FileNExporter::GetPath(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ZERO)) {
+        UniError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+    auto rafEntity = GetFileEntity(env, funcArg.GetThisVar());
+    if (!rafEntity) {
+        return nullptr;
+    }
+    return NVal::CreateUTF8String(env, rafEntity->path_).val_;
+}
+
+napi_value FileNExporter::GetUri(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ZERO)) {
+        UniError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+    auto rafEntity = GetFileEntity(env, funcArg.GetThisVar());
+    if (!rafEntity) {
+        return nullptr;
+    }
+    return NVal::CreateUTF8String(env, rafEntity->uri_).val_;
+}
+
+napi_value FileNExporter::Constructor(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ZERO)) {
+        UniError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+
+    auto rafEntity = make_unique<FileEntity>();
+    if (!NClass::SetEntityFor<FileEntity>(env, funcArg.GetThisVar(), move(rafEntity))) {
+        UniError(EIO).ThrowErr(env);
+        return nullptr;
+    }
+    return funcArg.GetThisVar();
+}
+
+bool FileNExporter::Export()
+{
+    vector<napi_property_descriptor> props = {
+        NVal::DeclareNapiGetter("fd", GetFD),
+        NVal::DeclareNapiGetter("path", GetPath),
+    };
+
+    string className = GetClassName();
+    bool succ = false;
+    napi_value classValue = nullptr;
+    tie(succ, classValue) = NClass::DefineClass(exports_.env_, className,
+        FileNExporter::Constructor, move(props));
+    if (!succ) {
+        UniError(EIO).ThrowErr(exports_.env_);
+        return false;
+    }
+    succ = NClass::SaveClass(exports_.env_, className, classValue);
+    if (!succ) {
+        UniError(EIO).ThrowErr(exports_.env_);
+        return false;
+    }
+
+    return exports_.AddProp(className, classValue);
+}
+
+string FileNExporter::GetClassName()
+{
+    return FileNExporter::className_;
+}
+
+FileNExporter::FileNExporter(napi_env env, napi_value exports) : NExporter(env, exports) {}
+FileNExporter::~FileNExporter() {}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/class_file/file_n_exporter.h b/interfaces/kits/js/src/mod_fileio/class_file/file_n_exporter.h
new file mode 100644
index 0000000000000000000000000000000000000000..ffa96ed6ddba5898be6c1368d035366568a8d426
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/class_file/file_n_exporter.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INTERFACES_KITS_JS_SRC_MOD_FILEIO_CLASS_FILE_FILE_N_EXPORTER_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_CLASS_FILE_FILE_N_EXPORTER_H
+
+#include "../../common/napi/n_exporter.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class FileNExporter final : public NExporter {
+public:
+    inline static const std::string className_ = "File";
+
+    bool Export() override;
+    std::string GetClassName() override;
+
+    static napi_value Constructor(napi_env env, napi_callback_info cbinfo);
+
+    static napi_value GetFD(napi_env env, napi_callback_info cbinfo);
+    static napi_value GetPath(napi_env env, napi_callback_info cbinfo);
+    static napi_value GetUri(napi_env env, napi_callback_info cbinfo);
+
+    FileNExporter(napi_env env, napi_value exports);
+    ~FileNExporter() override;
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/open_v9.cpp b/interfaces/kits/js/src/mod_fileio/properties/open_v9.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fb6f45f4e0b5f6ce9b297aa68e7440765209f120
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/open_v9.cpp
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "open_v9.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+#include <uv.h>
+
+#include "../../common/log.h"
+#include "../../common/napi/n_async/n_async_work_callback.h"
+#include "../../common/napi/n_async/n_async_work_promise.h"
+#include "../../common/napi/n_class.h"
+#include "../../common/napi/n_func_arg.h"
+#include "../../common/uni_error.h"
+#include "../common_func.h"
+
+#include "../class_file/file_entity.h"
+#include "../class_file/file_n_exporter.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+static tuple<bool, int> GetJsFlags(napi_env env, const NFuncArg &funcArg)
+{
+    int mode = O_RDONLY;
+    bool succ = false;
+    if (funcArg.GetArgc() == NARG_CNT::TWO && NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_number)) {
+        tie(succ, mode) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+        if (!succ) {
+            UniError(EINVAL).ThrowErr(env);
+            return { false, mode };
+        }
+        (void)CommonFunc::ConvertJsFlags(mode);
+    }
+    return { true, mode };
+}
+
+static NVal InstantiateFile(napi_env env, int fd, string path)
+{
+    napi_value objRAF = NClass::InstantiateClass(env, FileNExporter::className_, {});
+    if (!objRAF) {
+        UniError(EIO).ThrowErr(env);
+        return NVal();
+    }
+
+    auto rafEntity = NClass::GetEntityOf<FileEntity>(env, objRAF);
+    if (!rafEntity) {
+        UniError(EIO).ThrowErr(env);
+        return NVal();
+    }
+    auto fdg = make_unique<FDGuard>(fd);
+    rafEntity->fd_.swap(fdg);
+    rafEntity->path_ = path;
+    rafEntity->uri_ = path;
+    return { env, objRAF };
+}
+
+napi_value OpenV9::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+    auto [succPath, path, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!succPath) {
+        return nullptr;
+    }
+    auto [succMode, mode] = GetJsFlags(env, funcArg);
+    if (!succMode) {
+        return nullptr;
+    }
+    uv_loop_s *loop = nullptr;
+    napi_get_uv_event_loop(env, &loop);
+    uv_fs_t open_req;
+    int ret = uv_fs_open(loop, &open_req, path.get(), mode, S_IRUSR |
+        S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, NULL);
+    if (ret < 0) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+    auto File = InstantiateFile(env, open_req.result, path.get()).val_;
+    uv_fs_req_cleanup(&open_req);
+    return File;
+}
+
+struct AsyncOpenFileArg {
+    int fd;
+    string path;
+    string uri;
+};
+
+napi_value OpenV9::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env);
+        return nullptr;
+    }
+    auto [succPath, path, ignore] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!succPath) {
+        return nullptr;
+    }
+    auto [succMode, mode] = GetJsFlags(env, funcArg);
+    if (!succMode) {
+        return nullptr;
+    }
+    auto arg = make_shared<AsyncOpenFileArg>();
+    auto cbExec = [arg, path = string(path.get()), mode = mode](napi_env env) -> UniError {
+        uv_loop_s *loop = nullptr;
+        napi_get_uv_event_loop(env, &loop);
+        uv_fs_t open_req;
+        int ret = uv_fs_open(loop, &open_req, path.c_str(), mode, S_IRUSR |
+            S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH, NULL);
+        if (ret < 0) {
+            return UniError(errno);
+        }
+        arg->fd = open_req.result;
+        arg->path = path;
+        arg->uri = path;
+        uv_fs_req_cleanup(&open_req);
+        return UniError(ERRNO_NOERR);
+    };
+    auto cbCompl = [arg](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return InstantiateFile(env, arg->fd, arg->path);
+    };
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (funcArg.GetArgc() == NARG_CNT::ONE || (funcArg.GetArgc() == NARG_CNT::TWO &&
+        NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_number))) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(openV9ProcedureName, cbExec, cbCompl).val_;
+    } else {
+        int cbIdx = ((funcArg.GetArgc() == NARG_CNT::THREE) ? NARG_POS::THIRD : NARG_POS::SECOND);
+        NVal cb(env, funcArg[cbIdx]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(openV9ProcedureName, cbExec, cbCompl).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/open_v9.h b/interfaces/kits/js/src/mod_fileio/properties/open_v9.h
new file mode 100644
index 0000000000000000000000000000000000000000..f449ee13bf8bc554930a4212868731b74940d3b9
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/open_v9.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_OPEN_V9_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_OPEN_V9_H
+
+#include "../../common/napi/uni_header.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class OpenV9 final {
+public:
+    static napi_value Async(napi_env env, napi_callback_info info);
+    static napi_value Sync(napi_env env, napi_callback_info info);
+};
+const std::string openV9ProcedureName = "FileIOOpenV9";
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file