fix: fix issue awslabs#123

Author: fredbonin

src/fs/access.rs

@@ -11,7 +11,7 @@ use crate::utils::result::ResultExt;
 use super::{CONSTANT_F_OK, CONSTANT_R_OK, CONSTANT_W_OK, CONSTANT_X_OK};
 
 pub async fn access(ctx: Ctx<'_>, path: String, mode: Opt<u32>) -> Result<()> {
-    let metadata = fs::metadata(path.clone())
+    let metadata = fs::metadata(&path)
         .await
         .or_throw_msg(&ctx, &format!("Can't access file \"{}\"", &path))?;
 

src/fs/read_file.rs

@@ -1,18 +1,37 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-use rquickjs::{function::Opt, Ctx, Object, Result};
+use rquickjs::{function::Opt, Ctx, Exception, IntoJs, Object, Result, String as JsString, Value};
 use tokio::fs;
 
 use crate::{buffer::Buffer, utils::result::ResultExt};
 
-//TODO implement options
 pub async fn read_file<'js>(
     ctx: Ctx<'js>,
     path: String,
-    _options: Opt<Object<'js>>,
-) -> Result<Buffer> {
-    let bytes = fs::read(path.clone())
+    options: Opt<Object<'js>>,
+) -> Result<Value<'js>> {
+    let mut encoding: String = String::from("");
+    if let Some(options) = options.0 {
+        encoding = options.get("encoding").unwrap_or(encoding);
+    }
+
+    let bytes = fs::read(&path)
         .await
         .or_throw_msg(&ctx, &format!("Can't read \"{}\"", &path))?;
-    Ok(Buffer(bytes))
+
+    // Return string or bytes depending on the option (we only support encoding option now)
+    return match encoding.to_ascii_lowercase().as_str() {
+        "" => Buffer(bytes).into_js(&ctx),
+        "utf-8" => {
+            let utf8_str = std::str::from_utf8(&bytes).unwrap();
+            Ok(JsString::from_str(ctx.clone(), utf8_str)?.into_value())
+        }
+        _ => Err(Exception::throw_message(
+            &ctx,
+            &format!(
+                "Encoding not supported: {}. Currently supported:utf-8",
+                encoding
+            ),
+        )),
+    };
 }

tests/unit/fs.test.ts

@@ -84,6 +84,12 @@ describe("readfile", () => {
     expect(base64Text).toEqual("aGVsbG8gd29ybGQh");
     expect(hexText).toEqual("68656c6c6f20776f726c6421");
   });
+  it("should read a file as a string", async () => {
+    const text = await fs.readFile("fixtures/hello.txt", { encoding: "utf-8" });
+
+    expect(typeof text).toEqual("string");
+    expect(text).toEqual("hello world!");
+  });
 });
 
 describe("mkdtemp", () => {
@@ -106,7 +112,7 @@ describe("mkdtemp", () => {
     // Clean up the temporary directory
     await fs.rmdir(dirPath);
   });
-})
+});
 
 describe("mkdtempSync", () => {
   it("should create a temporary directory with a given prefix synchronously", async () => {
@@ -119,11 +125,11 @@ describe("mkdtempSync", () => {
       .stat(dirPath)
       .then(() => true)
       .catch(() => false);
-    expect(dirExists).toBeTruthy()
+    expect(dirExists).toBeTruthy();
 
     // Check that the directory has the correct prefix
     const dirPrefix = path.basename(dirPath).slice(0, prefix.length);
-    expect(dirPrefix).toStrictEqual(prefix)
+    expect(dirPrefix).toStrictEqual(prefix);
 
     // Clean up the temporary directory
     await fs.rmdir(dirPath);
@@ -155,7 +161,9 @@ describe("mkdir", () => {
 
 describe("mkdirSync", () => {
   it("should create a directory with the given path synchronously", async () => {
-    const dirPath = defaultFsImport.mkdtempSync(path.join(os.tmpdir(), "test/test-"));
+    const dirPath = defaultFsImport.mkdtempSync(
+      path.join(os.tmpdir(), "test/test-")
+    );
 
     //non recursive should reject
     expect(() => defaultFsImport.mkdirSync(dirPath)).toThrow(/[fF]ile.*exists/);