@overmap-ai/core 1.0.60-sdk-refactor.3 → 1.0.60-sdk-refactor.5

package/dist/overmap-core.js

@@ -35,8 +35,8 @@ import createMigration from "redux-persist-migrate";
 import { createSlice, createSelector, combineReducers, createNextState } from "@reduxjs/toolkit";
 import request from "superagent";
 import { shallowEqual as shallowEqual$1 } from "react-redux";
-import jwtDecode from "jwt-decode";
 import { RESET_STATE } from "@redux-offline/redux-offline/lib/constants";
+import jwtDecode from "jwt-decode";
 import { openDB } from "idb";
 var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
   HttpMethod2["GET"] = "GET";
@@ -13710,7 +13710,7 @@ const selectOrganization = (id) => (state) => {
   return state.organizationReducer.organizations[id];
 };
 const organizationReducer = organizationSlice.reducer;
-const createOfflineAction = (request2, baseUrl) => {
+const createOfflineAction = (request2, baseUrl, serviceName) => {
   const requestWithUuid = request2.uuid ? request2 : { ...request2, uuid: v4() };
   return {
     payload: requestWithUuid,
@@ -13720,7 +13720,8 @@ const createOfflineAction = (request2, baseUrl) => {
         effect: {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           request: requestWithUuid,
-          BASE_URL: baseUrl
+          BASE_URL: baseUrl,
+          serviceName
         }
       }
     }
@@ -13744,8 +13745,8 @@ const outboxSlice = createSlice({
       },
       prepare: (payload) => {
         console.debug("Preparing to enqueue request", payload);
-        const { BASE_URL, ...rest } = payload;
-        return createOfflineAction(rest, BASE_URL);
+        const { BASE_URL, serviceName, ...rest } = payload;
+        return createOfflineAction(rest, BASE_URL, serviceName);
       }
     },
     markForDeletion(state, action) {
@@ -15066,24 +15067,16 @@ function extractResponseFromError(error2) {
   return void 0;
 }
 async function performRequest(action, client) {
-  async function checkToken() {
-    if (client.auth.tokenIsExpiringSoon()) {
-      await client.auth.renewTokens();
-    }
+  const serviceOfRequest = CLASS_NAME_TO_SERVICE[action.meta.offline.effect.serviceName];
+  if (!serviceOfRequest) {
+    throw new Error(`Service ${action.meta.offline.effect.serviceName} not found`);
   }
   const state = client.store.getState();
   if (state.outboxReducer.deletedRequests.includes(action.payload.uuid)) {
     throw new Error("Request was marked for deletion");
   }
   if (action.payload.checkAuth !== false) {
-    try {
-      await checkToken();
-    } catch (e) {
-      if (e instanceof APIError) {
-        await client.auth.logout();
-        return Promise.reject(e);
-      }
-    }
+    await serviceOfRequest.auth.prepareAuth();
   }
   const defaultSettings = {
     queryParams: "",
@@ -15097,7 +15090,6 @@ async function performRequest(action, client) {
   const requestDetails = offlineEffect.request;
   let url = requestDetails.url;
   const file = attachmentHash ? await client.files.fetchCache(attachmentHash) : void 0;
-  const accessToken = selectAccessToken(state);
   if (attachmentHash && !file) {
     throw new Error(`Cannot upload file ${attachmentHash} because it's not cached.`);
   }
@@ -15150,7 +15142,8 @@ async function performRequest(action, client) {
   const selectedRequest = methodRequestMapping[method];
   let requestToSend = selectedRequest();
   if (isAuthNeeded) {
-    requestToSend = requestToSend.set("Authorization", `Bearer ${accessToken}`);
+    const authHeader = serviceOfRequest.auth.getAuthHeader();
+    requestToSend = requestToSend.set("Authorization", authHeader);
   }
   if (headers) {
     requestToSend = requestToSend.set(headers);
@@ -15161,32 +15154,8 @@ async function performRequest(action, client) {
     const errorResponse = extractResponseFromError(error2);
     const status = errorResponse == null ? void 0 : errorResponse.status;
     if (status === 401) {
-      if (url.endsWith("/token/refresh/")) {
-        if (state.authReducer.isLoggedIn) {
-          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
-        });
-      }
+      await serviceOfRequest.auth.handleUnauthorized(requestToSend, errorResponse);
+      return requestToSend.query(queryParams);
     }
     throw new APIError({ response: errorResponse, innerError: error2, discard: discardStatuses.includes(status) });
   }
@@ -15359,27 +15328,17 @@ class BaseSDK {
     __publicField(this, "store");
     this.store = store;
   }
-  /**
-   * Enqueues an API request to the offline outbox.
-   * @param requestDetails An SDKRequest object containing the details of the request.
-   * @param host The base URL of the API to send the request to.
-   * @protected
-   */
-  async enqueueRequest(requestDetails, host) {
-    return this._enqueueRequest(requestDetails, host).then((result) => {
+  async enqueueRequest(requestDetails, host, serviceName) {
+    return this._enqueueRequest(requestDetails, host, serviceName).then((result) => {
       if (result instanceof APIError) {
         throw result;
       }
       return result;
     });
   }
-  /**
-   * Enqueues an API request to the Redux Offline outbox
-   * @protected
-   */
-  _enqueueRequest(requestDetails, host) {
+  _enqueueRequest(requestDetails, host, serviceName) {
     const promise = new DeferredPromise();
-    const requestDetailsWithBaseUrl = { ...requestDetails, BASE_URL: host };
+    const requestDetailsWithBaseUrl = { ...requestDetails, BASE_URL: host, serviceName };
     if (requestDetails.immediate) {
       const requestWithUuid = {
         ...requestDetailsWithBaseUrl,
@@ -15393,7 +15352,8 @@ class BaseSDK {
             effect: {
               timestamp: (/* @__PURE__ */ new Date()).toISOString(),
               request: requestWithUuid,
-              BASE_URL: host
+              BASE_URL: host,
+              serviceName
             }
           }
         }
@@ -15449,18 +15409,13 @@ const initSDK = (store, sdk) => {
   setClientStore(store);
   return sdkInstance;
 };
-class BaseApiService {
+class BaseAuthService {
   constructor(sdk) {
     __publicField(this, "client");
     this.client = sdk;
   }
-  /**
-   * Enqueues an API request to the offline outbox.
-   * @param requestDetails An SDKRequest object containing the details of the request.
-   * @protected
-   */
   async enqueueRequest(requestDetails) {
-    return this.client.enqueueRequest(requestDetails, this.host);
+    return this.client.enqueueRequest(requestDetails, this.host, this.constructor.name);
   }
   dispatch(action) {
     this.client.store.dispatch(action);
@@ -15474,42 +15429,12 @@ function parseTokens(response) {
     throw new Error("Missing refresh token");
   return { accessToken: response.access, refreshToken: response.refresh };
 }
-class AuthService extends BaseApiService {
+class JWTService extends BaseAuthService {
   constructor() {
     super(...arguments);
-    __publicField(this, "_getAccessToken", () => this.client.store.getState().authReducer.accessToken);
-    __publicField(this, "_getRefreshToken", () => this.client.store.getState().authReducer.refreshToken);
     // _getTokenPair and _getRenewedTokens don't need to use enqueueRequest from the BaseApiService because
     // they are very simple. However, if we need robust error handling or want these operations to queue in the Outbox,
     // we will use enqueueRequest.
-    /**
-     * Takes credentials and gets a token pair
-     * @async
-     * @param credentials The username and password for obtaining a token pair
-     * @param logoutOnFailure Whether to log out if the request fails
-     * @returns An array containing two elements: 1) a Promise for the access and refresh tokens, and 2) the UUID of the
-     * request, so the request can be cancelled if necessary.
-     */
-    __publicField(this, "_getTokenPair", (credentials, logoutOnFailure = true) => {
-      const uuid = v4();
-      const responsePromise = this.enqueueRequest({
-        uuid,
-        description: "Get token pair",
-        method: HttpMethod.POST,
-        url: "/api/token/",
-        payload: credentials,
-        isAuthNeeded: false,
-        checkAuth: false,
-        blockers: [],
-        blocks: []
-      }).then(parseTokens).catch((e) => {
-        if (logoutOnFailure) {
-          void this.logout().then();
-        }
-        throw e;
-      });
-      return [responsePromise, uuid];
-    });
     /**
      * Takes refresh token and gets a new token pair
      * @async
@@ -15520,7 +15445,7 @@ class AuthService extends BaseApiService {
       const promise = this.enqueueRequest({
         description: "Get renewed tokens",
         method: HttpMethod.POST,
-        url: "/api/token/refresh/",
+        url: this.refreshTokensUrl,
         payload: { refresh: refreshToken },
         isAuthNeeded: false,
         blockers: [],
@@ -15531,14 +15456,14 @@ class AuthService extends BaseApiService {
         immediate: true
       }).catch((e) => {
         console.error("Could not renew tokens; logging out due to error:", e);
-        void this.logout();
+        void this.clearAuth();
         return void 0;
       });
       let response = void 0;
       try {
         response = await promise;
       } catch (e) {
-        await this.logout();
+        await this.clearAuth();
       }
       if (!response)
         return void 0;
@@ -15549,40 +15474,12 @@ class AuthService extends BaseApiService {
       return { accessToken: response.access, refreshToken: response.refresh };
     });
   }
-  /**
-   * Attempts to log into Hemora using given credentials
-   * @param {string} username
-   * @param {string} password
-   */
-  async login(username, password) {
-    const [promise, uuid] = this._getTokenPair({ username, password }, false);
-    const initialDataUuid = v4();
-    const timeout = 5;
-    let timedOut = false;
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        timedOut = true;
-        this.dispatch(markForDeletion(uuid));
-        this.dispatch(markForDeletion(initialDataUuid));
-        reject(new APIError({ message: `Request timed out after ${timeout} seconds` }));
-      }, timeout * 1e3);
-    });
-    const successPromise = promise.then((tokens) => {
-      if (timedOut) {
-        return void 0;
-      }
-      this.dispatch(setTokens(tokens));
-      this.dispatch(setLoggedIn(true));
-      this.dispatch({ type: "rehydrated/setRehydrated", payload: true });
-    });
-    return Promise.race([timeoutPromise, successPromise]);
-  }
   /**
    * Logs the user out
    */
-  async logout() {
+  async clearAuth() {
     this.dispatch(setLoggedIn(false));
-    this.dispatch(clearTokens());
+    this.clearTokens();
     this.dispatch(setActiveProjectId(null));
     this.dispatch(setActiveWorkspaceId(null));
     this.dispatch({ type: RESET_STATE });
@@ -15594,7 +15491,7 @@ class AuthService extends BaseApiService {
    * Attempts to renew tokens
    */
   async renewTokens() {
-    const dyingRefreshToken = this._getRefreshToken();
+    const dyingRefreshToken = this.getRefreshToken();
     if (!dyingRefreshToken) {
       throw new Error("No refresh token found");
     }
@@ -15603,48 +15500,20 @@ class AuthService extends BaseApiService {
       if (!tokens) {
         return void 0;
       }
-      const { accessToken, refreshToken } = tokens;
       console.log("Got renewed tokens");
-      this.dispatch(setTokens({ accessToken, refreshToken }));
+      this.setTokens(tokens);
     } catch (e) {
       console.error("Could not renew tokens; logging out.");
-      await this.logout();
+      await this.clearAuth();
       throw e;
     }
   }
-  /**
-   * Register a new user
-   */
-  register(payload) {
-    return this.enqueueRequest({
-      description: "Register",
-      method: HttpMethod.POST,
-      url: "/authentication/users/register/",
-      isAuthNeeded: false,
-      payload,
-      blockers: [],
-      blocks: []
-    });
-  }
-  async resetPassword(email) {
-    return this.enqueueRequest({
-      description: "Reset password",
-      method: HttpMethod.PATCH,
-      url: "/authentication/users/reset-password/",
-      isAuthNeeded: false,
-      payload: {
-        email
-      },
-      blockers: [],
-      blocks: []
-    });
-  }
   /**
    * Checks whether the tokens will be expiring soon
    * @returns {boolean}
    */
   tokenIsExpiringSoon() {
-    const accessToken = this._getAccessToken();
+    const accessToken = this.getAccessToken();
     if (!accessToken) {
       return false;
     }
@@ -15658,53 +15527,99 @@ class AuthService extends BaseApiService {
     const secondsUntilExpiry = expiryDate - currentDate;
     return secondsUntilExpiry < EXPIRING_SOON_THRESHOLD;
   }
-  async replaceProfilePicture(file) {
-    const hash = await hashFile(file);
-    await this.client.files.addCache(file, hash);
-    const [fileProps] = await this.client.files.uploadFileToS3(hash);
-    this.dispatch(setProfilePicture({ file: `/files/${fileProps.file}`, file_sha1: hash }));
-    return this.enqueueRequest({
-      description: "Replace profile picture",
-      method: HttpMethod.PATCH,
-      url: "/authentication/users/profile-details/",
-      payload: fileProps,
-      blockers: [],
-      blocks: []
-    });
+  getAuthHeader() {
+    const accesseToken = selectAccessToken(this.client.store.getState());
+    return `Bearer ${accesseToken}`;
   }
-  async addFavouriteProjectId(projectId) {
-    this.dispatch(addFavouriteProjectId(projectId));
-    return this.enqueueRequest({
-      description: "Add favourite project",
-      method: HttpMethod.POST,
-      url: `/authentication/users/favourite-project/${projectId}/`,
-      blockers: [],
-      blocks: []
-    });
+  async prepareAuth() {
+    if (!this.tokenIsExpiringSoon())
+      return;
+    try {
+      await this.renewTokens();
+    } catch (e) {
+      if (e instanceof APIError) {
+        await this.clearAuth();
+      }
+      return Promise.reject(e);
+    }
   }
-  async removeFavouriteProjectId(projectId) {
-    this.dispatch(removeFavouriteProjectId(projectId));
-    return this.enqueueRequest({
-      description: "Add favourite project",
-      method: HttpMethod.POST,
-      url: `/authentication/users/unfavourite-project/${projectId}/`,
-      blockers: [`favorite-project-${projectId}`],
-      blocks: [`favorite-project-${projectId}`]
-    });
+  /* if not successfull in gracefully handling an unauthorized response, throw and APIError */
+  async handleUnauthorized(request2, response) {
+    const state = this.client.store.getState();
+    if (request2.url.endsWith("/token/refresh/")) {
+      if (state.authReducer.isLoggedIn) {
+        console.warn("No signed-in user to sign out.");
+      }
+      await this.clearAuth();
+      throw new APIError({
+        message: "You have been signed out due to inactivity.",
+        response,
+        discard: true
+      });
+    }
+    if (state.authReducer.isLoggedIn) {
+      await this.renewTokens();
+    } else {
+      console.debug("Forbidden; user is not logged in.");
+      throw new APIError({
+        message: "Incorrect username or password.",
+        response,
+        discard: true
+      });
+    }
   }
-  async joinApplication(projectInviteId, verification_code, username, password) {
-    return this.enqueueRequest({
-      description: "Join application",
-      method: HttpMethod.PATCH,
-      url: `/authentication/join-app/${projectInviteId}/${verification_code}/`,
-      payload: {
-        username,
-        password
-      },
+  /**
+   * Attempts to log into Hemora using given credentials
+   * @param {string} username
+   * @param {string} password
+   */
+  async initAuth(username, password) {
+    const uuid = v4();
+    const promise = this.enqueueRequest({
+      uuid,
+      description: "Get token pair",
+      method: HttpMethod.POST,
+      url: this.initTokensUrl,
+      payload: { username, password },
       isAuthNeeded: false,
+      checkAuth: false,
       blockers: [],
       blocks: []
+    }).then(parseTokens);
+    const timeout = 5;
+    let timedOut = false;
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        timedOut = true;
+        this.dispatch(markForDeletion(uuid));
+        reject(new APIError({ message: `Request timed out after ${timeout} seconds` }));
+      }, timeout * 1e3);
+    });
+    const successPromise = promise.then((tokens) => {
+      if (timedOut) {
+        return void 0;
+      }
+      this.setTokens(tokens);
+      this.dispatch(setLoggedIn(true));
+      this.dispatch({ type: "rehydrated/setRehydrated", payload: true });
     });
+    return Promise.race([timeoutPromise, successPromise]);
+  }
+}
+const CLASS_NAME_TO_SERVICE = {};
+class BaseApiService {
+  constructor(sdk, auth) {
+    __publicField(this, "client");
+    __publicField(this, "auth");
+    CLASS_NAME_TO_SERVICE[this.constructor.name] = this;
+    this.client = sdk;
+    this.auth = auth;
+  }
+  async enqueueRequest(requestDetails) {
+    return this.client.enqueueRequest(requestDetails, this.host, this.constructor.name);
+  }
+  dispatch(action) {
+    this.client.store.dispatch(action);
   }
 }
 class CategoryService extends BaseApiService {
@@ -18105,18 +18020,17 @@ class FileService extends BaseApiService {
 }
 class EmailVerificationService extends BaseApiService {
   async getVerificationCode(verificationCode) {
-    const requestDetails = {
+    return this.enqueueRequest({
       description: "Get verification code",
       method: HttpMethod.GET,
       url: `/verification/email-verification/${verificationCode}/`,
       isAuthNeeded: false,
       blockers: [],
       blocks: []
-    };
-    return this.enqueueRequest(requestDetails);
+    });
   }
   validateVerificationCode(verificationCode, payload = void 0) {
-    const requestDetails = {
+    return this.enqueueRequest({
       description: "Validate verification code",
       method: HttpMethod.POST,
       url: `/verification/email-verification/${verificationCode}/`,
@@ -18124,8 +18038,7 @@ class EmailVerificationService extends BaseApiService {
       payload,
       blockers: [],
       blocks: []
-    };
-    return this.enqueueRequest(requestDetails);
+    });
   }
 }
 class EmailDomainsService extends BaseApiService {
@@ -18770,13 +18683,13 @@ export {
   AssetTypeAttachmentService,
   AssetTypeService,
   AttachmentModel,
-  AuthService,
   BaseApiService,
   BaseField,
   BaseFormElement,
   BaseSDK,
   BooleanField,
   BooleanInput,
+  CLASS_NAME_TO_SERVICE,
   CategoryService,
   ColorPicker,
   Colors,
@@ -18814,6 +18727,7 @@ export {
   IssueTypeService,
   IssueUpdateChange,
   IssueUpdateService,
+  JWTService,
   LicenseLevel,
   LicenseService,
   LicenseStatus,
@@ -19410,6 +19324,8 @@ export {
   userSlice,
   validateForm,
   valueIsFile,
+  versioningReducer,
+  versioningSlice,
   warningColor,
   workspaceReducer,
   workspaceSlice,