@wasp.sh/wasp-cli-darwin-x64-unknown 0.20.0

package/data/Generator/templates/sdk/wasp/client/crud/operationsHelpers.ts

@@ -0,0 +1,21 @@
+import { useAction, useQuery } from "../operations"
+import type { Query, Action } from "../operations/rpc"
+import type { Tail } from "../../universal/types"
+
+// PRIVATE API
+export function makeUseQueryFor<Input, Output>(
+  query: Query<Input, Output>
+) {
+  return (
+    ...rest: Tail<Parameters<typeof useQuery<Input, Output>>>
+  ) => useQuery<Input, Output>(query, ...rest);
+}
+
+// PRIVATE API
+export function makeUseActionFor<Input = unknown, Output = unknown>(
+  action: Action<Input, Output>
+) {
+  return (
+    ...rest: Tail<Parameters<typeof useAction<Input, Output>>>
+  ) => useAction<Input, Output>(action, ...rest);
+}

package/data/Generator/templates/sdk/wasp/client/env/schema.ts

@@ -0,0 +1,22 @@
+{{={= =}=}}
+import * as z from 'zod'
+
+{=# envValidationSchema.isDefined =}
+{=& envValidationSchema.importStatement =}
+const userClientEnvSchema = {= envValidationSchema.importIdentifier =}
+{=/ envValidationSchema.isDefined =}
+{=^ envValidationSchema.isDefined =}
+const userClientEnvSchema = z.object({})
+{=/ envValidationSchema.isDefined =}
+
+const waspClientEnvSchema = z.object({
+  "{= serverUrlEnvVarName =}": z
+  .string()
+  .url({
+    message: '{= serverUrlEnvVarName =} must be a valid URL',
+  })
+  .default('{= defaultServerUrl =}'),
+})
+
+// PRIVATE API (sdk, Vite config)
+export const clientEnvSchema = userClientEnvSchema.merge(waspClientEnvSchema)

package/data/Generator/templates/sdk/wasp/client/env.ts

@@ -0,0 +1,5 @@
+import { clientEnvSchema } from './env/schema.js'
+import { ensureEnvSchema } from '../env/validation.js'
+
+// PUBLIC API
+export const env = ensureEnvSchema(import.meta.env, clientEnvSchema)

package/data/Generator/templates/sdk/wasp/client/hooks.ts

@@ -0,0 +1,19 @@
+import { useRef, useEffect } from 'react';
+
+// PRIVATE API (sdk, web-app)
+/**
+ * Hook to avoid running effect twice when using React's `StrictMode` in development mode.
+ * React renders each component twice in development mode to detect potential effect clean up
+ * issues. Wasp relies on some effects triggering only once, for example, OAuth token exchange
+ * or e-mail verification.
+ */
+export function useEffectOnce(callback: () => void) {
+  const hasRun = useRef(false);
+
+  useEffect(() => {
+    if (!hasRun.current) {
+      callback();
+      hasRun.current = true;
+    }
+  }, [callback]);
+}

package/data/Generator/templates/sdk/wasp/client/index.ts

@@ -0,0 +1,17 @@
+// PUBLIC API
+// NOTE: This is enough to cover Operations and our APIs (src/Wasp/AppSpec/Api.hs).
+export enum HttpMethod {
+	Get = 'GET',
+	Post = 'POST',
+	Put = 'PUT',
+	Delete = 'DELETE',
+}
+
+// PUBLIC API
+export type Route = { method: HttpMethod; path: string }
+
+// PUBLIC API
+export { config, ClientConfig } from './config.js'
+
+// PUBLIC API
+export { env } from './env.js'

package/data/Generator/templates/sdk/wasp/client/operations/actions/core.ts

@@ -0,0 +1,49 @@
+import type { _Awaited, _ReturnType } from 'wasp/universal/types'
+import type { OperationRpcFor, GenericBackendOperation } from '../rpc.js'
+import { callOperation, makeOperationRoute } from '../internal/index.js'
+import {
+  registerActionInProgress,
+  registerActionDone,
+} from '../internal/resources.js'
+
+// PRIVATE API
+export function createAction<BackendAction extends GenericBackendOperation>(
+  relativeActionRoute: string,
+  entitiesUsed: unknown[]
+): ActionFor<BackendAction> {
+  const actionRoute = makeOperationRoute(relativeActionRoute)
+
+  async function internalAction(args, specificOptimisticUpdateDefinitions) {
+    registerActionInProgress(specificOptimisticUpdateDefinitions)
+    try {
+      // The `return await` is not redundant here. If we removed the await, the
+      // `finally` block would execute before the action finishes, prematurely
+      // registering the action as done.
+      return await callOperation(actionRoute, args)
+    } finally {
+      await registerActionDone(entitiesUsed, specificOptimisticUpdateDefinitions)
+    }
+  }
+
+  // We expose (and document) a restricted version of the API for our users,
+  // while also attaching the full "internal" API to the exposed action. By
+  // doing this, we can easily use the internal API of an action a users passes
+  // into our system (e.g., through the `useAction` hook) without needing a
+  // lookup table.
+  //
+  // While it does technically allow our users to access the interal API, it
+  // shouldn't be a problem in practice. Still, if it turns out to be a problem,
+  // we can always hide it using a Symbol.
+  const action = (args) => internalAction(args, [])
+  action.internal = internalAction
+
+  // NOTE: I'm not sure why unknown is necessary here,
+  // it might have something to do with functions allowing evolving types,
+  // // while objects to not:
+  // https://www.typescriptlang.org/play/?#code/MYewdgzgLgBCBGArGBeGBvGBDAXDA5AGYgj4wC+AUAogHTyoHxYBO+llA9JzIQK5hgUAJbhsAG3EgA7hGxgYAUwBuIccuFgA5jCgBPAA6KY8PrBqKhMACYhFcsCCiVQkWPwVoAFAEpUAPgJiUkoPekZ8ZjYgA
+  return action as unknown as ActionFor<BackendAction>
+}
+
+// PRIVATE API
+export type ActionFor<BackendAction extends GenericBackendOperation> =
+  OperationRpcFor<BackendAction>

package/data/Generator/templates/sdk/wasp/client/operations/actions/index.ts

@@ -0,0 +1,13 @@
+{{={= =}=}}
+import { type ActionFor, createAction } from './core'
+{=# actions =}
+{=& operationTypeImportStmt =}
+{=/ actions =}
+{=# actions =}
+
+// PUBLIC API
+export const {= operationName =}: ActionFor<{= operationTypeName =}> = createAction<{= operationTypeName =}>(
+  '{= actionRoute =}',
+  {=& entitiesArray =},
+)
+{=/ actions =}

package/data/Generator/templates/sdk/wasp/client/operations/hooks.ts

@@ -0,0 +1,347 @@
+import {
+  QueryClient,
+  QueryKey,
+  useMutation,
+  UseMutationOptions,
+  useQueryClient,
+  useQuery as rqUseQuery,
+  UseQueryResult,
+} from "@tanstack/react-query";
+import { Action, Query } from "./rpc";
+import { makeQueryCacheKey } from "./queries/core";
+export { configureQueryClient } from "./queryClient";
+
+// PUBLIC API
+export function useQuery<Input, Output>(
+  query: Query<Input, Output>,
+  queryFnArgs?: Input,
+  options?: any
+): UseQueryResult<Output, Error> {
+  if (typeof query !== 'function') {
+    throw new TypeError('useQuery requires queryFn to be a function.')
+  }
+
+  if (!query.queryCacheKey) {
+    throw new TypeError('queryFn needs to have queryCacheKey property defined.')
+  }
+
+  return rqUseQuery({
+    // todo: The full queryCacheKey is constructed in two places, both here and
+    // inside the Query. See https://github.com/wasp-lang/wasp/issues/2017
+    // FIXME: query fns don't handle the `undefined` case correctly
+    // https://github.com/wasp-lang/wasp/issues/2017
+    queryKey: makeQueryCacheKey(query, (queryFnArgs as Input)),
+    // FIXME: query fns don't handle the `undefined` case correctly
+    // https://github.com/wasp-lang/wasp/issues/2017
+    queryFn: () => query(queryFnArgs as Input),
+    ...options,
+  })
+}
+
+// PUBLIC API
+/**
+ * A hook for adding extra behavior to a Wasp Action (e.g., optimistic updates).
+ *
+ * @param actionFn The Wasp Action you wish to enhance/decorate.
+ * @param actionOptions An options object for enhancing/decorating the given Action.
+ * @returns A decorated Action with added behavior but an unchanged API.
+ */
+export function useAction<Input = unknown, Output = unknown>(
+  actionFn: Action<Input, Output>,
+  actionOptions?: ActionOptions<Input>
+): typeof actionFn {
+  const queryClient = useQueryClient();
+
+  let mutationFn = actionFn;
+  let options = {};
+  if (actionOptions?.optimisticUpdates) {
+    const optimisticUpdatesDefinitions = actionOptions.optimisticUpdates.map(
+      translateToInternalDefinition
+    );
+    mutationFn = makeOptimisticUpdateMutationFn(
+      actionFn,
+      optimisticUpdatesDefinitions
+    );
+    options = makeRqOptimisticUpdateOptions(
+      queryClient,
+      optimisticUpdatesDefinitions
+    );
+  }
+
+  // NOTE: We decided to hide React Query's extra mutation features (e.g.,
+  // isLoading, onSuccess and onError callbacks, synchronous mutate) and only
+  // expose a simple async function whose API matches the original Action.
+  // We did this to avoid cluttering the API with stuff we're not sure we need
+  // yet (e.g., isLoading), to postpone the action vs mutation dilemma, and to
+  // clearly separate our opinionated API from React Query's lower-level
+  // advanced API (which users can also use)
+  const mutation = useMutation(mutationFn, options);
+
+  // This assertion is necessary because, when the Input is void, we want to
+  // present the function as not accepting a payload (which isn't consistent
+  // with how it's defined).
+  return ((args: Input) => mutation.mutateAsync(args)) as typeof actionFn;
+}
+
+// PUBLIC API
+// todo: Improve this type. Details here:
+// https://github.com/wasp-lang/wasp/issues/2017 
+/**
+ * A documented (public) way to define optimistic updates.
+ */
+export type OptimisticUpdateDefinition<ActionInput, CachedData> = {
+  getQuerySpecifier: GetQuerySpecifier<ActionInput, CachedData>;
+  updateQuery: UpdateQuery<ActionInput, CachedData>;
+};
+
+/**
+ * An options object passed into the `useAction` hook and used to enhance the
+ * action with extra options.
+ *
+ */
+type ActionOptions<ActionInput> = {
+  optimisticUpdates: OptimisticUpdateDefinition<ActionInput, any>[];
+};
+
+/**
+ * A function that takes an item and returns a Wasp Query specifier.
+ */
+type GetQuerySpecifier<ActionInput, CachedData> = (
+  item: ActionInput
+) => QuerySpecifier<unknown, CachedData>;
+
+// todo: Improve the type's signature for when the cache is empty. Details here:
+// https://github.com/wasp-lang/wasp/issues/2017
+/**
+ * A function that takes an item and the previous state of the cache, and returns
+ * the desired (new) state of the cache.
+ */
+type UpdateQuery<ActionInput, CachedData> = (
+  item: ActionInput,
+  oldData: CachedData | undefined
+) => CachedData;
+
+// todo: Improve this type signature. Details here:
+// https://github.com/wasp-lang/wasp/issues/2017
+/**
+ * A public query specifier used for addressing Wasp queries. See our docs for details:
+ * https://wasp.sh/docs/language/features#the-useaction-hook.
+ */
+type QuerySpecifier<Input, Output> = [Query<Input, Output>, ...any[]];
+
+/**
+ * An internal (undocumented, private, desugared) way of defining optimistic updates.
+ */
+type InternalOptimisticUpdateDefinition<ActionInput, CachedData> = {
+  getQueryKey: (item: ActionInput) => QueryKey;
+  updateQuery: UpdateQuery<ActionInput, CachedData>;
+};
+
+/**
+ * An UpdateQuery function "instantiated" with a specific item. It only takes
+ * the current state of the cache and returns the desired (new) state of the
+ * cache.
+ */
+type SpecificUpdateQuery<CachedData> = (oldData: CachedData | undefined) => CachedData;
+
+/**
+ * A specific, "instantiated" optimistic update definition which contains a
+ * fully-constructed query key and a specific update function.
+ */
+type SpecificOptimisticUpdateDefinition<Item> = {
+  queryKey: QueryKey;
+  updateQuery: SpecificUpdateQuery<Item>;
+};
+
+type InternalAction<Input, Output> = Action<Input, Output> & {
+  internal<CachedData extends unknown>(
+    item: Input,
+    optimisticUpdateDefinitions: SpecificOptimisticUpdateDefinition<CachedData>[]
+  ): Promise<Output>;
+};
+
+/**
+ * Translates/Desugars a public optimistic update definition object into a
+ * definition object our system uses internally.
+ *
+ * @param publicOptimisticUpdateDefinition An optimistic update definition
+ * object that's a part of the public API:
+ * https://wasp.sh/docs/language/features#the-useaction-hook.
+ * @returns An internally-used optimistic update definition object.
+ */
+function translateToInternalDefinition<Item, CachedData>(
+  publicOptimisticUpdateDefinition: OptimisticUpdateDefinition<Item, CachedData>
+): InternalOptimisticUpdateDefinition<Item, CachedData> {
+  const { getQuerySpecifier, updateQuery } = publicOptimisticUpdateDefinition;
+
+  const definitionErrors: string[] = [];
+  if (typeof getQuerySpecifier !== "function") {
+    definitionErrors.push("`getQuerySpecifier` is not a function.");
+  }
+  if (typeof updateQuery !== "function") {
+    definitionErrors.push("`updateQuery` is not a function.");
+  }
+  if (definitionErrors.length) {
+    throw new TypeError(
+      `Invalid optimistic update definition: ${definitionErrors.join(", ")}.`
+    );
+  }
+
+  return {
+    getQueryKey: (item) => getRqQueryKeyFromSpecifier(getQuerySpecifier(item)),
+    updateQuery,
+  };
+}
+
+/**
+ * Creates a function that performs an action while telling it about the
+ * optimistic updates it caused.
+ *
+ * @param actionFn The Wasp Action.
+ * @param optimisticUpdateDefinitions The optimisitc updates the action causes.
+ * @returns An decorated action which performs optimistic updates.
+ */
+function makeOptimisticUpdateMutationFn<Input, Output, CachedData>(
+  actionFn: Action<Input, Output>,
+  optimisticUpdateDefinitions: InternalOptimisticUpdateDefinition<
+    Input,
+    CachedData
+  >[]
+): typeof actionFn {
+  return (function performActionWithOptimisticUpdates(item: Input) {
+    const specificOptimisticUpdateDefinitions = optimisticUpdateDefinitions.map(
+      (generalDefinition) =>
+        getOptimisticUpdateDefinitionForSpecificItem(generalDefinition, item)
+    );
+    return (actionFn as InternalAction<Input, Output>).internal(
+      item,
+      specificOptimisticUpdateDefinitions
+    );
+    // This assertion is necessary because, when the Input is void, we want to
+    // present the function as not accepting a payload (which isn't consistent
+    // with how it's defined).
+  }) as typeof actionFn;
+}
+
+/**
+ * Given a ReactQuery query client and our internal definition of optimistic
+ * updates, this function constructs an object describing those same optimistic
+ * updates in a format we can pass into React Query's useMutation hook. In other
+ * words, it translates our optimistic updates definition into React Query's
+ * optimistic updates definition. Check their docs for details:
+ * https://tanstack.com/query/v4/docs/guides/optimistic-updates?from=reactQueryV3&original=https://react-query-v3.tanstack.com/guides/optimistic-updates
+ *
+ * @param queryClient The QueryClient instance used by React Query.
+ * @param optimisticUpdateDefinitions A list containing internal optimistic
+ * updates definition objects (i.e., a list where each object carries the
+ * instructions for performing particular optimistic update).
+ * @returns An object containing 'onMutate' and 'onError' functions
+ * corresponding to the given optimistic update definitions (check the docs
+ * linked above for details).
+ */
+function makeRqOptimisticUpdateOptions<ActionInput, CachedData>(
+  queryClient: QueryClient,
+  optimisticUpdateDefinitions: InternalOptimisticUpdateDefinition<
+    ActionInput,
+    CachedData
+  >[]
+): Pick<UseMutationOptions, "onMutate" | "onError"> {
+  async function onMutate(item) {
+    const specificOptimisticUpdateDefinitions = optimisticUpdateDefinitions.map(
+      (generalDefinition) =>
+        getOptimisticUpdateDefinitionForSpecificItem(generalDefinition, item)
+    );
+
+    // Cancel any outgoing refetches (so they don't overwrite our optimistic update).
+    // Theoretically, we can be a bit faster. Instead of awaiting the
+    // cancellation of all queries, we could cancel and update them in parallel.
+    // However, awaiting cancellation hasn't yet proven to be a performance bottleneck.
+    await Promise.all(
+      specificOptimisticUpdateDefinitions.map(({ queryKey }) =>
+        queryClient.cancelQueries(queryKey)
+      )
+    );
+
+    // We're using a Map to correctly serialize query keys that contain objects.
+    const previousData: Map<QueryKey, CachedData | undefined> = new Map();
+    specificOptimisticUpdateDefinitions.forEach(({ queryKey, updateQuery }) => {
+      // Snapshot the currently cached value.
+      const previousDataForQuery: CachedData | undefined =
+        queryClient.getQueryData(queryKey);
+
+      // Attempt to optimistically update the cache using the new value.
+      try {
+        queryClient.setQueryData(queryKey, updateQuery);
+      } catch (e) {
+        console.error(
+          "The `updateQuery` function threw an exception, skipping optimistic update:"
+        );
+        console.error(e);
+      }
+
+      // Remember the snapshotted value to restore in case of an error.
+      previousData.set(queryKey, previousDataForQuery);
+    });
+
+    return { previousData };
+  }
+
+  function onError(_err, _item, context) {
+    // All we do in case of an error is roll back all optimistic updates. We ensure
+    // not to do anything else because React Query rethrows the error. This allows
+    // the programmer to handle the error as they usually would (i.e., we want the
+    // error handling to work as it would if the programmer wasn't using optimistic
+    // updates).
+    context.previousData.forEach(async (data, queryKey) => {
+      await queryClient.cancelQueries(queryKey);
+      queryClient.setQueryData(queryKey, data);
+    });
+  }
+
+  return {
+    onMutate,
+    onError,
+  };
+}
+
+/**
+ * Constructs the definition for optimistically updating a specific item. It
+ * uses a closure over the updated item to construct an item-specific query key
+ * (e.g., useful when the query key depends on an ID).
+ *
+ * @param optimisticUpdateDefinition The general, "uninstantiated" optimistic
+ * update definition with a function for constructing the query key.
+ * @param item The item triggering the Action/optimistic update (i.e., the
+ * argument passed to the Action).
+ * @returns A specific optimistic update definition which corresponds to the
+ * provided definition and closes over the provided item.
+ */
+function getOptimisticUpdateDefinitionForSpecificItem<ActionInput, CachedData>(
+  optimisticUpdateDefinition: InternalOptimisticUpdateDefinition<
+    ActionInput,
+    CachedData
+  >,
+  item: ActionInput
+): SpecificOptimisticUpdateDefinition<CachedData> {
+  const { getQueryKey, updateQuery } = optimisticUpdateDefinition;
+  return {
+    queryKey: getQueryKey(item),
+    updateQuery: (old) => updateQuery(item, old),
+  };
+}
+
+// todo: Address the duplication between this function and the one in
+// queries/core.ts. Details here: https://github.com/wasp-lang/wasp/issues/2017
+/**
+ * Translates a Wasp query specifier to a query cache key used by React Query.
+ *
+ * @param querySpecifier A query specifier that's a part of the public API:
+ * https://wasp.sh/docs/language/features#the-useaction-hook.
+ * @returns A cache key React Query internally uses for addressing queries.
+ */
+function getRqQueryKeyFromSpecifier(
+  querySpecifier: QuerySpecifier<unknown, unknown>
+): QueryKey {
+  const [queryFn, ...otherKeys] = querySpecifier;
+  return [...(queryFn as any).queryCacheKey, ...otherKeys];
+}

package/data/Generator/templates/sdk/wasp/client/operations/index.ts

@@ -0,0 +1,22 @@
+// PUBLIC API
+export * from './actions'
+// MOSTLY PUBLIC API (see the file for details)
+export * from './queries'
+
+export {
+    // PUBLIC API
+    useAction,
+    // PUBLIC API
+    useQuery,
+    // PUBLIC API
+    type OptimisticUpdateDefinition,
+} from './hooks'
+
+export {
+    // PUBLIC API
+    configureQueryClient,
+    // PRIVATE API (framework code)
+    initializeQueryClient,
+    // PRIVATE API (framework code)
+    queryClientInitialized
+} from './queryClient'

package/data/Generator/templates/sdk/wasp/client/operations/internal/index.ts

@@ -0,0 +1,22 @@
+import { api, handleApiError } from 'wasp/client/api'
+import { HttpMethod } from 'wasp/client'
+import { serialize, deserialize } from 'wasp/core/serialization'
+
+// PRIVATE API
+export type OperationRoute = { method: HttpMethod.Post, path: string }
+
+// PRIVATE API
+export async function callOperation(operationRoute: OperationRoute, args: any) {
+  try {
+    const serializedArgs = serialize(args)
+    const response = await api.post(operationRoute.path, serializedArgs)
+    return deserialize(response.data)
+  } catch (error) {
+    throw handleApiError(error)
+  }
+}
+
+// PRIVATE API
+export function makeOperationRoute(relativeOperationRoute: string): OperationRoute {
+  return { method: HttpMethod.Post, path: `/${relativeOperationRoute}` }
+}

package/data/Generator/templates/sdk/wasp/client/operations/internal/resources.js

@@ -0,0 +1,83 @@
+import { queryClientInitialized } from '../queryClient.js'
+import { makeUpdateHandlersMap } from './updateHandlersMap'
+import { hashQueryKey } from '@tanstack/react-query'
+
+// Map where key is resource name and value is Set
+// containing query ids of all the queries that use
+// that resource.
+const resourceToQueryCacheKeys = new Map()
+
+const updateHandlers = makeUpdateHandlersMap(hashQueryKey)
+
+// PRIVATE API
+/**
+ * Remembers that specified query is using specified resources.
+ * If called multiple times for same query, resources are added, not reset.
+ * @param {string[]} queryCacheKey - Unique key under used to identify query in the cache.
+ * @param {string[]} resources - Names of resources that query is using.
+ */
+export function addResourcesUsedByQuery(queryCacheKey, resources) {
+  for (const resource of resources) {
+    let cacheKeys = resourceToQueryCacheKeys.get(resource)
+    if (!cacheKeys) {
+      cacheKeys = new Set()
+      resourceToQueryCacheKeys.set(resource, cacheKeys)
+    }
+    cacheKeys.add(queryCacheKey)
+  }
+}
+
+export function registerActionInProgress(optimisticUpdateTuples) {
+  optimisticUpdateTuples.forEach(
+    ({ queryKey, updateQuery }) => updateHandlers.add(queryKey, updateQuery)
+  )
+}
+
+export async function registerActionDone(resources, optimisticUpdateTuples) {
+  optimisticUpdateTuples.forEach(({ queryKey }) => updateHandlers.remove(queryKey))
+  await invalidateQueriesUsing(resources)
+}
+
+export function getActiveOptimisticUpdates(queryKey) {
+  return updateHandlers.getUpdateHandlers(queryKey)
+}
+
+export async function invalidateAndRemoveQueries() {
+  const queryClient = await queryClientInitialized
+  // If we don't reset the queries before removing them, Wasp will stay on
+  // the same page. The user would have to manually refresh the page to "finish"
+  // logging out.
+  // When a query is removed, the `Observer` is removed as well, and the components
+  // that are using the query are not re-rendered. This is why we need to reset
+  // the queries, so that the `Observer` is re-created and the components are re-rendered.
+  // For more details: https://github.com/wasp-lang/wasp/pull/1014/files#r1111862125
+  queryClient.resetQueries()
+  // If we don't remove the queries after invalidating them, the old query data
+  // remains in the cache, casuing a potential privacy issue.
+  queryClient.removeQueries()
+}
+
+/**
+ * Invalidates all queries that are using specified resources.
+ * @param {string[]} resources - Names of resources.
+ */
+async function invalidateQueriesUsing(resources) {
+  const queryClient = await queryClientInitialized
+
+  const queryCacheKeysToInvalidate = getQueriesUsingResources(resources)
+  queryCacheKeysToInvalidate.forEach(
+    queryCacheKey => queryClient.invalidateQueries(queryCacheKey)
+  )
+}
+
+/**
+ * @param {string} resource - Resource name.
+ * @returns {string[]} Array of "query cache keys" of queries that use specified resource.
+ */
+function getQueriesUsingResource(resource) {
+  return Array.from(resourceToQueryCacheKeys.get(resource) || [])
+}
+
+function getQueriesUsingResources(resources) {
+  return Array.from(new Set(resources.flatMap(getQueriesUsingResource)))
+}

package/data/Generator/templates/sdk/wasp/client/operations/internal/updateHandlersMap.js

@@ -0,0 +1,37 @@
+export function makeUpdateHandlersMap(calculateHash) {
+  const updateHandlers = new Map()
+
+  function getHandlerTuples(queryKeyHash) {
+    return updateHandlers.get(queryKeyHash) || [];
+  }
+
+  function add(queryKey, updateQuery) {
+    const queryKeyHash = calculateHash(queryKey)
+    const handlers = getHandlerTuples(queryKeyHash);
+    updateHandlers.set(queryKeyHash, [...handlers, { queryKey, updateQuery }])
+  }
+
+  function getUpdateHandlers(queryKey) {
+    const queryKeyHash = calculateHash(queryKey)
+    return getHandlerTuples(queryKeyHash).map(({ updateQuery }) => updateQuery)
+  }
+
+  function remove(queryKeyToRemove) {
+    const queryKeyHash = calculateHash(queryKeyToRemove)
+    const filteredHandlers = getHandlerTuples(queryKeyHash).filter(
+      ({ queryKey }) => queryKey !== queryKeyToRemove
+    )
+
+    if (filteredHandlers.length > 0) {
+      updateHandlers.set(queryKeyHash, filteredHandlers)
+    } else {
+      updateHandlers.delete(queryKeyHash)
+    }
+  }
+
+  return {
+    add,
+    remove,
+    getUpdateHandlers,
+  }
+}