@overmap-ai/core 1.0.60-sdk-refactor.2 → 1.0.60-sdk-refactor.4

package/dist/forms/fields/BaseField/hooks.d.ts

@@ -64,7 +64,7 @@ export declare const useFormikInput: <TField extends AnyField>(props: ComponentP
     readonly results?: number | undefined;
     readonly security?: string | undefined;
     readonly unselectable?: "on" | "off" | undefined;
-    readonly inputMode?: "search" | "text" | "email" | "url" | "none" | "numeric" | "tel" | "decimal" | undefined;
+    readonly inputMode?: "search" | "text" | "email" | "none" | "url" | "numeric" | "tel" | "decimal" | undefined;
     readonly is?: string | undefined;
     readonly "aria-activedescendant"?: string | undefined;
     readonly "aria-atomic"?: (boolean | "true" | "false") | undefined;
@@ -280,10 +280,10 @@ export declare const useFormikInput: <TField extends AnyField>(props: ComponentP
     readonly onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
     readonly onTransitionEnd?: import("react").TransitionEventHandler<HTMLElement> | undefined;
     readonly onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLElement> | undefined;
-    readonly headers?: string | undefined;
-    readonly method?: string | undefined;
     readonly href?: string | undefined;
     readonly download?: any;
+    readonly headers?: string | undefined;
+    readonly method?: string | undefined;
     readonly placeholder?: string | undefined;
     readonly required?: boolean | undefined;
     readonly target?: string | undefined;

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";
@@ -12187,23 +12187,6 @@ class APIError extends Error {
     this.options = options;
   }
 }
-class BaseApiService {
-  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);
-  }
-  dispatch(action) {
-    this.client.store.dispatch(action);
-  }
-}
 var randomString = function randomString2() {
   return Math.random().toString(36).substring(7).split("").join(".");
 };
@@ -13727,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,
@@ -13737,7 +13720,8 @@ const createOfflineAction = (request2, baseUrl) => {
         effect: {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           request: requestWithUuid,
-          BASE_URL: baseUrl
+          BASE_URL: baseUrl,
+          serviceName
         }
       }
     }
@@ -13761,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) {
@@ -15083,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: "",
@@ -15114,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.`);
   }
@@ -15167,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);
@@ -15178,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) });
   }
@@ -15371,6 +15323,104 @@ function retry(_action, _retries) {
   getClientStore().dispatch(_setLatestRetryTime((/* @__PURE__ */ new Date()).getTime()));
   return OUTBOX_RETRY_DELAY;
 }
+class BaseSDK {
+  constructor(store) {
+    __publicField(this, "store");
+    this.store = store;
+  }
+  async enqueueRequest(requestDetails, host, serviceName) {
+    return this._enqueueRequest(requestDetails, host, serviceName).then((result) => {
+      if (result instanceof APIError) {
+        throw result;
+      }
+      return result;
+    });
+  }
+  _enqueueRequest(requestDetails, host, serviceName) {
+    const promise = new DeferredPromise();
+    const requestDetailsWithBaseUrl = { ...requestDetails, BASE_URL: host, serviceName };
+    if (requestDetails.immediate) {
+      const requestWithUuid = {
+        ...requestDetailsWithBaseUrl,
+        uuid: requestDetails.uuid ?? v4()
+      };
+      const fullOfflineAction = {
+        payload: requestWithUuid,
+        type: "",
+        meta: {
+          offline: {
+            effect: {
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              request: requestWithUuid,
+              BASE_URL: host,
+              serviceName
+            }
+          }
+        }
+      };
+      performRequest(fullOfflineAction, this).then((result) => {
+        promise.resolve(result.body);
+      }).catch((error2) => {
+        discard(error2, fullOfflineAction);
+        promise.reject(error2);
+      });
+    } else {
+      const innerPromise = this.store.dispatch(
+        enqueueRequest(requestDetailsWithBaseUrl)
+      );
+      const successOrUndefinedHandler = (response) => {
+        if (response) {
+          promise.resolve(response.body);
+        } else {
+          const error2 = new APIError({
+            message: "Could not get a response from the server.",
+            response,
+            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
+          });
+        }
+        promise.reject(error2);
+      };
+      innerPromise.then(successOrUndefinedHandler, errorHandler);
+    }
+    return promise;
+  }
+  // NOTE: these are currently expected to be present in the base SDK, not sure if that is desired
+}
+const initSDK = (store, sdk) => {
+  const sdkInstance = new sdk(store);
+  setClientSDK(sdkInstance);
+  setClientStore(store);
+  return sdkInstance;
+};
+class BaseAuthService {
+  constructor(sdk) {
+    __publicField(this, "client");
+    this.client = sdk;
+  }
+  async enqueueRequest(requestDetails) {
+    return this.client.enqueueRequest(requestDetails, this.host, this.constructor.name);
+  }
+  dispatch(action) {
+    this.client.store.dispatch(action);
+  }
+}
 const EXPIRING_SOON_THRESHOLD = 1800;
 function parseTokens(response) {
   if (!response.access)
@@ -15379,43 +15429,15 @@ 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, "host", {}.REACT_APP_API_URL);
+    // AUTH below
     __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
@@ -15455,34 +15477,6 @@ 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
    */
@@ -15518,6 +15512,103 @@ class AuthService extends BaseApiService {
       throw e;
     }
   }
+  /**
+   * Checks whether the tokens will be expiring soon
+   * @returns {boolean}
+   */
+  tokenIsExpiringSoon() {
+    const accessToken = this._getAccessToken();
+    if (!accessToken) {
+      return false;
+    }
+    const currentDate = Date.now() / 1e3;
+    let expiryDate;
+    try {
+      expiryDate = jwtDecode(accessToken).exp ?? currentDate;
+    } catch {
+      expiryDate = currentDate;
+    }
+    const secondsUntilExpiry = expiryDate - currentDate;
+    return secondsUntilExpiry < EXPIRING_SOON_THRESHOLD;
+  }
+  getAuthHeader() {
+    const accesseToken = selectAccessToken(this.client.store.getState());
+    return `Bearer ${accesseToken}`;
+  }
+  async prepareAuth() {
+    if (!this.tokenIsExpiringSoon())
+      return;
+    try {
+      await this.renewTokens();
+    } catch (e) {
+      if (e instanceof APIError) {
+        await this.logout();
+      }
+      return Promise.reject(e);
+    }
+  }
+  /* 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.logout();
+      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
+      });
+    }
+  }
+  /**
+   * 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: "/api/token/",
+      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.dispatch(setTokens(tokens));
+      this.dispatch(setLoggedIn(true));
+      this.dispatch({ type: "rehydrated/setRehydrated", payload: true });
+    });
+    return Promise.race([timeoutPromise, successPromise]);
+  }
   /**
    * Register a new user
    */
@@ -15545,25 +15636,6 @@ class AuthService extends BaseApiService {
       blocks: []
     });
   }
-  /**
-   * Checks whether the tokens will be expiring soon
-   * @returns {boolean}
-   */
-  tokenIsExpiringSoon() {
-    const accessToken = this._getAccessToken();
-    if (!accessToken) {
-      return false;
-    }
-    const currentDate = Date.now() / 1e3;
-    let expiryDate;
-    try {
-      expiryDate = jwtDecode(accessToken).exp ?? currentDate;
-    } catch {
-      expiryDate = currentDate;
-    }
-    const secondsUntilExpiry = expiryDate - currentDate;
-    return secondsUntilExpiry < EXPIRING_SOON_THRESHOLD;
-  }
   async replaceProfilePicture(file) {
     const hash = await hashFile(file);
     await this.client.files.addCache(file, hash);
@@ -15613,6 +15685,22 @@ class AuthService extends BaseApiService {
     });
   }
 }
+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 {
   add(category, workspaceId) {
     const offlineCategory = offline(category);
@@ -18011,18 +18099,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}/`,
@@ -18030,8 +18117,7 @@ class EmailVerificationService extends BaseApiService {
       payload,
       blockers: [],
       blocks: []
-    };
-    return this.enqueueRequest(requestDetails);
+    });
   }
 }
 class EmailDomainsService extends BaseApiService {
@@ -18665,103 +18751,6 @@ class TeamService extends BaseApiService {
     this.dispatch(setTeams(result));
   }
 }
