components/l2s/common/utils.mjs (2)

4-15: LGTM: Array handling logic is well-implemented.

The function correctly handles arrays, preserving non-string values and safely parsing JSON strings.

Consider enhancing the function to handle nested arrays for more comprehensive parsing. This could be achieved by recursively calling parseObject on array items:

 if (Array.isArray(obj)) {
   return obj.map((item) => {
+    if (Array.isArray(item)) {
+      return parseObject(item);
+    }
     if (typeof item === "string") {
       try {
         return JSON.parse(item);
       } catch (e) {
         return item;
       }
     }
     return item;
   });
 }

---

1-24: Overall, the parseObject function is well-implemented and aligns with the PR objectives.

The function effectively handles various input types and provides a robust utility for parsing JSON strings while preserving non-string values. This could be particularly useful when dealing with URL-related data in the L2S service.

Consider the following enhancements to make the function even more robust:

1. Implement recursive handling of nested arrays, as suggested earlier.
2. Add optional error logging for debugging purposes. This could be implemented using a debug flag:

export const parseObject = (obj, debug = false) => {
  // ... existing code ...
  if (typeof obj === "string") {
    try {
      return JSON.parse(obj);
    } catch (e) {
      if (debug) {
        console.warn(`Failed to parse JSON string: ${obj}`, e);
      }
      return obj;
    }
  }
  // ... rest of the function ...
};

These enhancements would make the function more versatile and easier to debug in complex scenarios.

components/l2s/l2s.app.mjs (3)

15-23: LGTM: Request method well-implemented, consider adding error handling.

The _makeRequest() method is well-structured and correctly combines the base URL, headers, and additional options for making API requests. The use of object destructuring and spread operator provides flexibility.

Consider adding error handling to improve robustness:

 _makeRequest({
   $ = this, path, ...opts
 }) {
-  return axios($, {
+  return axios($, {
     url: this._baseUrl() + path,
     headers: this._headers(),
     ...opts,
-  });
+  }).catch(err => {
+    throw new Error(`Request failed: ${err.message}`);
+  });
 },

---

24-29: LGTM: URL shortening method implemented correctly, consider adding input validation.

The shortenUrl() method correctly implements the URL shortening functionality as per the PR objectives. It properly utilizes the _makeRequest() method with the correct HTTP method and endpoint.

Consider adding input validation to ensure the required 'url' property is present:

 shortenUrl(opts = {}) {
+  if (!opts.data || !opts.data.url) {
+    throw new Error("The 'url' property is required in the request data.");
+  }
   return this._makeRequest({
     method: "POST",
     path: "/url",
     ...opts,
   });
 },

---

1-32: Overall implementation looks good, consider future enhancements.

The l2s app module is well-structured and implements the core functionality for shortening URLs as required. The code is clean, modular, and follows good practices for API interaction.

For future enhancements, consider:

1. Implementing methods for other L2S API endpoints (if any) to provide a more comprehensive integration.
2. Adding input validation and error handling throughout the module to improve robustness.
3. Implementing a method to parse and validate the optional properties mentioned in the PR objectives (customKey, utmSource, etc.) before sending them to the API.

components/l2s/actions/create-shortened-url/create-shortened-url.mjs (2)

4-65: LGTM: Action configuration is well-defined and aligns with requirements.

The configuration includes all necessary properties as outlined in the linked issue #14107. The description, version, and type are appropriately set.

Consider adding input validation for the url property to ensure it's a valid URL format. This can help prevent potential issues with invalid URLs being processed. For example:

url: {
  type: "string",
  label: "URL",
  description: "The URL to be shortened",
  validate: (url) => {
    const urlPattern = new RegExp('^(https?:\\/\\/)?'+ // protocol
      '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|'+ // domain name
      '((\\d{1,3}\\.){3}\\d{1,3}))'+ // OR ip (v4) address
      '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*'+ // port and path
      '(\\?[;&a-z\\d%_.~+=-]*)?'+ // query string
      '(\\#[-a-z\\d_]*)?$','i'); // fragment locator
    if(!urlPattern.test(url)) {
      return "Please enter a valid URL";
    }
    return true;
  },
},

---

66-88: LGTM: Run method implements the required functionality.

The method correctly processes the input, calls the L2S API, and returns the expected result. However, there are a couple of areas for improvement:

1. Error Handling: Add try-catch block to handle potential API errors.
2. Performance: Consider using object spread for tags parsing to avoid unnecessary object creation.

Consider applying the following changes:

 async run({ $ }) {
   const {
     l2s,
     tags,
     ...data
   } = this;

   if (tags) {
-    data.tags = parseObject(tags);
+    data.tags = { ...parseObject(tags) };
   }

+  try {
     const { response: { data: response } } = await l2s.shortenUrl({
       $,
       data,
     });

     const shortUrl = `https://l2s.is/${response.key}`;
     $.export("$summary", "URL shortened successfully");
     return {
       short_url: shortUrl,
       ...response,
     };
+  } catch (error) {
+    $.export("$summary", "Failed to shorten URL");
+    throw error;
+  }
 },

These changes will improve error handling and slightly optimize the tags parsing process.

Configuration used: CodeRabbit UI
Review profile: CHILL