feat: Improved compliance of URL object (#409)

* feat: Improved compliance of url object Signed-off-by: WATANABE Shinya <[email protected]> * Fix API.md * Refactoring --------- Signed-off-by: WATANABE Shinya <[email protected]>
awslabs · Jun 7, 2024 · b1ca602 · b1ca602
1 parent e67efd7
commit b1ca602
Show file tree

Hide file tree

Showing 3 changed files with 30 additions and 15 deletions.
diff --git a/API.md b/API.md
@@ -191,6 +191,7 @@ export class URL {
   searchParams: URLSearchParams;
   username: string;
 
+  parse(input: string, base?: string): URL | null;
   canParse(input: string, base?: string): boolean;
   toJSON(): string;
   toString(): string;

diff --git a/llrt_core/src/modules/http/url.rs b/llrt_core/src/modules/http/url.rs
@@ -7,7 +7,7 @@ use rquickjs::{
     class::{Trace, Tracer},
     function::Opt,
     prelude::This,
-    Class, Coerced, Ctx, Exception, FromJs, Function, Object, Result, Value,
+    Class, Coerced, Ctx, Exception, FromJs, Function, IntoJs, Null, Object, Result, Value,
 };
 use url::Url;
 
@@ -64,31 +64,40 @@ impl<'js> URL<'js> {
 
     #[qjs(static)]
     pub fn can_parse(ctx: Ctx<'js>, input: Value<'js>, base: Opt<Value<'js>>) -> bool {
+        match Self::parse(ctx.clone(), input.clone(), Opt(base.clone())) {
+            Ok(val) => !val.is_null(),
+            Err(_) => false,
+        }
+    }
+
+    #[qjs(static)]
+    pub fn parse(ctx: Ctx<'js>, input: Value<'js>, base: Opt<Value<'js>>) -> Result<Value<'js>> {
         if let Some(base) = base.0 {
             let base_string = match get_string(&ctx, base) {
                 Ok(s) => s,
-                Err(_) => return false,
+                Err(_) => return Null.into_js(&ctx),
             };
             let path_string = match get_string(&ctx, input) {
                 Ok(s) => s,
-                Err(_) => return false,
+                Err(_) => return Null.into_js(&ctx),
             };
 
             match base_string.parse::<Url>() {
-                Ok(base_url) => base_url.join(&path_string).is_ok(),
-                Err(_) => false, // Base URL parsing failed
+                Ok(base_url) => {
+                    if let Ok(parsed_url) = base_url.join(&path_string) {
+                        return URL::create(ctx.clone(), parsed_url).unwrap().into_js(&ctx);
+                    }
+                },
+                Err(_) => return Null.into_js(&ctx),
             }
-        } else {
-            // Handle the case where base is not provided
-            if input.is_string() {
-                match input.get::<String>() {
-                    Ok(string_val) => Url::parse(&string_val).is_ok(),
-                    Err(_) => false,
+        } else if input.is_string() {
+            if let Ok(string_val) = input.get::<String>() {
+                if let Ok(parsed_url) = Url::parse(&string_val) {
+                    return URL::create(ctx.clone(), parsed_url).unwrap().into_js(&ctx);
                 }
-            } else {
-                false
             }
         }
+        Null.into_js(&ctx)
     }
 
     pub fn to_string(&self) -> String {

diff --git a/tests/unit/http.test.ts b/tests/unit/http.test.ts
@@ -492,13 +492,18 @@ describe("URL class", () => {
     expect(url.username).toEqual("anonymous");
     expect(url.password).toEqual("flabada");
   });
-  it("should provide canParse util", () => {
+  it("should provide parse/canParse util", () => {
     const validUrl = "https://www.example.com/";
     const invalidUrl = "not_a_valid_url";
+    expect(URL.parse(validUrl).href).toEqual(validUrl);
     expect(URL.canParse(validUrl)).toEqual(true);
+    expect(URL.parse(invalidUrl)).toBeNull();
     expect(URL.canParse(invalidUrl)).toEqual(false);
   });
-  it("canParse works for relative urls", () => {
+  it("parse/canParse works for relative urls", () => {
+    expect(URL.parse("/foo", "https://example.org/").href).toEqual(
+      "https://example.org/foo"
+    );
     expect(URL.canParse("/foo", "https://example.org/")).toEqual(true);
   });
 });