-class BaseSDK {
-  constructor(store) {
-    __publicField(this, "store");
-    // NOTE: these are currently expected to be present in the base SDK, not sure if that is desired
-    __publicField(this, "files", new FileService(this));
-    __publicField(this, "auth", new AuthService(this));
-    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) => {
-      if (result instanceof APIError) {
-        throw result;
-      }
-      return result;
-    });
-  }
-  /**
-   * Enqueues an API request to the Redux Offline outbox
-   * @protected
-   */
-  _enqueueRequest(requestDetails, host) {
-    const promise = new DeferredPromise();
-    const requestDetailsWithBaseUrl = { ...requestDetails, BASE_URL: host };
-    if (requestDetails.immediate) {
-      const requestWithUuid = {
-        ...requestDetailsWithBaseUrl,
-        uuid: requestDetails.uuid ?? v4()
-      };
-      const fullOfflineAction = {
-        payload: requestWithUuid,
-        type: "",
-        meta: {
-          offline: {
-            effect: {
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              request: requestWithUuid,
-              BASE_URL: host
-            }
-          }
-        }
-      };
-      performRequest(fullOfflineAction, this).then((result) => {
-        promise.resolve(result.body);
-      }).catch((error2) => {
-        discard(error2, fullOfflineAction);
-        promise.reject(error2);
-      });
-    } else {
-      const innerPromise = this.store.dispatch(
-        enqueueRequest(requestDetailsWithBaseUrl)
-      );
-      const successOrUndefinedHandler = (response) => {
-        if (response) {
-          promise.resolve(response.body);
-        } else {
-          const error2 = new APIError({
-            message: "Could not get a response from the server.",
-            response,
-            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
-          });
-        }
-        promise.reject(error2);
-      };
-      innerPromise.then(successOrUndefinedHandler, errorHandler);
-    }
-    return promise;
-  }
-}
-const initSDK = (store, sdk) => {
-  const sdkInstance = new sdk(store);
-  setClientSDK(sdkInstance);
-  setClientStore(store);
-  return sdkInstance;
-};
 export {
   APIError,
   AgentService,
@@ -18773,13 +18762,13 @@ export {
   AssetTypeAttachmentService,
   AssetTypeService,
   AttachmentModel,
-  AuthService,
   BaseApiService,
   BaseField,
   BaseFormElement,
   BaseSDK,
   BooleanField,
   BooleanInput,
+  CLASS_NAME_TO_SERVICE,
   CategoryService,
   ColorPicker,
   Colors,
@@ -18817,6 +18806,7 @@ export {
   IssueTypeService,
   IssueUpdateChange,
   IssueUpdateService,
+  JWTService,
   LicenseLevel,
   LicenseService,
   LicenseStatus,
@@ -19413,6 +19403,8 @@ export {
   userSlice,
   validateForm,
   valueIsFile,
+  versioningReducer,
+  versioningSlice,
   warningColor,
   workspaceReducer,
   workspaceSlice,