diff --git a/interfaces/kits/js/src/mod_fileio/properties/chmod.cpp b/interfaces/kits/js/src/mod_fileio/properties/chmod.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3bc5a6364f2b7c4c977d71c1ff7a8f1dac429b0b
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/chmod.cpp
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2021-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 "chmod.h"
+
+#include <cstring>
+#include <sys/stat.h>
+#include <tuple>
+#include <unistd.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_func_arg.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Chmod::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    auto [resGetSecondArg, mode] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid mode");
+        return nullptr;
+    }
+
+    if (chmod(path.get(), mode) == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value Chmod::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, tmp, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return nullptr;
+    }
+
+    auto [resGetSecondArg, mode] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid mode");
+    }
+
+    string path = tmp.get();
+    auto cbExec = [path, mode](napi_env env) -> UniError {
+        if (chmod(path.c_str(), mode) == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbComplete = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return { NVal::CreateUndefined(env) };
+    };
+
+    size_t argc = funcArg.GetArgc();
+    NVal thisVar(env, funcArg.GetThisVar());
+    const string procedureName = "FileIOChmod";
+    if (argc == NARG_CNT::TWO) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::THIRD]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/chmod.h b/interfaces/kits/js/src/mod_fileio/properties/chmod.h
new file mode 100644
index 0000000000000000000000000000000000000000..825289198b788ae310362e2850ff1e508e4dfe4f
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/chmod.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_CHMOD_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_CHMOD_H
+
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Chmod final {
+public:
+    static napi_value Sync(napi_env env, napi_callback_info info);
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/chown.cpp b/interfaces/kits/js/src/mod_fileio/properties/chown.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f6b4fff5afffb2e2d1f246cb80a44d374af01fe4
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/chown.cpp
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2021-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 "chown.h"
+
+#include <cstring>
+#include <tuple>
+#include <unistd.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_func_arg.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+static tuple<bool, string, int, int> GetChownArg(napi_env env, const NFuncArg &funcArg)
+{
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return { false, "", -1, -1 };
+    }
+
+    auto [resGetSecondArg, owner] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid owner");
+        return { false, "", -1, -1 };
+    }
+
+    auto [resGetThirdArg, group] = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
+    if (!resGetThirdArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid group");
+        return { false, "", -1, -1 };
+    }
+
+    return { succ, path.get(), owner, group };
+}
+
+napi_value Chown::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetChownArg, path, owner, group] = GetChownArg(env, funcArg);
+    if (!resGetChownArg) {
+        return nullptr;
+    }
+
+    if (chown(path.c_str(), owner, group) == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value Chown::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FOUR)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetChownArg, path, owner, group] = GetChownArg(env, funcArg);
+    if (!resGetChownArg) {
+        return nullptr;
+    }
+
+    auto cbExec = [path, owner, group](napi_env env) -> UniError {
+        if (chown(path.c_str(), owner, group) == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbCompl = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return { NVal::CreateUndefined(env) };
+    };
+
+    const string procedureName = "FileIOChown";
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (funcArg.GetArgc() == NARG_CNT::THREE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
+    } else {
+        int cbIdx = NARG_POS::FOURTH;
+        NVal cb(env, funcArg[cbIdx]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbCompl).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
diff --git a/interfaces/kits/js/src/mod_fileio/properties/chown.h b/interfaces/kits/js/src/mod_fileio/properties/chown.h
new file mode 100644
index 0000000000000000000000000000000000000000..5ac00ec2fa502fa6f1bb70227a6e28c8f12dcf0b
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/chown.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_CHOWN_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_CHOWN_H
+
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Chown final {
+public:
+    static napi_value Sync(napi_env env, napi_callback_info info);
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/close.cpp b/interfaces/kits/js/src/mod_fileio/properties/close.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..44a7cf3915d5d57ce81d3580f2c25d8375d684b5
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/close.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2021 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 "close.h"
+
+#include <cstring>
+#include <tuple>
+#include <unistd.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_func_arg.h"
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Close::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    if (close(fd) == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value Close::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto cbExec = [fd](napi_env env) -> UniError {
+        int ret = close(fd);
+        if (ret == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbComplete = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        } else {
+            return NVal::CreateUndefined(env);
+        }
+    };
+
+    const string procedureName = "FileIOClose";
+    size_t argc = funcArg.GetArgc();
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (argc == NARG_CNT::ONE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::SECOND]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/close.h b/interfaces/kits/js/src/mod_fileio/properties/close.h
new file mode 100644
index 0000000000000000000000000000000000000000..6d6a3964682a2e10c6f29306fea72a396b9544a0
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/close.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_CLOSE_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_CLOSE_H
+
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Close final {
+public:
+    static napi_value Sync(napi_env env, napi_callback_info info);
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/copy_file.cpp b/interfaces/kits/js/src/mod_fileio/properties/copy_file.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..30f2cc90dd68a63bc5fa11164121d3fcf278f17d
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/copy_file.cpp
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2021-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 "copy_file.h"
+
+#include <cstring>
+#include <fcntl.h>
+#include <sys/sendfile.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <tuple>
+#include <unistd.h>
+
+#include "../../common/file_helper/fd_guard.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_func_arg.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+namespace {
+constexpr int COPY_BLOCK_SIZE = 4096;
+}
+
+struct FileInfo {
+    bool isPath = false;
+    unique_ptr<char[]> path;
+    FDGuard fdg;
+};
+
+static UniError CopyFileCore(FileInfo &srcFile, FileInfo &destFile)
+{
+    int res = EINVAL;
+    if (srcFile.isPath) {
+        srcFile.fdg.SetFD(open(srcFile.path.get(), O_RDONLY), true);
+        res = errno;
+    }
+
+    if (!srcFile.fdg) {
+        return UniError(res);
+    }
+
+    struct stat statbf;
+    if (fstat(srcFile.fdg.GetFD(), &statbf) == -1) {
+        return UniError(errno);
+    }
+
+    if (destFile.isPath) {
+        destFile.fdg.SetFD(open(destFile.path.get(), O_WRONLY | O_CREAT, statbf.st_mode), true);
+        res = errno;
+    }
+
+    if (!destFile.fdg) {
+        return UniError(res);
+    }
+
+    auto copyBuf = make_unique<char[]>(COPY_BLOCK_SIZE);
+    do {
+        ssize_t readSize = read(srcFile.fdg.GetFD(), copyBuf.get(), COPY_BLOCK_SIZE);
+        if (readSize == -1) {
+            return UniError(errno);
+        } else if (readSize == 0) {
+            break;
+        }
+        ssize_t writeSize = write(destFile.fdg.GetFD(), copyBuf.get(), readSize);
+        if (writeSize != readSize) {
+            return UniError(errno);
+        }
+        if (readSize != COPY_BLOCK_SIZE) {
+            break;
+        }
+    } while (true);
+
+    return UniError(ERRNO_NOERR);
+}
+
+static tuple<bool, int, bool> ParseJsModeAndProm(napi_env env, const NFuncArg &funcArg)
+{
+    bool succ = false;
+    bool promise = false;
+    bool hasMode = false;
+    int mode = 0;
+    if (funcArg.GetArgc() == NARG_CNT::THREE && NVal(env, funcArg[NARG_POS::THIRD]).TypeIs(napi_number)) {
+        promise = true;
+        hasMode = true;
+    } else if (funcArg.GetArgc() == NARG_CNT::FOUR) {
+        hasMode = true;
+    }
+
+    if (hasMode) {
+        tie(succ, mode) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
+        if (!succ) {
+            return {false, mode, promise};
+        }
+    }
+
+    return {true, mode, promise};
+}
+
+static tuple<bool, FileInfo> ParseJsOperand(napi_env env, NVal pathOrFdFromJsArg)
+{
+    auto [isPath, path, ignore] = pathOrFdFromJsArg.ToUTF8String();
+    if (isPath) {
+        return {true, FileInfo{true, move(path), {}}};
+    }
+
+    auto [isFd, fd] = pathOrFdFromJsArg.ToInt32();
+    if (isFd) {
+        return {true, FileInfo{false, {}, {fd, false}}};
+    }
+
+    return {false, FileInfo{false, {}, {}}};
+};
+
+napi_value CopyFile::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [succSrc, src] = ParseJsOperand(env, {env, funcArg[NARG_POS::FIRST]});
+    auto [succDest, dest] = ParseJsOperand(env, {env, funcArg[NARG_POS::SECOND]});
+    if (!succSrc || !succDest) {
+        UniError(EINVAL).ThrowErr(env, "The first/second argument requires filepath/fd");
+        return nullptr;
+    }
+
+    auto [succMode, mode, unused] = ParseJsModeAndProm(env, funcArg);
+    if (!succMode) {
+        UniError(EINVAL).ThrowErr(env, "Invalid mode");
+        return nullptr;
+    }
+
+    auto err = CopyFileCore(src, dest);
+    if (err) {
+        err.ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+class Para {
+public:
+    FileInfo src_;
+    FileInfo dest_;
+
+    Para(FileInfo src, FileInfo dest) : src_(move(src)), dest_(move(dest)) {};
+};
+
+napi_value CopyFile::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::FOUR)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [succSrc, src] = ParseJsOperand(env, {env, funcArg[NARG_POS::FIRST]});
+    auto [succDest, dest] = ParseJsOperand(env, {env, funcArg[NARG_POS::SECOND]});
+    if (!succSrc || !succDest) {
+        UniError(EINVAL).ThrowErr(env, "The first/second argument requires filepath/fd");
+        return nullptr;
+    }
+
+    auto [succMode, mode, promise] = ParseJsModeAndProm(env, funcArg);
+    if (!succMode) {
+        UniError(EINVAL).ThrowErr(env, "Invalid mode");
+        return nullptr;
+    }
+
+    auto cbExec = [para = make_shared<Para>(move(src), move(dest))](napi_env env) -> UniError {
+        return CopyFileCore(para->src_, para->dest_);
+    };
+
+    auto cbCompl = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return {env, err.GetNapiErr(env)};
+        }
+        return {NVal::CreateUndefined(env)};
+    };
+    
+    const string procedureName = "FileIOCopyFile";
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (funcArg.GetArgc() == NARG_CNT::TWO || promise) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
+    } else {
+        NVal cb(env, funcArg[((funcArg.GetArgc() == NARG_CNT::THREE) ? NARG_POS::THIRD : NARG_POS::FOURTH)]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbCompl).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
diff --git a/interfaces/kits/js/src/mod_fileio/properties/copy_file.h b/interfaces/kits/js/src/mod_fileio/properties/copy_file.h
new file mode 100644
index 0000000000000000000000000000000000000000..bef01ef1e7a6d0ee54ad37903525210be32e9d98
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/copy_file.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_COPY_FILE_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_COPY_FILE_H
+
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class CopyFile final {
+public:
+    static napi_value Async(napi_env env, napi_callback_info info);
+    static napi_value Sync(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/create_stream.cpp b/interfaces/kits/js/src/mod_fileio/properties/create_stream.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..df19686d80e9e159948c5efdfc13863a1741cd53
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/create_stream.cpp
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2021 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 "create_stream.h"
+
+#include <memory>
+#include <tuple>
+
+#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/napi/n_val.h"
+#include "../../common/uni_error.h"
+
+#include "../class_stream/stream_entity.h"
+#include "../class_stream/stream_n_exporter.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+static NVal InstantiateStream(napi_env env, unique_ptr<FILE, decltype(&fclose)> fp)
+{
+    napi_value objStream = NClass::InstantiateClass(env, StreamNExporter::className_, {});
+    if (!objStream) {
+        UniError(EIO).ThrowErr(env, "INNER BUG. Cannot instantiate stream");
+        return NVal();
+    }
+
+    auto streamEntity = NClass::GetEntityOf<StreamEntity>(env, objStream);
+    if (!streamEntity) {
+        UniError(EIO).ThrowErr(env, "Cannot instantiate stream because of void entity");
+        return NVal();
+    }
+
+    streamEntity->fp.swap(fp);
+    return { env, objStream };
+}
+
+static tuple<bool, string, string> GetCreateStreamArgs(napi_env env, const NFuncArg &funcArg)
+{
+    auto [resGetFirstArg, path, unused] = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid path");
+        return { false, "", "" };
+    }
+
+    tie(resGetSecondArg, mode, useless) = NVal(env, funcArg[NARG_POS::SECOND]).ToUTF8String();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid mode");
+        return { false, "", "" };
+    }
+
+    return { true, path.get(), mode.get() };
+}
+
+napi_value CreateStream::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetCreateStreamArgs, argPath, argMode) = GetCreateStreamArgs(env, funcArg);
+    if (!resGetCreateStreamArgs) {
+        return nullptr;
+    }
+
+    unique_ptr<FILE, decltype(&fclose)> fp = { fopen(argPath.c_str(), argMode.c_str()), fclose };
+    if (!fp) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return InstantiateStream(env, move(fp)).val_;
+}
+
+struct AsyncCreateStreamArg {
+    unique_ptr<FILE, decltype(&fclose)> fp = { nullptr, fclose };
+};
+
+napi_value CreateStream::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetCreateStreamArgs, argPath, argMode] = GetCreateStreamArgs(env, funcArg);
+    if (!resGetCreateStreamArgs) {
+        return nullptr;
+    }
+
+    auto arg = make_shared<AsyncCreateStreamArg>();
+    auto cbExec = [arg, argPath = move(argPath), argMode = move(argMode)](napi_env env) -> UniError {
+        arg->fp = { fopen(argPath.c_str(), argMode.c_str()), fclose };
+        if (!arg->fp) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbCompl = [arg](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return InstantiateStream(env, move(arg->fp));
+    };
+
+    const string procedureName = "FileIOCreateStream";
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (funcArg.GetArgc() == NARG_CNT::TWO) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::THIRD]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, 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/create_stream.h b/interfaces/kits/js/src/mod_fileio/properties/create_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c58fa744a9dbb7a0e85d3c7e7258b4695c8c13c
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/create_stream.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_CREATE_STREAM_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_CREATE_STREAM_H
+
+#include "../../common/napi/uni_header.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class CreateStream final {
+public:
+    static napi_value Async(napi_env env, napi_callback_info info);
+    static napi_value Sync(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/fchmod.cpp b/interfaces/kits/js/src/mod_fileio/properties/fchmod.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fe2dcbcfba5083dfc743b667c013264b544316a1
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fchmod.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2021 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 "fchmod.h"
+#include <cstring>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <tuple>
+#include <unistd.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_func_arg.h"
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Fchmod::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto [resGetSecondArg, mode] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid mode");
+        return nullptr;
+    }
+
+    int ret = fchmod(fd, mode);
+    if (ret == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+
+napi_value Fchmod::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto [resGetSecondArg, mode] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid owner");
+    }
+
+    auto cbExec = [fd, mode](napi_env env) -> UniError {
+        int ret = fchmod(fd, mode);
+        if (ret == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbComplCallback = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return { NVal::CreateUndefined(env) };
+    };
+
+    const string procedureName = "FileIOFchmod";
+    NVal thisVar(env, funcArg.GetThisVar());
+    size_t argc = funcArg.GetArgc();
+    if (argc == NARG_CNT::TWO) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplCallback).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::THIRD]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplCallback).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/fchmod.h b/interfaces/kits/js/src/mod_fileio/properties/fchmod.h
new file mode 100644
index 0000000000000000000000000000000000000000..eb7711822870984742d1190bedfb61200768b2d6
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fchmod.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_FCHMOD_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_FCHMOD_H
+
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Fchmod final {
+public:
+    static napi_value Sync(napi_env env, napi_callback_info info);
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/fchown.cpp b/interfaces/kits/js/src/mod_fileio/properties/fchown.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e2576eea74ea2bf043adf718cac6688db2325f99
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fchown.cpp
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2021 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 "fchown.h"
+#include <cstring>
+#include <fcntl.h>
+#include <tuple>
+#include <unistd.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_func_arg.h"
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Fchown::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto [resGetSecondArg, owner] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid owner");
+    }
+
+    auto [resGetThirdArg, group] = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
+    if (!resGetThirdArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid group");
+    }
+
+    int ret = fchown(fd, owner, group);
+    if (ret == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value Fchown::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::THREE, NARG_CNT::FOUR)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto [resGetSecondArg, owner] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid owner");
+    }
+
+    auto (resGetThirdArg, group] = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
+    if (!resGetThirdArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid group");
+    }
+
+    auto cbExec = [fd, owner, group](napi_env env) -> UniError {
+        int ret = fchown(fd, owner, group);
+        if (ret == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbComplCallback = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return { NVal::CreateUndefined(env) };
+    };
+
+    const string procedureName = "FileIOFchown";
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (funcArg.GetArgc() == NARG_CNT::THREE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplCallback).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::FOURTH]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplCallback).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/fchown.h b/interfaces/kits/js/src/mod_fileio/properties/fchown.h
new file mode 100644
index 0000000000000000000000000000000000000000..7439f2e542f346eeb6f8c9affaca8f3a8705e752
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fchown.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_FCHOWN_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_FCHOWN_H
+
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Fchown final {
+public:
+    static napi_value Sync(napi_env env, napi_callback_info info);
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/fdatasync.cpp b/interfaces/kits/js/src/mod_fileio/properties/fdatasync.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8c7c739120e6d36351913a494756a59b99c0b359
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fdatasync.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2021 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 "fdatasync.h"
+#include <cstring>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <tuple>
+#include <unistd.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_func_arg.h"
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Fdatasync::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    int ret = fdatasync(fd);
+    if (ret == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+
+napi_value Fdatasync::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto cbExec = [fd](napi_env env) -> UniError {
+        int ret = fdatasync(fd);
+        if (ret == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbComplCallback = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return { NVal::CreateUndefined(env) };
+    };
+
+    const string procedureName = "FileIOFdatasync";
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (funcArg.GetArgc() == NARG_CNT::ONE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplCallback).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::SECOND]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplCallback).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/fdatasync.h b/interfaces/kits/js/src/mod_fileio/properties/fdatasync.h
new file mode 100644
index 0000000000000000000000000000000000000000..f10fcbde3a1faa694680ef8ce97aaba17824e65f
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fdatasync.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_FDATASYNC_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_FDATASYNC_H
+
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Fdatasync final {
+public:
+    static napi_value Sync(napi_env env, napi_callback_info info);
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/fdopen_stream.cpp b/interfaces/kits/js/src/mod_fileio/properties/fdopen_stream.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..dddce67daf690b23481358a86bf908e899a06901
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fdopen_stream.cpp
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2021 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 "fdopen_stream.h"
+#include <memory>
+#include <tuple>
+
+#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/napi/n_val.h"
+#include "../../common/uni_error.h"
+#include "../class_stream/stream_entity.h"
+#include "../class_stream/stream_n_exporter.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+static NVal InstantiateStream(napi_env env, unique_ptr<FILE, decltype(&fclose)> fp)
+{
+    napi_value objStream = NClass::InstantiateClass(env, StreamNExporter::className_, {});
+    if (!objStream) {
+        UniError(EIO).ThrowErr(env, "INNER BUG. Cannot instantiate stream");
+        return NVal();
+    }
+
+    auto streamEntity = NClass::GetEntityOf<StreamEntity>(env, objStream);
+    if (!streamEntity) {
+        UniError(EIO).ThrowErr(env, "Cannot instantiate stream because of void entity");
+        return NVal();
+    }
+
+    streamEntity->fp.swap(fp);
+    return { env, objStream };
+}
+
+static tuple<bool, int, string> GetFdopenStreamArgs(napi_env env, const NFuncArg &funcArg)
+{
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Arg fd is required to be type integer");
+        return { false, -1, "" };
+    }
+
+    auto [resGetSecondArg, mode, unused] = NVal(env, funcArg[NARG_POS::SECOND]).ToUTF8String();
+    if (!resGetSecondArg) {
+        UniError(EINVAL).ThrowErr(env, "Arg mode is required to be type string");
+        return { false, -1, "" };
+    }
+
+    return { true, fd, mode.get() };
+}
+
+napi_value FdopenStream::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFdopenStreamArgs, fd, mode] = GetFdopenStreamArgs(env, funcArg);
+    if (!resGetFdopenStreamArgs) {
+        return nullptr;
+    }
+
+    unique_ptr<FILE, decltype(&fclose)> fp = { fdopen(fd, mode.c_str()), fclose };
+    if (!fp) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return InstantiateStream(env, move(fp)).val_;
+}
+
+struct AsyncFdopenStreamArg {
+    unique_ptr<FILE, decltype(&fclose)> fp = { nullptr, fclose };
+};
+
+napi_value FdopenStream::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFdopenStreamArgs, fd, mode] = GetFdopenStreamArgs(env, funcArg);
+    if (!resGetFdopenStreamArgs) {
+        return nullptr;
+    }
+
+    auto arg = make_shared<AsyncFdopenStreamArg>();
+    auto cbExec = [arg, fd, mode = move(mode)](napi_env env) -> UniError {
+        arg->fp = { fdopen(fd, mode.c_str()), fclose };
+        if (!arg->fp) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbCompl = [arg](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        return InstantiateStream(env, move(arg->fp));
+    };
+
+    const string procedureName = "FileIOFdopenStream";
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (funcArg.GetArgc() == NARG_CNT::TWO) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::THIRD]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, 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/fdopen_stream.h b/interfaces/kits/js/src/mod_fileio/properties/fdopen_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..195369eceec8a73a7278380675ae64be6a358626
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fdopen_stream.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_FDOPEN_STREAM_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_FDOPEN_STREAM_H
+
+#include "../../common/napi/uni_header.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class FdopenStream final {
+public:
+    static napi_value Async(napi_env env, napi_callback_info info);
+    static napi_value Sync(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/fstat.cpp b/interfaces/kits/js/src/mod_fileio/properties/fstat.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..34e01a1b2602486e1d1f8afb14b5268a5ddb52c3
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fstat.cpp
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2021 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 "fstat.h"
+
+#include <memory>
+#include <tuple>
+
+#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/napi/n_val.h"
+#include "../../common/uni_error.h"
+
+#include "../class_stat/stat_entity.h"
+#include "../class_stat/stat_n_exporter.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Fstat::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    struct stat buf;
+    if (fstat(fd, &buf) == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    napi_value objStat = NClass::InstantiateClass(env, StatNExporter::className_, {});
+    if (!objStat) {
+        UniError(EINVAL).ThrowErr(env, "Cannot instantiate class");
+        return nullptr;
+    }
+
+    auto statEntity = NClass::GetEntityOf<StatEntity>(env, objStat);
+    if (!statEntity) {
+        UniError(EINVAL).ThrowErr(env, "Cannot get the entity of objStat");
+        return nullptr;
+    }
+
+    statEntity->stat_ = buf;
+    return objStat;
+}
+
+struct AsyncStatArg {
+    struct stat stat_;
+};
+
+napi_value Fstat::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto arg = make_shared<AsyncStatArg>();
+    auto cbExec = [fd, arg](napi_env env) -> UniError {
+        if (fstat(fd, &arg->stat_)) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbCompl = [arg](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        }
+        napi_value objStat = NClass::InstantiateClass(env, StatNExporter::className_, {});
+        if (!objStat) {
+            return { env, UniError(EIO).GetNapiErr(env) };
+        }
+        auto statEntity = NClass::GetEntityOf<StatEntity>(env, objStat);
+        if (!statEntity) {
+            return { env, UniError(EIO).GetNapiErr(env) };
+        }
+        statEntity->stat_ = arg->stat_;
+        return { env, objStat };
+    };
+
+    NVal thisVar(env, funcArg.GetThisVar());
+    const string procedureName = "fileIOFstat";
+    if (funcArg.GetArgc() == NARG_CNT::ONE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbCompl).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::SECOND]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, 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/fstat.h b/interfaces/kits/js/src/mod_fileio/properties/fstat.h
new file mode 100644
index 0000000000000000000000000000000000000000..27395df81e9d5802c873d5c7be42b066fc254640
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fstat.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_FSTAT_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_FSTAT_H
+
+#include "../../common/napi/uni_header.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Fstat final {
+public:
+    static napi_value Async(napi_env env, napi_callback_info info);
+    static napi_value Sync(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/fsync.cpp b/interfaces/kits/js/src/mod_fileio/properties/fsync.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aa25b2e6ce550e098ae88a38096755ec4da94b6e
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fsync.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2021 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 "fsync.h"
+
+#include <cstring>
+#include <tuple>
+#include <unistd.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_func_arg.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Fsync::Sync(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    if (fsync(fd) == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value Fsync::Async(napi_env env, napi_callback_info info)
+{
+    NFuncArg funcArg(env, info);
+    if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
+        UniError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    auto cbExec = [fd](napi_env env) -> UniError {
+        if (fsync(fd) == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbComplete = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        } else {
+            return NVal::CreateUndefined(env);
+        }
+    };
+
+    const string procedureName = "FileIOFsync";
+    size_t argc = funcArg.GetArgc();
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (argc == NARG_CNT::ONE) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::SECOND]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
diff --git a/interfaces/kits/js/src/mod_fileio/properties/fsync.h b/interfaces/kits/js/src/mod_fileio/properties/fsync.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e2a54e040fd05388608de6d0bc3a38ad264c868
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/fsync.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_FSYNC_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_FSYNC_H
+
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Fsync final {
+public:
+    static napi_value Sync(napi_env env, napi_callback_info info);
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/ftruncate.cpp b/interfaces/kits/js/src/mod_fileio/properties/ftruncate.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d325a8d0edd23408066993daec7fd6d14a3a576b
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/ftruncate.cpp
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2021 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 "ftruncate.h"
+
+#include <cstring>
+#include <tuple>
+#include <unistd.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_func_arg.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+using namespace std;
+
+napi_value Ftruncate::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, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    int ret = -1;
+    if (funcArg.GetArgc() == NARG_CNT::ONE) {
+        ret = ftruncate(fd, 0);
+    } else {
+        int len;
+        tie(succ, len) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+        if (!succ) {
+            UniError(EINVAL).ThrowErr(env, "Invalid len");
+            return nullptr;
+        }
+        ret = ftruncate(fd, len);
+    }
+
+    if (ret == -1) {
+        UniError(errno).ThrowErr(env);
+        return nullptr;
+    }
+
+    return NVal::CreateUndefined(env).val_;
+}
+
+napi_value Ftruncate::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, "Number of arguments unmatched");
+        return nullptr;
+    }
+
+    auto [resGetFirstArg, fd] = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
+    if (!resGetFirstArg) {
+        UniError(EINVAL).ThrowErr(env, "Invalid fd");
+        return nullptr;
+    }
+
+    int len = 0;
+    size_t argc = funcArg.GetArgc();
+    if (argc > NARG_CNT::ONE) {
+        auto [resGetSecondArg, length] = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
+        if (!resGetSecondArg) {
+            UniError(EINVAL).ThrowErr(env, "Invalid len");
+            return nullptr;
+        }
+        len = length;
+    }
+
+    auto cbExec = [fd, len](napi_env env) -> UniError {
+        int ret = ftruncate(fd, len);
+        if (ret == -1) {
+            return UniError(errno);
+        } else {
+            return UniError(ERRNO_NOERR);
+        }
+    };
+
+    auto cbComplete = [](napi_env env, UniError err) -> NVal {
+        if (err) {
+            return { env, err.GetNapiErr(env) };
+        } else {
+            return NVal::CreateUndefined(env);
+        }
+    };
+
+    const string procedureName = "fileIOFtruncate";
+    NVal thisVar(env, funcArg.GetThisVar());
+    if (argc == NARG_CNT::ONE || (argc == NARG_CNT::TWO && NVal(env, funcArg[NARG_POS::SECOND]).TypeIs(napi_number))) {
+        return NAsyncWorkPromise(env, thisVar).Schedule(procedureName, cbExec, cbComplete).val_;
+    } else {
+        NVal cb(env, funcArg[NARG_POS::THIRD]);
+        return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
+    }
+}
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
\ No newline at end of file
diff --git a/interfaces/kits/js/src/mod_fileio/properties/ftruncate.h b/interfaces/kits/js/src/mod_fileio/properties/ftruncate.h
new file mode 100644
index 0000000000000000000000000000000000000000..f9d076efc337ce69f6ea7d804d07a580964b1c91
--- /dev/null
+++ b/interfaces/kits/js/src/mod_fileio/properties/ftruncate.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021 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_FTRUNCATE_H
+#define INTERFACES_KITS_JS_SRC_MOD_FILEIO_PROPERTIES_FTRUNCATE_H
+
+#include "../../common/napi/n_val.h"
+
+namespace OHOS {
+namespace DistributedFS {
+namespace ModuleFileIO {
+class Ftruncate final {
+public:
+    static napi_value Sync(napi_env env, napi_callback_info info);
+    static napi_value Async(napi_env env, napi_callback_info info);
+};
+} // namespace ModuleFileIO
+} // namespace DistributedFS
+} // namespace OHOS
+#endif
\ No newline at end of file