mobx-tanstack-query-api 0.33.0 → 0.34.0

package/index.js

@@ -6,6 +6,11 @@ import { Query, InfiniteQuery, Mutation, QueryClient } from "mobx-tanstack-query
 import { getMobxAdministration, lazyObserve } from "yummies/mobx";
 import { stringify } from "qs";
 class EndpointQuery extends Query {
+  /**
+   * Creates `EndpointQuery` instance.
+   *
+   * [**Documentation**](https://js2me.github.io/mobx-tanstack-query-api/endpoint-queries/#constructor)
+   */
   constructor(endpoint, inputQueryClient, queryOptionsInput) {
     const isQueryOptionsInputFn = typeof queryOptionsInput === "function";
     const unpackedQueryOptionsInput = isQueryOptionsInputFn ? queryOptionsInput() : queryOptionsInput;
@@ -155,12 +160,27 @@ class EndpointQuery extends Query {
     this._observableData = _observableData;
   }
   _observableData;
+  /**
+   * Current endpoint params used by this query.
+   *
+   * [**Documentation**](https://js2me.github.io/mobx-tanstack-query-api/endpoint-queries/#params)
+   */
   get params() {
     return this._observableData.params;
   }
+  /**
+   * Last raw HTTP response returned by endpoint.
+   *
+   * [**Documentation**](https://js2me.github.io/mobx-tanstack-query-api/endpoint-queries/#response)
+   */
   get response() {
     return this._observableData.response;
   }
+  /**
+   * Updates query options and optionally params.
+   *
+   * [**Documentation**](https://js2me.github.io/mobx-tanstack-query-api/endpoint-queries/#update)
+   */
   update(updateParams) {
     if ("params" in updateParams) {
       const { params, ...options } = updateParams;
@@ -188,12 +208,22 @@ class EndpointQuery extends Query {
       return super.update(updateParams);
     }
   }
+  /**
+   * Refetches query when params are initialized.
+   *
+   * [**Documentation**](https://js2me.github.io/mobx-tanstack-query-api/endpoint-queries/#refetch)
+   */
   refetch(options) {
     if (this.params) {
       return super.refetch(options);
     }
     return Promise.resolve(this.queryObserver.getCurrentResult());
   }
+  /**
+   * Sets params and starts query execution.
+   *
+   * [**Documentation**](https://js2me.github.io/mobx-tanstack-query-api/endpoint-queries/#start)
+   */
   async start(params) {
     runInAction(() => {
       this._observableData.params = params;
@@ -323,6 +353,11 @@ class EndpointInfiniteQuery extends InfiniteQuery {
   }
 }
 class EndpointMutation extends Mutation {
+  /**
+   * Creates `EndpointMutation` instance.
+   *
+   * [**Documentation**](https://js2me.github.io/mobx-tanstack-query-api/endpoint-mutations/#constructor)
+   */
   constructor(endpoint, inputQueryClient, {
     transform: transformResponse,
     invalidateEndpoints,
@@ -385,199 +420,67 @@ class EndpointMutation extends Mutation {
         return await transformResponse?.(response) ?? response.data;
       }
     });
-    this.endpoint = endpoint;
   }
 }
-const ContentType = {
-  Json: "application/json",
-  FormData: "multipart/form-data",
-  UrlEncoded: "application/x-www-form-urlencoded",
-  Text: "text/plain",
-  Binary: "application/octet-stream"
-};
-const isHttpResponse = (response, status) => !!response && typeof response === "object" && response instanceof Response && "data" in response && (!status || response.status === status);
-const isHttpBadResponse = (response) => {
-  return isHttpResponse(response) && (!response.ok || !!response.error);
-};
 const emptyStatusCodesSet = /* @__PURE__ */ new Set([204, 205, 304]);
-class HttpClient {
-  config;
-  fetch;
-  meta;
-  baseApiParams;
-  badResponse;
-  toQueryString;
-  constructor(config) {
-    this.config = config ?? {};
-    this.badResponse = null;
-    this.meta = config?.meta ?? null;
-    this.fetch = config?.fetch ?? ((...fetchParams) => globalThis.fetch(...fetchParams));
-    this.toQueryString = config?.toQueryString ?? ((query) => stringify(query, config?.queryStringifyOptions));
-    this.baseApiParams = {
-      credentials: "same-origin",
-      headers: {},
-      redirect: "follow",
-      referrerPolicy: "no-referrer"
-    };
-    this.updateConfig(this.config);
-    observable.ref(this, "badResponse");
-    observable.ref(this, "meta");
-    action(this, "setMeta");
-    action(this, "setBadResponse");
-    makeObservable(this);
-  }
-  get baseUrl() {
-    return this.config.baseUrl ?? "";
-  }
-  updateConfig(update) {
-    Object.assign(this.config, update);
-    if (update.baseApiParams) {
-      Object.assign(this.baseApiParams, update.baseApiParams);
-    }
-    if (update.contentFormatters) {
-      Object.assign(this.contentFormatters, update.contentFormatters);
-    }
-    if (update.fetch) {
-      this.fetch = update.fetch;
-    }
-  }
-  setMeta = (data) => {
-    this.meta = data;
-  };
-  setBadResponse = (response) => {
-    this.badResponse = response;
-  };
-  contentFormatters = {
-    "application/json": (input) => input !== null && (typeof input === "object" || typeof input === "string") ? JSON.stringify(input) : input,
-    "text/plain": (input) => input !== null && typeof input !== "string" ? JSON.stringify(input) : input,
-    "multipart/form-data": (input) => Object.keys(input || {}).reduce((formData, key) => {
-      const property = input[key];
-      if (property instanceof Blob) {
-        formData.append(key, property);
-      } else if (typeof property === "object" && property !== null) {
-        formData.append(key, JSON.stringify(property));
-      } else {
-        formData.append(key, `${property}`);
-      }
-      return formData;
-    }, new FormData()),
-    "application/x-www-form-urlencoded": (input) => this.toQueryString(input),
-    "application/octet-stream": (input) => input
-  };
-  mergeRequestParams(params1, params2) {
-    return {
-      ...this.baseApiParams,
-      ...params1,
-      ...params2,
-      headers: {
-        ...this.baseApiParams.headers,
-        ...params1.headers,
-        ...params2?.headers
-      }
-    };
-  }
-  isEmptyResponseBody(response) {
-    if (emptyStatusCodesSet.has(response.status)) {
+class HttpResponse {
+  constructor(originalResponse, request) {
+    this.originalResponse = originalResponse;
+    this.request = request;
+    this.headers = originalResponse.headers;
+    this.ok = originalResponse.ok;
+    this.body = originalResponse.body;
+    this.redirected = originalResponse.redirected;
+    this.status = originalResponse.status;
+    this.statusText = originalResponse.statusText;
+    this.type = originalResponse.type;
+    this.url = originalResponse.url;
+    this.data = null;
+    this.error = null;
+  }
+  headers;
+  ok;
+  redirected;
+  statusText;
+  type;
+  url;
+  body;
+  data;
+  error;
+  status;
+  clone() {
+    return new HttpResponse(this.originalResponse.clone(), this.request);
+  }
+  isEmpty() {
+    if (emptyStatusCodesSet.has(this.status)) {
       return true;
     }
-    const contentLength = response.headers.get("content-length");
+    const contentLength = this.headers.get("content-length");
     if (contentLength !== null && contentLength === "0") {
       return true;
     }
-    if (response.body === null) {
+    if (this.body === null) {
       return true;
     }
     return false;
   }
-  async createResponse(responseFormat = "json", raw, url, params) {
-    const response = raw;
-    response.request = { url, params };
-    response.data = null;
-    response.error = null;
-    if (this.isEmptyResponseBody(response)) {
-      return response;
-    }
+  async resolveBody(responseFormat) {
     try {
-      const formatted = await response[responseFormat]();
-      if (response.ok) {
-        response.data = formatted;
-      } else {
-        response.error = formatted;
-      }
-    } catch (error) {
-      response.error = error;
-    }
-    if (!response.ok || response.error) {
-      this.setBadResponse(response);
-    }
-    return response;
-  }
-  buildUrl = (params) => {
-    const baseUrl = params.baseUrl ?? this.baseUrl ?? "";
-    const path = params.path;
-    const queryString = params.query && this.toQueryString(params.query);
-    const query = queryString ? `?${queryString}` : "";
-    if (this.config.buildUrl) {
-      return this.config.buildUrl(params, { baseUrl, path, query }, this.meta);
-    }
-    const url = baseUrl + path + query;
-    return url;
-  };
-  async request(fullParams, endpoint) {
-    this.setBadResponse(null);
-    const { body, contentType, format, ...params } = fullParams;
-    let requestParams = this.mergeRequestParams(params);
-    if (this.config.interceptor) {
-      requestParams = await this.config.interceptor(requestParams, this.meta, endpoint) ?? requestParams;
-    }
-    const responseFormat = format || requestParams.format;
-    const url = this.buildUrl(fullParams);
-    let headers;
-    if (requestParams.headers instanceof Headers) {
-      headers = requestParams.headers;
-    } else if (Array.isArray(requestParams.headers)) {
-      headers = new Headers(requestParams.headers);
-    } else {
-      headers = new Headers(requestParams.headers);
-    }
-    let bodyToSend;
-    if (contentType) {
-      if (contentType !== ContentType.FormData && !headers.has("Content-Type")) {
-        headers.set("Content-Type", contentType);
-      }
-      const payloadFormatter = this.contentFormatters[contentType];
-      if (body == null) {
-        bodyToSend = null;
-      } else if (payloadFormatter) {
-        bodyToSend = payloadFormatter(body);
+      const formatted = await this.originalResponse[responseFormat]();
+      if (this.ok) {
+        this.data = formatted;
       } else {
-        bodyToSend = body;
+        this.error = formatted;
       }
-    }
-    const fetchUrl = url;
-    const fetchParams = {
-      ...requestParams,
-      headers,
-      body: bodyToSend
-    };
-    let response;
-    try {
-      response = await this.fetch(fetchUrl, fetchParams);
     } catch (error) {
-      response = error;
-    }
-    const httpResponse = await this.createResponse(
-      responseFormat,
-      response,
-      fetchUrl,
-      fetchParams
-    );
-    if (!httpResponse.ok || httpResponse.error) {
-      throw httpResponse;
+      this.error = error;
     }
-    return httpResponse;
   }
 }
+const isHttpResponse = (response, status) => typeof response === "object" && response instanceof HttpResponse && "data" in response && (!status || response.status === status);
+const isHttpBadResponse = (response) => {
+  return isHttpResponse(response) && (!response.ok || !!response.error);
+};
 class Endpoint {
   constructor(configuration, queryClient, httpClient) {
     this.configuration = configuration;
@@ -704,6 +607,11 @@ class Endpoint {
   }
 }
 class EndpointQueryClient extends QueryClient {
+  /**
+   * Creates `EndpointQueryClient` instance.
+   *
+   * [**Documentation**](https://js2me.github.io/mobx-tanstack-query-api/endpoint-query-client/#constructor)
+   */
   constructor(config) {
     super({
       ...config,
@@ -716,6 +624,11 @@ class EndpointQueryClient extends QueryClient {
       }
     });
   }
+  /**
+   * Invalidates endpoint queries by endpoint metadata filters.
+   *
+   * [**Documentation**](https://js2me.github.io/mobx-tanstack-query-api/endpoint-query-client/#invalidateendpoints)
+   */
   invalidateEndpoints({
     group,
     namespace,
@@ -785,6 +698,166 @@ const applyStringFilter = (filter, value) => {
   }
   return values.includes(filter);
 };
+const ContentType = {
+  Json: "application/json",
+  FormData: "multipart/form-data",
+  UrlEncoded: "application/x-www-form-urlencoded",
+  Text: "text/plain",
+  Binary: "application/octet-stream"
+};
+class HttpClient {
+  config;
+  fetch;
+  meta;
+  baseApiParams;
+  badResponse;
+  toQueryString;
+  constructor(config) {
+    this.config = config ?? {};
+    this.badResponse = null;
+    this.meta = config?.meta ?? null;
+    this.fetch = config?.fetch ?? ((...fetchParams) => globalThis.fetch(...fetchParams));
+    this.toQueryString = config?.toQueryString ?? ((query) => stringify(query, config?.queryStringifyOptions));
+    this.baseApiParams = {
+      credentials: "same-origin",
+      headers: {},
+      redirect: "follow",
+      referrerPolicy: "no-referrer"
+    };
+    this.updateConfig(this.config);
+    observable.ref(this, "badResponse");
+    observable.ref(this, "meta");
+    action(this, "setMeta");
+    action(this, "setBadResponse");
+    makeObservable(this);
+  }
+  get baseUrl() {
+    return this.config.baseUrl ?? "";
+  }
+  updateConfig(update) {
+    Object.assign(this.config, update);
+    if (update.baseApiParams) {
+      Object.assign(this.baseApiParams, update.baseApiParams);
+    }
+    if (update.contentFormatters) {
+      Object.assign(this.contentFormatters, update.contentFormatters);
+    }
+    if (update.fetch) {
+      this.fetch = update.fetch;
+    }
+  }
+  setMeta = (data) => {
+    this.meta = data;
+  };
+  setBadResponse = (response) => {
+    this.badResponse = response;
+  };
+  contentFormatters = {
+    "application/json": (input) => input !== null && (typeof input === "object" || typeof input === "string") ? JSON.stringify(input) : input,
+    "text/plain": (input) => input !== null && typeof input !== "string" ? JSON.stringify(input) : input,
+    "multipart/form-data": (input) => Object.keys(input || {}).reduce((formData, key) => {
+      const property = input[key];
+      if (property instanceof Blob) {
+        formData.append(key, property);
+      } else if (typeof property === "object" && property !== null) {
+        formData.append(key, JSON.stringify(property));
+      } else {
+        formData.append(key, `${property}`);
+      }
+      return formData;
+    }, new FormData()),
+    "application/x-www-form-urlencoded": (input) => this.toQueryString(input),
+    "application/octet-stream": (input) => input
+  };
+  mergeRequestParams(params1, params2) {
+    return {
+      ...this.baseApiParams,
+      ...params1,
+      ...params2,
+      headers: {
+        ...this.baseApiParams.headers,
+        ...params1.headers,
+        ...params2?.headers
+      }
+    };
+  }
+  async createResponse(responseFormat = "json", raw, url, params) {
+    const response = new HttpResponse(raw, { url, params });
+    if (response.isEmpty()) {
+      return response;
+    }
+    await response.resolveBody(responseFormat);
+    if (!response.ok || response.error) {
+      this.setBadResponse(response);
+    }
+    return response;
+  }
+  buildUrl = (params) => {
+    const baseUrl = params.baseUrl ?? this.baseUrl ?? "";
+    const path = params.path;
+    const queryString = params.query && this.toQueryString(params.query);
+    const query = queryString ? `?${queryString}` : "";
+    if (this.config.buildUrl) {
+      return this.config.buildUrl(params, { baseUrl, path, query }, this.meta);
+    }
+    const url = baseUrl + path + query;
+    return url;
+  };
+  async request(fullParams, endpoint) {
+    this.setBadResponse(null);
+    const { body, contentType, format, ...params } = fullParams;
+    let requestParams = this.mergeRequestParams(params);
+    if (this.config.interceptor) {
+      requestParams = await this.config.interceptor(requestParams, this.meta, endpoint) ?? requestParams;
+    }
+    const responseFormat = format || requestParams.format;
+    const url = this.buildUrl(fullParams);
+    let headers;
+    if (requestParams.headers instanceof Headers) {
+      headers = requestParams.headers;
+    } else if (Array.isArray(requestParams.headers)) {
+      headers = new Headers(requestParams.headers);
+    } else {
+      headers = new Headers(requestParams.headers);
+    }
+    let bodyToSend;
+    if (contentType) {
+      if (contentType !== ContentType.FormData && !headers.has("Content-Type")) {
+        headers.set("Content-Type", contentType);
+      }
+      const payloadFormatter = this.contentFormatters[contentType];
+      if (body == null) {
+        bodyToSend = null;
+      } else if (payloadFormatter) {
+        bodyToSend = payloadFormatter(body);
+      } else {
+        bodyToSend = body;
+      }
+    }
+    const fetchUrl = url;
+    const fetchParams = {
+      ...requestParams,
+      headers,
+      body: bodyToSend
+    };
+    let response;
+    try {
+      response = await this.fetch(fetchUrl, fetchParams);
+    } catch (error) {
+      response = error;
+    }
+    const httpResponse = await this.createResponse(
+      responseFormat,
+      response,
+      fetchUrl,
+      fetchParams
+    );
+    if (!httpResponse.ok || httpResponse.error) {
+      throw httpResponse;
+    }
+    return httpResponse;
+  }
+}
 export {
   ContentType,
   Endpoint,
@@ -792,6 +865,7 @@ export {
   EndpointQuery,
   EndpointQueryClient,
   HttpClient,
+  HttpResponse,
   buildOptionsFromParams,
   emptyStatusCodesSet,
   getParamsFromContext,