@overmap-ai/core 1.0.49-fix-error-messaging.4 → 1.0.49-update-presigned-url-payload.0

package/dist/overmap-core.umd.cjs

@@ -208,64 +208,18 @@ var __publicField = (obj, key, value) => {
       this.requestAttemptCounter[uuid2] = (this.requestAttemptCounter[uuid2] || 0) + 1;
     }
   }
-  const UNKNOWN_ERROR_MESSAGE = "An unknown error occurred";
-  const MAX_ERROR_MESSAGE_LENGTH = 500;
-  const _SPECIAL_KEYS = ["non_field_errors", "detail"];
-  function extractErrorMessage(errorRes, err) {
-    let ret;
-    if (errorRes == null ? void 0 : errorRes.body) {
-      if (typeof errorRes.body === "object") {
-        const responseBody = errorRes.body;
-        if (typeof responseBody.error === "string") {
-          ret = responseBody.error;
-        } else if (typeof responseBody.message === "string") {
-          ret = responseBody.message;
-        } else if (responseBody.body) {
-          try {
-            ret = Object.entries(responseBody.body).map(([key, value]) => {
-              if (typeof value === "string") {
-                if (_SPECIAL_KEYS.includes(key))
-                  return value;
-                return `${key}: ${value}`;
-              }
-              if (Array.isArray(value)) {
-                if (_SPECIAL_KEYS.includes(key))
-                  return value.join("\n");
-                return value.map((v) => `${key}: ${v}`).join("\n");
-              }
-              return `${key}: ${JSON.stringify(value)}`;
-            }).join("\n");
-          } catch (e) {
-            console.error("Failed to extract error message from response body", e);
-          }
-        }
-      } else if (typeof errorRes.body === "string") {
-        ret = errorRes.body;
-      }
-    } else if (errorRes == null ? void 0 : errorRes.text) {
-      ret = errorRes.text;
-    } else if (err instanceof Error) {
-      ret = err.message;
-    }
-    if (!ret || ret.length > MAX_ERROR_MESSAGE_LENGTH) {
-      return UNKNOWN_ERROR_MESSAGE;
-    }
-    return ret;
-  }
   class APIError extends Error {
-    constructor(options) {
-      super(UNKNOWN_ERROR_MESSAGE);
+    constructor(message, response, options) {
+      super(response == null ? void 0 : response.text);
       // NOTE: Needs to conform to NetworkError in @redux-offline/redux-offline, which has `status` and `response`.
       __publicField(this, "status");
-      __publicField(this, "response");
       __publicField(this, "message");
+      __publicField(this, "response");
       __publicField(this, "options");
-      const { response, innerError } = options;
-      this.message = options.message ?? extractErrorMessage(response, innerError) ?? UNKNOWN_ERROR_MESSAGE;
+      this.message = message;
       this.status = (response == null ? void 0 : response.status) ?? 0;
       this.response = response;
-      options.discard = options.discard ?? false;
-      this.options = options;
+      this.options = options ?? { discard: false };
     }
   }
   class DeferredPromise {
@@ -4214,6 +4168,35 @@ var __publicField = (obj, key, value) => {
     }
     return void 0;
   }
+  function extractErrorMessage(errorRes, err) {
+    if (errorRes == null ? void 0 : errorRes.body) {
+      if (typeof errorRes.body === "object") {
+        if (typeof errorRes.body.error === "string")
+          return errorRes.body.error;
+        if (typeof errorRes.body.message === "string")
+          return errorRes.body.message;
+        try {
+          return Object.entries(errorRes.body).map(([key, value]) => {
+            if (typeof value === "string") {
+              return `${key}: ${value}`;
+            }
+            if (Array.isArray(value)) {
+              return value.map((v) => `${key}: ${v}`).join("\n");
+            }
+            return `${key}: ${JSON.stringify(value)}`;
+          }).join("\n");
+        } catch (e) {
+          console.error("Failed to extract error message from response body", e);
+        }
+      } else if (typeof errorRes.body === "string")
+        return errorRes.body;
+    } else if (errorRes == null ? void 0 : errorRes.text) {
+      return errorRes.text;
+    } else if (err instanceof Error) {
+      return err.message;
+    }
+    return void 0;
+  }
   async function performRequest(action, client) {
     async function checkToken() {
       if (client.auth.tokenIsExpiringSoon()) {
@@ -4316,29 +4299,19 @@ var __publicField = (obj, key, value) => {
             console.warn("No signed-in user to sign out.");
           }
           await client.auth.logout();
-          throw new APIError({
-            message: "You have been signed out due to inactivity.",
-            response: errorResponse,
-            discard: true,
-            innerError: error2
-          });
-        }
-        if (state.authReducer.isLoggedIn) {
-          console.debug("Forbidden; renewing tokens and retrying.");
-          await client.auth.renewTokens();
-          console.debug("Successfully renewed tokens; retrying request.");
-          return requestToSend.query(queryParams);
-        } else {
-          console.debug("Forbidden; user is not logged in.");
-          throw new APIError({
-            message: "Incorrect username or password.",
-            response: errorResponse,
-            discard: true,
-            innerError: error2
+          throw new APIError("You have been signed out due to inactivity.", errorResponse, {
+            discard: true
           });
         }
+        console.debug("Forbidden; renewing tokens and retrying.");
+        await client.auth.renewTokens();
+        console.debug("Successfully renewed tokens; retrying request.");
+        return requestToSend.query(queryParams);
       }
-      throw new APIError({ response: errorResponse, innerError: error2, discard: discardStatuses.includes(status) });
+      const apiErrorMessage = extractErrorMessage(errorResponse, error2) || "An unexpected error occurred.";
+      throw new APIError(apiErrorMessage, errorResponse, {
+        discard: discardStatuses.includes(status)
+      });
     }
   }
   class MiddlewareChainerPrivate {
@@ -4549,29 +4522,18 @@ var __publicField = (obj, key, value) => {
           if (response) {
             promise.resolve(response.body);
           } else {
-            const error2 = new APIError({
-              message: "Could not get a response from the server.",
+            const error2 = new APIError(
+              "Could not get a response from the server.",
               response,
-              discard: true
-            });
+              {
+                discard: true
+              }
+            );
             promise.reject(error2);
           }
         };
         const errorHandler = (error2) => {
-          if (error2 instanceof APIError) {
-            error2.options.discard = true;
-          } else {
-            console.error(
-              "Received an unexpected error while processing a request:",
-              error2,
-              "\nConverting error to APIError and discarding."
-            );
-            error2 = new APIError({
-              message: "An error occurred while processing the request.",
-              innerError: error2,
-              discard: true
-            });
-          }
+          error2.options.discard = true;
           promise.reject(error2);
         };
         innerPromise.then(successOrUndefinedHandler, errorHandler);
@@ -5151,23 +5113,24 @@ var __publicField = (obj, key, value) => {
        */
       __publicField(this, "_getTokenPair", (credentials, logoutOnFailure = true) => {
         const uuid$1 = uuid.v4();
-        const responsePromise = this.enqueueRequest({
-          uuid: uuid$1,
-          description: "Get token pair",
-          method: HttpMethod.POST,
-          url: "/api/token/",
-          payload: credentials,
-          isAuthNeeded: false,
-          checkAuth: false,
-          blockers: [],
-          blocks: []
-        }).then(parseTokens).catch((e) => {
+        try {
+          const responsePromise = this.enqueueRequest({
+            uuid: uuid$1,
+            description: "Get token pair",
+            method: HttpMethod.POST,
+            url: "/api/token/",
+            payload: credentials,
+            isAuthNeeded: false,
+            blockers: [],
+            blocks: []
+          });
+          return [responsePromise.then(parseTokens), uuid$1];
+        } catch (e) {
           if (logoutOnFailure) {
             void this.logout().then();
           }
           throw e;
-        });
-        return [responsePromise, uuid$1];
+        }
       });
       /**
        * Takes refresh token and gets a new token pair
@@ -5228,7 +5191,7 @@ var __publicField = (obj, key, value) => {
           timedOut = true;
           store.dispatch(markForDeletion(uuid$1));
           store.dispatch(markForDeletion(initialDataUuid));
-          reject(new APIError({ message: `Request timed out after ${timeout} seconds` }));
+          reject(new Error(`Request timed out after ${timeout} seconds`));
         }, timeout * 1e3);
       });
       const successPromise = promise.then((tokens) => {
@@ -7197,7 +7160,8 @@ var __publicField = (obj, key, value) => {
         blockers: [],
         blocks: []
       });
-      store.dispatch(setOrganizationAccesses(result));
+      const organizationAccesses = result;
+      store.dispatch(setOrganizationAccesses(organizationAccesses));
     }
   }
   const cachedRequestPromises = {};
@@ -7226,7 +7190,12 @@ var __publicField = (obj, key, value) => {
         description: "Get S3 URL",
         method: HttpMethod.GET,
         url: "/authentication/files/presigned-upload-url/",
-        queryParams: { key, type: file.type },
+        queryParams: {
+          sha1: await hashFile(file),
+          file_type: file.type,
+          extension: file.name.split(".").pop(),
+          size: file.size.toString()
+        },
         blockers: [],
         blocks: [`s3-${key}`]
       });