@ynput/ayon-frontend-shared 0.2.2 → 0.2.4

package/dist/node_modules/@reduxjs/toolkit/dist/query/rtk-query.modern.es.js

@@ -1,5 +1,6 @@
 import { isPlainObject, nanoid, formatProdErrorMessage, createAction, createSelector, createNextState, createAsyncThunk, createSlice, prepareAutoBatched, isAnyOf, isFulfilled, isRejectedWithValue, combineReducers, SHOULD_AUTOBATCH, isAllOf, isRejected, isPending, isAction, isAsyncThunkAction } from "@reduxjs/toolkit";
 import { enablePatches, applyPatches, isDraftable, produceWithPatches, isDraft, original } from "../../../../immer/dist/immer.es.js";
+import { SchemaError } from "../../../../@standard-schema/utils/dist/index.es.js";
 import { weakMapMemoize } from "../../../../reselect/dist/reselect.es.js";
 var QueryStatus = /* @__PURE__ */ ((QueryStatus2) => {
   QueryStatus2["uninitialized"] = "uninitialized";
@@ -257,6 +258,9 @@ function isMutationDefinition(e) {
 function isInfiniteQueryDefinition(e) {
   return e.type === "infinitequery";
 }
+function isAnyQueryDefinition(e) {
+  return isQueryDefinition(e) || isInfiniteQueryDefinition(e);
+}
 function calculateProvidedBy(description, result, error, queryArg, meta, assertTagTypes) {
   if (isFunction(description)) {
     return description(result, error, queryArg, meta).filter(isNotNullish).map(expandTagDescription).map(assertTagTypes);
@@ -518,6 +522,21 @@ You must add the middleware for RTK-Query to function correctly!`);
     };
   }
 }
+var NamedSchemaError = class extends SchemaError {
+  constructor(issues, value, schemaName, _bqMeta) {
+    super(issues);
+    this.value = value;
+    this.schemaName = schemaName;
+    this._bqMeta = _bqMeta;
+  }
+};
+async function parseWithSchema(schema, data, schemaName, bqMeta) {
+  const result = await schema["~standard"].validate(data);
+  if (result.issues) {
+    throw new NamedSchemaError(result.issues, data, schemaName, bqMeta);
+  }
+  return result.value;
+}
 function defaultTransformResponse(baseQueryReturnValue) {
   return baseQueryReturnValue;
 }
@@ -536,7 +555,10 @@ function buildThunks({
   serializeQueryArgs,
   api,
   assertTagType,
-  selectors
+  selectors,
+  onSchemaFailure,
+  catchSchemaFailure: globalCatchSchemaFailure,
+  skipSchemaValidation: globalSkipSchemaValidation
 }) {
   const patchQueryData = (endpointName, arg, patches, updateProvided) => (dispatch, getState) => {
     const endpointDefinition = endpointDefinitions[endpointName];
@@ -557,10 +579,10 @@ function buildThunks({
       getState()
     );
     const providedTags = calculateProvidedBy(endpointDefinition.providesTags, newValue.data, void 0, arg, {}, assertTagType);
-    dispatch(api.internalActions.updateProvidedBy({
+    dispatch(api.internalActions.updateProvidedBy([{
       queryCacheKey,
       providedTags
-    }));
+    }]));
   };
   function addToStart(items, item, max = 0) {
     const newItems = [item, ...items];
@@ -633,8 +655,12 @@ function buildThunks({
     getState,
     extra
   }) => {
-    var _a;
+    var _a, _b;
     const endpointDefinition = endpointDefinitions[arg.endpointName];
+    const {
+      metaSchema,
+      skipSchemaValidation = globalSkipSchemaValidation
+    } = endpointDefinition;
     try {
       let transformResponse = getTransformCallbackForEndpoint(endpointDefinition, "transformResponse");
       const baseQueryApi = {
@@ -666,14 +692,27 @@ function buildThunks({
           data: {
             pages: addTo(data.pages, pageResponse.data, maxPages),
             pageParams: addTo(data.pageParams, param, maxPages)
-          }
+          },
+          meta: pageResponse.meta
         };
       };
       async function executeRequest(finalQueryArg) {
         let result;
         const {
-          extraOptions
+          extraOptions,
+          argSchema,
+          rawResponseSchema,
+          responseSchema
         } = endpointDefinition;
+        if (argSchema && !skipSchemaValidation) {
+          finalQueryArg = await parseWithSchema(
+            argSchema,
+            finalQueryArg,
+            "argSchema",
+            {}
+            // we don't have a meta yet, so we can't pass it
+          );
+        }
         if (forceQueryFn) {
           result = forceQueryFn();
         } else if (endpointDefinition.query) {
@@ -708,7 +747,16 @@ function buildThunks({
           }
         }
         if (result.error) throw new HandledError(result.error, result.meta);
-        const transformedResponse = await transformResponse(result.data, result.meta, finalQueryArg);
+        let {
+          data
+        } = result;
+        if (rawResponseSchema && !skipSchemaValidation) {
+          data = await parseWithSchema(rawResponseSchema, result.data, "rawResponseSchema", result.meta);
+        }
+        let transformedResponse = await transformResponse(data, result.meta, finalQueryArg);
+        if (responseSchema && !skipSchemaValidation) {
+          transformedResponse = await parseWithSchema(responseSchema, transformedResponse, "responseSchema", result.meta);
+        }
         return {
           ...result,
           data: transformedResponse
@@ -759,29 +807,72 @@ function buildThunks({
       } else {
         finalQueryReturnValue = await executeRequest(arg.originalArgs);
       }
+      if (metaSchema && !skipSchemaValidation && finalQueryReturnValue.meta) {
+        finalQueryReturnValue.meta = await parseWithSchema(metaSchema, finalQueryReturnValue.meta, "metaSchema", finalQueryReturnValue.meta);
+      }
       return fulfillWithValue(finalQueryReturnValue.data, addShouldAutoBatch({
         fulfilledTimeStamp: Date.now(),
         baseQueryMeta: finalQueryReturnValue.meta
       }));
     } catch (error) {
-      let catchedError = error;
-      if (catchedError instanceof HandledError) {
+      let caughtError = error;
+      if (caughtError instanceof HandledError) {
         let transformErrorResponse = getTransformCallbackForEndpoint(endpointDefinition, "transformErrorResponse");
+        const {
+          rawErrorResponseSchema,
+          errorResponseSchema
+        } = endpointDefinition;
+        let {
+          value,
+          meta
+        } = caughtError;
         try {
-          return rejectWithValue(await transformErrorResponse(catchedError.value, catchedError.meta, arg.originalArgs), addShouldAutoBatch({
-            baseQueryMeta: catchedError.meta
+          if (rawErrorResponseSchema && !skipSchemaValidation) {
+            value = await parseWithSchema(rawErrorResponseSchema, value, "rawErrorResponseSchema", meta);
+          }
+          if (metaSchema && !skipSchemaValidation) {
+            meta = await parseWithSchema(metaSchema, meta, "metaSchema", meta);
+          }
+          let transformedErrorResponse = await transformErrorResponse(value, meta, arg.originalArgs);
+          if (errorResponseSchema && !skipSchemaValidation) {
+            transformedErrorResponse = await parseWithSchema(errorResponseSchema, transformedErrorResponse, "errorResponseSchema", meta);
+          }
+          return rejectWithValue(transformedErrorResponse, addShouldAutoBatch({
+            baseQueryMeta: meta
           }));
         } catch (e) {
-          catchedError = e;
+          caughtError = e;
+        }
+      }
+      try {
+        if (caughtError instanceof NamedSchemaError) {
+          const info = {
+            endpoint: arg.endpointName,
+            arg: arg.originalArgs,
+            type: arg.type,
+            queryCacheKey: arg.type === "query" ? arg.queryCacheKey : void 0
+          };
+          (_b = endpointDefinition.onSchemaFailure) == null ? void 0 : _b.call(endpointDefinition, caughtError, info);
+          onSchemaFailure == null ? void 0 : onSchemaFailure(caughtError, info);
+          const {
+            catchSchemaFailure = globalCatchSchemaFailure
+          } = endpointDefinition;
+          if (catchSchemaFailure) {
+            return rejectWithValue(catchSchemaFailure(caughtError, info), addShouldAutoBatch({
+              baseQueryMeta: caughtError._bqMeta
+            }));
+          }
         }
+      } catch (e) {
+        caughtError = e;
       }
       if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
         console.error(`An unhandled error occurred processing a request for the endpoint "${arg.endpointName}".
-In the case of an unhandled error, no tags will be "provided" or "invalidated".`, catchedError);
+In the case of an unhandled error, no tags will be "provided" or "invalidated".`, caughtError);
       } else {
-        console.error(catchedError);
+        console.error(caughtError);
       }
-      throw catchedError;
+      throw caughtError;
     }
   };
   function isForcedQuery(arg, state) {
@@ -1218,34 +1309,33 @@ function buildSlice({
       });
     }
   });
