'How to deal with ECONNRESET error in Supabase

I have a remix action function that accepts a file as a formData request object and then uploads it to supabase. After that, I get the URL of the uploaded image and return it.

My function:

 const fileExt = filename.split(".").pop();
  const fileName = `${Math.random().toFixed(10)}.${fileExt}`;
  const filePath = `${fileName}`;

  const { error: uploadError } = await supabaseClient.storage
      .from("public")
      .upload(`misc/${filePath}`, stream);

    if (uploadError) {
      console.error(uploadError);
      throw new Error(uploadError.message);
    }

    const { publicURL, error } = await supabaseClient.storage
      .from("public")
      .getPublicUrl(`misc/${filePath}`);
    if (error) {
      console.error(error);
      throw new Error(error.message);
    }
    !publicURL && console.error(`No public URL for ${filePath}`);

    return publicURL;

Because the formData is a multipart/form-data, I need to parse it which I handled by throwing the code above in an uploadHandler function and then:

const formData = await parseMultipartFormData(
    request,
    uploadHandler
 );

The code works and at other times, it fails with an error:ECONNRESET, from what I understand, that may have to do with node asynchronous code but I have not been able to solve it. How would I be able to avoid those random ECONNRESET errors that Supabase keeps giving?

node.jssupabaseremix.runswiftuinavigationuinavigationcontrollerpush


Solution 1:[1]

I've been through this with file uploads and Remix. I think while everyone's use-case is different, in many cases, where it's an authenticated user uploading to a service like Supabase storage or Cloudflare, it's better to upload from the client. This is especially true if we are using a serverless env. With cloudflare I grab a unique signed upload url with useFetcher(). With Supabase the team have setup their JS library to authenticate the user and we write policies on the database to protect the upload. So it's just a lot easier to use the Client. This becomes even more relevant where we're uploading large video files for example and we want to use the ability to pause and resume uploading. It's much easier from the client than via isolated serverless functions. If we're worried about data from the client, we can put sensitive data encrypted in a cookie so when the client completes it (eg) sends {completed: true} to an Action which grabs the data from the cookie and persists it to the database

I'm sure this doesn't solve your problem, like you really need to do it via the backend, but I just wanted to share that in my experience it's not always the best idea to do everything The Remix Way. Sometimes the client is better.

Solution 2:[2]

In SwiftUI, the navigation has been improved, You have to embed your view inside a NavigationView, and after that you can use NavigationLink to redirect wherever you want

example:

struct ContentView: View {
    var body: some View {
        NavigationView {
            VStack(spacing: 30) {
                Text("You're going to flip a coin – do you want to choose heads or tails?")

                NavigationLink(destination: ResultView(choice: "Heads")) {
                    Text("Choose Heads")
                }

                NavigationLink(destination: ResultView(choice: "Tails")) {
                    Text("Choose Tails")
                }
            }
            .navigationTitle("Navigation")
        }
    }
}

(You can replace the NavigationLink content by whatever you want, Text -> Button)

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution Source
Solution 1 fergus
Solution 2 BLANDIN Florian

Related Questions