mobx-tanstack-query-api 0.25.0 → 0.26.1

package/index.js

@@ -1,2 +1,768 @@
-export * from '@tanstack/query-core';
-export * from "./runtime/index.js";
+import { hashKey } from "@tanstack/query-core";
+export * from "@tanstack/query-core";
+import { callFunction } from "yummies/common";
+import { makeObservable, observable, runInAction, comparer, computed, reaction, action } from "mobx";
+import { Query, InfiniteQuery, Mutation, QueryClient } from "mobx-tanstack-query";
+import { getMobxAdministration, lazyObserve } from "yummies/mobx";
+import { stringify } from "qs";
+class EndpointQuery extends Query {
+  constructor(endpoint, inputQueryClient, queryOptionsInput) {
+    const isQueryOptionsInputFn = typeof queryOptionsInput === "function";
+    const unpackedQueryOptionsInput = isQueryOptionsInputFn ? queryOptionsInput() : queryOptionsInput;
+    const {
+      uniqKey,
+      transform: transformResponse,
+      params,
+      queryClient: overridedQueryClient,
+      ...queryOptions
+    } = unpackedQueryOptionsInput;
+    const queryClient = overridedQueryClient ?? inputQueryClient;
+    const _observableData = {
+      params: null,
+      dynamicOptions: void 0,
+      response: null,
+      uniqKey: unpackedQueryOptionsInput.uniqKey
+    };
+    if (!isQueryOptionsInputFn && typeof params !== "function") {
+      if ("params" in unpackedQueryOptionsInput) {
+        _observableData.params = params;
+      } else {
+        _observableData.params = {};
+      }
+      _observableData.initialized = true;
+    }
+    makeObservable(_observableData, {
+      params: observable.ref,
+      response: observable.ref,
+      dynamicOptions: observable
+    });
+    super({
+      ...queryOptions,
+      queryClient,
+      meta: endpoint.toQueryMeta(queryOptions.meta),
+      options: () => {
+        const builtOptions = buildOptionsFromParams(
+          endpoint,
+          _observableData.params,
+          _observableData.uniqKey
+        );
+        let isEnabled = !!_observableData.initialized && builtOptions.enabled;
+        if (typeof queryOptionsInput !== "function" && queryOptionsInput.enabled === false) {
+          isEnabled = false;
+        }
+        return {
+          ...builtOptions,
+          enabled: isEnabled,
+          ..._observableData.dynamicOptions
+        };
+      },
+      queryFn: async (ctx) => {
+        const params2 = endpoint.getParamsFromContext(ctx);
+        runInAction(() => {
+          _observableData.response = null;
+          if (!comparer.structural(params2, _observableData.params)) {
+            _observableData.params = params2;
+          }
+        });
+        let requestParams = params2.requestParams;
+        if (requestParams) {
+          if (!requestParams.signal) {
+            requestParams.signal = ctx.signal;
+          }
+        } else {
+          requestParams = { signal: ctx.signal };
+        }
+        const fixedInput = {
+          ...params2,
+          requestParams
+        };
+        const response = await endpoint.request(fixedInput);
+        runInAction(() => {
+          _observableData.response = response;
+        });
+        return await transformResponse?.(response) ?? response.data;
+      }
+    });
+    this.endpoint = endpoint;
+    const parentAtom = getMobxAdministration(this);
+    computed.struct(this, "params");
+    computed.struct(this, "response");
+    makeObservable(this);
+    if (isQueryOptionsInputFn || typeof params === "function") {
+      const createParamsReaction = () => reaction(
+        () => {
+          let outDynamicOptions;
+          let outParams;
+          let uniqKey2;
+          if (isQueryOptionsInputFn) {
+            const result = queryOptionsInput();
+            const {
+              params: params2,
+              abortSignal,
+              select,
+              onDone,
+              onError,
+              onInit,
+              enableOnDemand,
+              uniqKey: _uniqKey,
+              ...dynamicOptions
+            } = result;
+            uniqKey2 = _uniqKey;
+            if ("params" in result) {
+              outParams = result.params;
+            } else {
+              outParams = {};
+            }
+            outDynamicOptions = Object.keys(dynamicOptions).length > 0 ? dynamicOptions : void 0;
+          } else if ("params" in unpackedQueryOptionsInput) {
+            outParams = unpackedQueryOptionsInput.params;
+            uniqKey2 = unpackedQueryOptionsInput.uniqKey;
+          } else {
+            outParams = {};
+            uniqKey2 = unpackedQueryOptionsInput.uniqKey;
+          }
+          return {
+            params: callFunction(outParams),
+            dynamicOptions: outDynamicOptions,
+            uniqKey: uniqKey2
+          };
+        },
+        ({ params: params2, dynamicOptions, uniqKey: uniqKey2 }) => {
+          runInAction(() => {
+            _observableData.initialized = true;
+            _observableData.params = params2;
+            _observableData.dynamicOptions = dynamicOptions;
+            _observableData.uniqKey = uniqKey2;
+          });
+        },
+        {
+          fireImmediately: true
+        }
+      );
+      if (this.features.lazy) {
+        lazyObserve({
+          property: parentAtom.values_.get("_result"),
+          onStart: createParamsReaction,
+          onEnd: (disposeFn) => disposeFn()
+        });
+      } else {
+        this.abortController.signal.addEventListener(
+          "abort",
+          createParamsReaction()
+        );
+      }
+    }
+    this._observableData = _observableData;
+  }
+  _observableData;
+  get params() {
+    return this._observableData.params;
+  }
+  get response() {
+    return this._observableData.response;
+  }
+  update(updateParams) {
+    if ("params" in updateParams) {
+      const { params, ...options } = updateParams;
+      runInAction(() => {
+        this._observableData.params = params;
+      });
+      return super.update({
+        ...buildOptionsFromParams(
+          this.endpoint,
+          params,
+          this._observableData.uniqKey
+        ),
+        ...options
+      });
+    } else if (this._observableData) {
+      return super.update({
+        ...buildOptionsFromParams(
+          this.endpoint,
+          this._observableData.params,
+          this._observableData.uniqKey
+        ),
+        ...updateParams
+      });
+    } else {
+      return super.update(updateParams);
+    }
+  }
+  refetch(options) {
+    if (this.params) {
+      return super.refetch(options);
+    }
+    return Promise.resolve(this.queryObserver.getCurrentResult());
+  }
+  async start(params) {
+    runInAction(() => {
+      this._observableData.params = params;
+    });
+    return await super.start(
+      buildOptionsFromParams(
+        this.endpoint,
+        params,
+        this._observableData.uniqKey
+      )
+    );
+  }
+  handleDestroy() {
+    super.handleDestroy();
+    runInAction(() => {
+      this._observableData.params = void 0;
+      this._observableData.dynamicOptions = void 0;
+    });
+  }
+}
+const getParamsFromContext = (ctx) => {
+  return ctx.queryKey.at(-2) || {};
+};
+const buildOptionsFromParams = (endpoint, params, uniqKey) => {
+  const { requiredParams } = endpoint.configuration;
+  let hasRequiredParams = false;
+  if (requiredParams.length > 0) {
+    hasRequiredParams = !!params && requiredParams.every((param) => param in params);
+  } else {
+    hasRequiredParams = !!params;
+  }
+  return {
+    enabled: hasRequiredParams,
+    queryKey: endpoint.toQueryKey(params || {}, uniqKey)
+  };
+};
+class EndpointInfiniteQuery extends InfiniteQuery {
+  constructor(endpoint, queryClient, queryOptionsInput) {
+    const {
+      uniqKey,
+      transform: transformResponse,
+      params: paramsFn,
+      ...queryOptions
+    } = typeof queryOptionsInput === "function" ? queryOptionsInput() : queryOptionsInput;
+    super({
+      ...queryOptions,
+      queryClient,
+      meta: endpoint.toQueryMeta(queryOptions.meta),
+      options: (query) => {
+        const extraOptions = {};
+        let willEnableManually;
+        let params;
+        const pageParam = query.options.initialPageParam;
+        if (typeof queryOptionsInput === "function") {
+          Object.assign(extraOptions, queryOptionsInput());
+          params = paramsFn(pageParam);
+          willEnableManually = false;
+        } else {
+          willEnableManually = queryOptionsInput.enabled === false;
+          params = paramsFn(pageParam);
+        }
+        const builtOptions = buildOptionsFromParams(endpoint, params, uniqKey);
+        let isEnabled = false;
+        if (willEnableManually) ;
+        else {
+          isEnabled = builtOptions.enabled;
+        }
+        return {
+          ...query.options,
+          ...builtOptions,
+          // ...dynamicOuterOptions,
+          enabled: isEnabled,
+          ...extraOptions
+        };
+      },
+      queryFn: async (ctx) => {
+        const params = paramsFn(
+          ctx.pageParam ?? queryOptions.initialPageParam
+        );
+        runInAction(() => {
+          this.response = null;
+          this.params = params;
+        });
+        let requestParams = params.request;
+        if (requestParams) {
+          if (!requestParams.signal) {
+            requestParams.signal = ctx.signal;
+          }
+        } else {
+          requestParams = { signal: ctx.signal };
+        }
+        const fixedInput = {
+          ...params,
+          request: requestParams
+        };
+        const response = await endpoint.request(fixedInput);
+        runInAction(() => {
+          this.response = response;
+        });
+        return await transformResponse?.(response) ?? response.data;
+      }
+    });
+    this.endpoint = endpoint;
+    this.paramsFn = paramsFn;
+    this.uniqKey = uniqKey;
+    observable.ref(this, "response");
+    observable.ref(this, "params");
+    makeObservable(this);
+  }
+  response = null;
+  params = null;
+  uniqKey;
+  paramsFn;
+  update({
+    params,
+    ...options
+  }) {
+    return super.update({
+      ...buildOptionsFromParams(this.endpoint, params, this.uniqKey),
+      ...options
+    });
+  }
+  async start(params) {
+    return await super.start(
+      buildOptionsFromParams(this.endpoint, params, this.uniqKey)
+    );
+  }
+}
+class EndpointMutation extends Mutation {
+  constructor(endpoint, inputQueryClient, {
+    transform: transformResponse,
+    invalidateEndpoints,
+    queryClient: overridedQueryClient,
+    ...mutationOptions
+  }) {
+    const queryClient = overridedQueryClient ?? inputQueryClient;
+    super({
+      ...mutationOptions,
+      queryClient,
+      onSuccess: (data, variables, onMutateResult, context) => {
+        mutationOptions.onSuccess?.(data, variables, onMutateResult, context);
+        if (invalidateEndpoints) {
+          if (typeof invalidateEndpoints === "object") {
+            queryClient.invalidateEndpoints(invalidateEndpoints);
+          } else {
+            let filters;
+            switch (`${invalidateEndpoints}`) {
+              case "true": {
+                filters = endpoint.group ? {
+                  group: endpoint.group
+                } : {
+                  tag: endpoint.tags
+                };
+                break;
+              }
+              case "by-group": {
+                filters = {
+                  group: endpoint.group
+                };
+                break;
+              }
+              case "by-tag": {
+                filters = {
+                  tag: endpoint.tags
+                };
+                break;
+              }
+            }
+            if (filters) {
+              queryClient.invalidateEndpoints(filters);
+            }
+          }
+        }
+      },
+      mutationFn: async (input, context) => {
+        let requestParams = input?.requestParams;
+        if (requestParams) {
+          if (!requestParams.signal) {
+            requestParams.signal = context.signal;
+          }
+        } else {
+          requestParams = { signal: context.signal };
+        }
+        const fixedInput = {
+          ...input,
+          requestParams
+        };
+        const response = await endpoint.request(fixedInput);
+        return await transformResponse?.(response) ?? response.data;
+      }
+    });
+    this.endpoint = endpoint;
+  }
+}
+class Endpoint {
+  constructor(configuration, queryClient, httpClient) {
+    this.configuration = configuration;
+    this.queryClient = queryClient;
+    this.httpClient = httpClient;
+    this.endpointId = globalThis.crypto.randomUUID();
+    this.meta = configuration.meta ?? {};
+    const instance = this;
+    const callable = function(...args) {
+      return instance.request.apply(instance, args);
+    };
+    Object.setPrototypeOf(callable, new.target.prototype);
+    Object.getOwnPropertyNames(instance).concat(Object.getOwnPropertyNames(new.target.prototype)).forEach((key) => {
+      if (key === "constructor") return;
+      const desc = Object.getOwnPropertyDescriptor(instance, key) || Object.getOwnPropertyDescriptor(new.target.prototype, key);
+      if (desc) Object.defineProperty(callable, key, desc);
+    });
+    return callable;
+  }
+  endpointId;
+  presets = {
+    mutations: {}
+  };
+  __params;
+  __response;
+  meta;
+  getFullUrl(...args) {
+    const params = this.configuration.params(args[0] ?? {});
+    return this.httpClient.buildUrl(params);
+  }
+  getPath(...args) {
+    const params = this.configuration.params(args[0] ?? {});
+    return params.path;
+  }
+  getParamsFromContext(ctx) {
+    return ctx.queryKey.at(-2) || {};
+  }
+  get tags() {
+    return this.configuration.tags;
+  }
+  get path() {
+    return this.configuration.path;
+  }
+  get pathDeclaration() {
+    return this.path.join("/");
+  }
+  get operationId() {
+    return this.configuration.operationId;
+  }
+  get group() {
+    return this.configuration.group;
+  }
+  get namespace() {
+    return this.configuration.namespace;
+  }
+  request(...args) {
+    return this.httpClient.request(
+      this.configuration.params(args[0] ?? {}),
+      this
+    );
+  }
+  toQueryMeta = (meta) => ({
+    ...meta,
+    tags: this.tags,
+    operationId: this.operationId,
+    path: this.path,
+    pathDeclaration: this.pathDeclaration,
+    endpointId: this.endpointId,
+    endpointQuery: true
+  });
+  toQueryKey(params, uniqKey) {
+    return [
+      ...this.configuration.path,
+      this.configuration.operationId,
+      params ?? {},
+      callFunction(uniqKey)
+    ];
+  }
+  toInfiniteQueryKey(params, uniqKey) {
+    return [
+      { infiniteQuery: true },
+      ...this.configuration.path,
+      this.configuration.operationId,
+      params ?? {},
+      callFunction(uniqKey)
+    ];
+  }
+  invalidateQuery(...args) {
+    this.queryClient.invalidateQueries(
+      {
+        queryKey: this.toQueryKey(args[0], args[1]?.uniqKey),
+        exact: true,
+        ...args[1]
+      },
+      args[2]
+    );
+  }
+  toMutation(options) {
+    return new EndpointMutation(
+      this,
+      this.queryClient,
+      {
+        ...options,
+        invalidateEndpoints: options.invalidateEndpoints ?? this.presets.mutations?.invalidateQueries
+      }
+    );
+  }
+  toQuery(options) {
+    return new EndpointQuery(
+      this,
+      this.queryClient,
+      options
+    );
+  }
+  toInfiniteQuery(options) {
+    return new EndpointInfiniteQuery(
+      this,
+      this.queryClient,
+      options
+    );
+  }
+}
+class EndpointQueryClient extends QueryClient {
+  constructor(config) {
+    super({
+      ...config,
+      defaultOptions: {
+        ...config?.defaultOptions,
+        queries: {
+          ...config?.defaultOptions?.queries,
+          queryKeyHashFn: config?.defaultOptions?.queries?.queryKeyHashFn ?? hashKey
+        }
+      }
+    });
+  }
+  invalidateEndpoints({
+    group,
+    namespace,
+    operationId,
+    tag,
+    predicate,
+    endpoint,
+    ...queryFilters
+  }, options) {
+    let endpointIdsToFilter;
+    if (Array.isArray(endpoint)) {
+      endpointIdsToFilter = new Set(endpoint.map((it) => it.endpointId));
+    } else if (endpoint) {
+      endpointIdsToFilter = /* @__PURE__ */ new Set([endpoint.endpointId]);
+    }
+    return this.invalidateQueries(
+      {
+        ...queryFilters,
+        predicate: (query) => {
+          if (!query.meta?.endpointQuery) {
+            return false;
+          }
+          const meta = query.meta;
+          if (endpointIdsToFilter && !endpointIdsToFilter.has(meta.endpointId)) {
+            return false;
+          }
+          if (namespace && meta.namespace && !applyStringFilter(namespace, meta.namespace)) {
+            return false;
+          }
+          if (group && meta.group && !applyStringFilter(group, meta.group)) {
+            return false;
+          }
+          if (tag && meta.tags && !applyStringFilter(tag, meta.tags)) {
+            return false;
+          }
+          if (tag && meta.tags && !applyStringFilter(tag, meta.tags)) {
+            return false;
+          }
+          if (operationId && !applyStringFilter(operationId, meta.operationId)) {
+            return false;
+          }
+          if (predicate && !predicate(meta, query)) {
+            return false;
+          }
+          return true;
+        }
+      },
+      options
+    );
+  }
+}
+const applyStringFilter = (filter, value) => {
+  const values = Array.isArray(value) ? value : [value];
+  if (filter instanceof RegExp) {
+    return values.some((value2) => filter.test(value2));
+  }
+  if (Array.isArray(filter)) {
+    return filter.some((filter2) => values.includes(filter2));
+  }
+  return values.includes(filter);
+};
+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);
+};
+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, raw, url, params) {
+    const response = raw;
+    response.request = {
+      url,
+      params
+    };
+    response.data = null;
+    response.error = null;
+    if (responseFormat) {
+      try {
+        const formatted = await response[responseFormat]();
+        if (response.ok) {
+          response.data = formatted;
+        } else {
+          response.error = formatted;
+        }
+      } catch (error) {
+        if (response.ok) {
+          response.error = error;
+        } else {
+          response.error = null;
+        }
+      }
+    }
+    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 = "application/json",
+      format = "json",
+      ...params
+    } = fullParams;
+    let requestParams = this.mergeRequestParams(params);
+    if (this.config.interceptor) {
+      requestParams = await this.config.interceptor(requestParams, this.meta, endpoint) ?? requestParams;
+    }
+    const payloadFormatter = this.contentFormatters[contentType];
+    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);
+    }
+    if (!headers.has("Content-Type")) {
+      headers.set("Content-Type", contentType);
+    }
+    const fetchUrl = url;
+    const fetchParams = {
+      ...requestParams,
+      headers,
+      body: body == null ? null : payloadFormatter(body)
+    };
+    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 {
+  Endpoint,
+  EndpointMutation,
+  EndpointQuery,
+  EndpointQueryClient,
+  HttpClient,
+  buildOptionsFromParams,
+  getParamsFromContext,
+  isHttpBadResponse,
+  isHttpResponse
+};
+//# sourceMappingURL=index.js.map