+  const initialInvalidationState = {
+    tags: {},
+    keys: {}
+  };
   const invalidationSlice = createSlice({
     name: `${reducerPath}/invalidation`,
-    initialState,
+    initialState: initialInvalidationState,
     reducers: {
       updateProvidedBy: {
         reducer(draft, action) {
-          var _a, _b;
-          const {
+          var _a, _b, _c;
+          for (const {
             queryCacheKey,
             providedTags
-          } = action.payload;
-          for (const tagTypeSubscriptions of Object.values(draft)) {
-            for (const idSubscriptions of Object.values(tagTypeSubscriptions)) {
-              const foundAt = idSubscriptions.indexOf(queryCacheKey);
-              if (foundAt !== -1) {
-                idSubscriptions.splice(foundAt, 1);
+          } of action.payload) {
+            removeCacheKeyFromTags(draft, queryCacheKey);
+            for (const {
+              type,
+              id
+            } of providedTags) {
+              const subscribedQueries = (_b = (_a = draft.tags)[type] ?? (_a[type] = {}))[_c = id || "__internal_without_id"] ?? (_b[_c] = []);
+              const alreadySubscribed = subscribedQueries.includes(queryCacheKey);
+              if (!alreadySubscribed) {
+                subscribedQueries.push(queryCacheKey);
               }
             }
-          }
-          for (const {
-            type,
-            id
-          } of providedTags) {
-            const subscribedQueries = (_a = draft[type] ?? (draft[type] = {}))[_b = id || "__internal_without_id"] ?? (_a[_b] = []);
-            const alreadySubscribed = subscribedQueries.includes(queryCacheKey);
-            if (!alreadySubscribed) {
-              subscribedQueries.push(queryCacheKey);
-            }
+            draft.keys[queryCacheKey] = providedTags;
           }
         },
         prepare: prepareAutoBatched()
@@ -1257,22 +1347,15 @@ function buildSlice({
           queryCacheKey
         }
       }) => {
-        for (const tagTypeSubscriptions of Object.values(draft)) {
-          for (const idSubscriptions of Object.values(tagTypeSubscriptions)) {
-            const foundAt = idSubscriptions.indexOf(queryCacheKey);
-            if (foundAt !== -1) {
-              idSubscriptions.splice(foundAt, 1);
-            }
-          }
-        }
+        removeCacheKeyFromTags(draft, queryCacheKey);
       }).addMatcher(hasRehydrationInfo, (draft, action) => {
-        var _a, _b;
+        var _a, _b, _c;
         const {
           provided
         } = extractRehydrationInfo(action);
         for (const [type, incomingTags] of Object.entries(provided)) {
           for (const [id, cacheKeys] of Object.entries(incomingTags)) {
-            const subscribedQueries = (_a = draft[type] ?? (draft[type] = {}))[_b = id || "__internal_without_id"] ?? (_a[_b] = []);
+            const subscribedQueries = (_b = (_a = draft.tags)[type] ?? (_a[type] = {}))[_c = id || "__internal_without_id"] ?? (_b[_c] = []);
             for (const queryCacheKey of cacheKeys) {
               const alreadySubscribed = subscribedQueries.includes(queryCacheKey);
               if (!alreadySubscribed) {
@@ -1282,35 +1365,51 @@ function buildSlice({
           }
         }
       }).addMatcher(isAnyOf(isFulfilled(queryThunk), isRejectedWithValue(queryThunk)), (draft, action) => {
-        writeProvidedTagsForQuery(draft, action);
+        writeProvidedTagsForQueries(draft, [action]);
       }).addMatcher(querySlice.actions.cacheEntriesUpserted.match, (draft, action) => {
-        for (const {
-          queryDescription: arg,
+        const mockActions = action.payload.map(({
+          queryDescription,
           value
-        } of action.payload) {
-          const action2 = {
+        }) => {
+          return {
             type: "UNKNOWN",
             payload: value,
             meta: {
               requestStatus: "fulfilled",
               requestId: "UNKNOWN",
-              arg
+              arg: queryDescription
             }
           };
-          writeProvidedTagsForQuery(draft, action2);
-        }
+        });
+        writeProvidedTagsForQueries(draft, mockActions);
       });
     }
   });
-  function writeProvidedTagsForQuery(draft, action) {
-    const providedTags = calculateProvidedByThunk(action, "providesTags", definitions, assertTagType);
-    const {
-      queryCacheKey
-    } = action.meta.arg;
-    invalidationSlice.caseReducers.updateProvidedBy(draft, invalidationSlice.actions.updateProvidedBy({
-      queryCacheKey,
-      providedTags
-    }));
+  function removeCacheKeyFromTags(draft, queryCacheKey) {
+    var _a;
+    const existingTags = draft.keys[queryCacheKey] ?? [];
+    for (const tag of existingTags) {
+      const tagType = tag.type;
+      const tagId = tag.id ?? "__internal_without_id";
+      const tagSubscriptions = (_a = draft.tags[tagType]) == null ? void 0 : _a[tagId];
+      if (tagSubscriptions) {
+        draft.tags[tagType][tagId] = tagSubscriptions.filter((qc) => qc !== queryCacheKey);
+      }
+    }
+    delete draft.keys[queryCacheKey];
+  }
+  function writeProvidedTagsForQueries(draft, actions2) {
+    const providedByEntries = actions2.map((action) => {
+      const providedTags = calculateProvidedByThunk(action, "providesTags", definitions, assertTagType);
+      const {
+        queryCacheKey
+      } = action.meta.arg;
+      return {
+        queryCacheKey,
+        providedTags
+      };
+    });
+    invalidationSlice.caseReducers.updateProvidedBy(draft, invalidationSlice.actions.updateProvidedBy(providedByEntries));
   }
   const subscriptionSlice = createSlice({
     name: `${reducerPath}/subscriptions`,
@@ -1513,7 +1612,7 @@ function buildSelectors({
     const apiState = state[reducerPath];
     const toInvalidate = /* @__PURE__ */ new Set();
     for (const tag of tags.filter(isNotNullish).map(expandTagDescription)) {
-      const provided = apiState.provided[tag.type];
+      const provided = apiState.provided.tags[tag.type];
       if (!provided) {
         continue;
       }
@@ -2023,14 +2122,14 @@ var buildCacheLifecycleHandler = ({
     cacheDataLoaded.catch(() => {
     });
     lifecycleMap[queryCacheKey] = lifecycle;
-    const selector = api.endpoints[endpointName].select(endpointDefinition.type === "query" ? originalArgs : queryCacheKey);
+    const selector = api.endpoints[endpointName].select(isAnyQueryDefinition(endpointDefinition) ? originalArgs : queryCacheKey);
     const extra = mwApi.dispatch((_, __, extra2) => extra2);
     const lifecycleApi = {
       ...mwApi,
       getCacheEntry: () => selector(mwApi.getState()),
       requestId,
       extra,
-      updateCachedData: endpointDefinition.type === "query" ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
+      updateCachedData: isAnyQueryDefinition(endpointDefinition) ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
       cacheDataLoaded,
       cacheEntryRemoved
     };
@@ -2272,14 +2371,14 @@ var buildQueryLifecycleHandler = ({
         queryFulfilled.catch(() => {
         });
         lifecycleMap[requestId] = lifecycle;
-        const selector = api.endpoints[endpointName].select(endpointDefinition.type === "query" ? originalArgs : requestId);
+        const selector = api.endpoints[endpointName].select(isAnyQueryDefinition(endpointDefinition) ? originalArgs : requestId);
         const extra = mwApi.dispatch((_, __, extra2) => extra2);
         const lifecycleApi = {
           ...mwApi,
           getCacheEntry: () => selector(mwApi.getState()),
           requestId,
           extra,
-          updateCachedData: endpointDefinition.type === "query" ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
+          updateCachedData: isAnyQueryDefinition(endpointDefinition) ? (updateRecipe) => mwApi.dispatch(api.util.updateQueryData(endpointName, originalArgs, updateRecipe)) : void 0,
           queryFulfilled
         };
         onQueryStarted(originalArgs, lifecycleApi);
@@ -2439,7 +2538,10 @@ var coreModule = ({
     refetchOnMountOrArgChange,
     refetchOnFocus,
     refetchOnReconnect,
-    invalidationBehavior
+    invalidationBehavior,
+    onSchemaFailure,
+    catchSchemaFailure,
+    skipSchemaValidation
   }, context) {
     enablePatches();
     const assertTagType = (tag) => {
@@ -2493,7 +2595,10 @@ var coreModule = ({
       api,
       serializeQueryArgs,
       assertTagType,
-      selectors
+      selectors,
+      onSchemaFailure,
+      catchSchemaFailure,
+      skipSchemaValidation
     });
     const {
       reducer,
@@ -2596,6 +2701,7 @@ var coreModule = ({
 });
 /* @__PURE__ */ buildCreateApi(coreModule());
 export {
+  NamedSchemaError,
   QueryStatus,
   buildCreateApi,
   copyWithStructuralSharing,