Function cascadeInvalidation

Parameters

• ctx: CascadeContext
• OptionalstoreApi: Omit<
      Omit<StoreApi<GraphState>, "subscribe"> & {
          subscribe: {
              (
                  listener: (
                      selectedState: GraphState,
                      previousSelectedState: GraphState,
                  ) => void,
              ): () => void;
              <U>(
                  selector: (state: GraphState) => U,
                  listener: (selectedState: U, previousSelectedState: U) => void,
                  options?: {
                      equalityFn?: (a: U, b: U) => boolean;
                      fireImmediately?: boolean;
                  },
              ): () => void;
          };
      },
      "setState",
  > & {
      setState(
          nextStateOrUpdater:
              | GraphState
              | Partial<GraphState>
              | (
                  (
                      state: {
                          appendListResult: (
                              key: string,
                              ids: string[],
                              meta: Partial<
                                  Omit<
                                      ListState,
                                      "ids"
                                      | "isFetching"
                                      | "isFetchingMore"
                                      | "error"
                                      | "stale",
                                  >,
                              >,
                          ) => void;
                          clearEntitySyncMetadata: (type: string, id: string) => void;
                          clearPatch: (type: string, id: string) => void;
                          entities: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                          entityStates: {
                              [x: string]: {
                                  error: string | null;
                                  isFetching: boolean;
                                  lastFetched: number | null;
                                  stale: boolean;
                              };
                          };
                          ingestFetchedList: (
                              type: string,
                              entries: { data: Record<string, unknown>; id: string }[],
                              options?: IngestFetchedListOptions,
                          ) => void;
                          insertIdInList: (
                              key: string,
                              id: string,
                              position: number | "end" | "start",
                          ) => void;
                          invalidateEntity: (type: string, id?: string) => void;
                          invalidateLists: (
                              matcher: string | ((key: string) => boolean),
                          ) => void;
                          invalidateType: (type: string) => void;
                          lists: {
                              [x: string]: {
                                  currentPage: number | null;
                                  error: string | null;
                                  hasNextPage: boolean;
                                  hasPrevPage: boolean;
                                  ids: string[];
                                  isFetching: boolean;
                                  isFetchingMore: boolean;
                                  lastError:
                                      | {
                                          cause?: unknown;
                                          kind: "terminal";
                                          message: string;
                                          name: string;
                                          stack?: (...)
                                          | (...);
                                          status?: (...) | (...);
                                      }
                                      | {
                                          cause?: unknown;
                                          kind: "transient";
                                          message: string;
                                          name: string;
                                          stack?: (...)
                                          | (...);
                                          status?: (...) | (...);
                                      }
                                      | null;
                                  lastFetched: number
                                  | null;
                                  nextCursor: string | null;
                                  pageSize: number | null;
                                  prevCursor: string | null;
                                  stale: boolean;
                                  total: number | null;
                              };
                          };
                          patchEntity: (
                              type: string,
                              id: string,
                              patch: Record<string, unknown>,
                          ) => void;
                          patches: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                          prependListResult: (
                              key: string,
                              ids: string[],
                              meta?: Partial<ListState>,
                          ) => void;
                          readEntity: <T = Record<string, unknown>>(
                              type: string,
                              id: string,
                          ) => T | null;
                          readEntitySnapshot: <T = Record<string, unknown>>(
                              type: string,
                              id: string,
                          ) => EntitySnapshot<T & Record<(...), (...)>> | null;
                          removeEntity: (type: string, id: string) => void;
                          removeIdFromAllLists: (type: string, id: string) => void;
                          replaceEntity: (
                              type: string,
                              id: string,
                              data: Record<string, unknown>,
                          ) => void;
                          setEntityError: (
                              type: string,
                              id: string,
                              error: string | null,
                          ) => void;
                          setEntityFetched: (type: string, id: string) => void;
                          setEntityFetching: (
                              type: string,
                              id: string,
                              fetching: boolean,
                          ) => void;
                          setEntityStale: (type: string, id: string, stale: boolean) => void;
                          setEntitySyncMetadata: (
                              type: string,
                              id: string,
                              metadata: Partial<EntitySyncMetadata>,
                          ) => void;
                          setListError: (
                              key: string,
                              error: string | null,
                              typed?: EntityError | null,
                          ) => void;
                          setListFetching: (key: string, fetching: boolean) => void;
                          setListFetchingMore: (key: string, fetchingMore: boolean) => void;
                          setListResult: (
                              key: string,
                              ids: string[],
                              meta: Partial<
                                  Omit<
                                      ListState,
                                      "ids"
                                      | "isFetching"
                                      | "isFetchingMore"
                                      | "error"
                                      | "stale",
                                  >,
                              >,
                          ) => void;
                          setListStale: (key: string, stale: boolean) => void;
                          syncMetadata: {
                              [x: string]: {
                                  origin: SyncOrigin;
                                  synced: boolean;
                                  updatedAt: number | null;
                              };
                          };
                          unpatchEntity: (type: string, id: string, keys: string[]) => void;
                          upsertEntities: (
                              type: string,
                              entries: { data: Record<string, unknown>; id: string }[],
                          ) => void;
                          upsertEntity: (
                              type: string,
                              id: string,
                              data: Record<string, unknown>,
                          ) => void;
                      },
                  ) => void
              ),
          shouldReplace?: false,
      ): void;
      setState(
          nextStateOrUpdater:
              | GraphState
              | (
                  (
                      state: {
                          appendListResult: (
                              key: string,
                              ids: string[],
                              meta: Partial<
                                  Omit<
                                      ListState,
                                      "ids"
                                      | "isFetching"
                                      | "isFetchingMore"
                                      | "error"
                                      | "stale",
                                  >,
                              >,
                          ) => void;
                          clearEntitySyncMetadata: (type: string, id: string) => void;
                          clearPatch: (type: string, id: string) => void;
                          entities: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                          entityStates: {
                              [x: string]: {
                                  error: string | null;
                                  isFetching: boolean;
                                  lastFetched: number | null;
                                  stale: boolean;
                              };
                          };
                          ingestFetchedList: (
                              type: string,
                              entries: { data: Record<string, unknown>; id: string }[],
                              options?: IngestFetchedListOptions,
                          ) => void;
                          insertIdInList: (
                              key: string,
                              id: string,
                              position: number | "end" | "start",
                          ) => void;
                          invalidateEntity: (type: string, id?: string) => void;
                          invalidateLists: (
                              matcher: string | ((key: string) => boolean),
                          ) => void;
                          invalidateType: (type: string) => void;
                          lists: {
                              [x: string]: {
                                  currentPage: number | null;
                                  error: string | null;
                                  hasNextPage: boolean;
                                  hasPrevPage: boolean;
                                  ids: string[];
                                  isFetching: boolean;
                                  isFetchingMore: boolean;
                                  lastError:
                                      | {
                                          cause?: unknown;
                                          kind: "terminal";
                                          message: string;
                                          name: string;
                                          stack?: (...)
                                          | (...);
                                          status?: (...) | (...);
                                      }
                                      | {
                                          cause?: unknown;
                                          kind: "transient";
                                          message: string;
                                          name: string;
                                          stack?: (...)
                                          | (...);
                                          status?: (...) | (...);
                                      }
                                      | null;
                                  lastFetched: number
                                  | null;
                                  nextCursor: string | null;
                                  pageSize: number | null;
                                  prevCursor: string | null;
                                  stale: boolean;
                                  total: number | null;
                              };
                          };
                          patchEntity: (
                              type: string,
                              id: string,
                              patch: Record<string, unknown>,
                          ) => void;
                          patches: { [x: string]: { [x: string]: { [x: string]: unknown } } };
                          prependListResult: (
                              key: string,
                              ids: string[],
                              meta?: Partial<ListState>,
                          ) => void;
                          readEntity: <T = Record<string, unknown>>(
                              type: string,
                              id: string,
                          ) => T | null;
                          readEntitySnapshot: <T = Record<string, unknown>>(
                              type: string,
                              id: string,
                          ) => EntitySnapshot<T & Record<(...), (...)>> | null;
                          removeEntity: (type: string, id: string) => void;
                          removeIdFromAllLists: (type: string, id: string) => void;
                          replaceEntity: (
                              type: string,
                              id: string,
                              data: Record<string, unknown>,
                          ) => void;
                          setEntityError: (
                              type: string,
                              id: string,
                              error: string | null,
                          ) => void;
                          setEntityFetched: (type: string, id: string) => void;
                          setEntityFetching: (
                              type: string,
                              id: string,
                              fetching: boolean,
                          ) => void;
                          setEntityStale: (type: string, id: string, stale: boolean) => void;
                          setEntitySyncMetadata: (
                              type: string,
                              id: string,
                              metadata: Partial<EntitySyncMetadata>,
                          ) => void;
                          setListError: (
                              key: string,
                              error: string | null,
                              typed?: EntityError | null,
                          ) => void;
                          setListFetching: (key: string, fetching: boolean) => void;
                          setListFetchingMore: (key: string, fetchingMore: boolean) => void;
                          setListResult: (
                              key: string,
                              ids: string[],
                              meta: Partial<
                                  Omit<
                                      ListState,
                                      "ids"
                                      | "isFetching"
                                      | "isFetchingMore"
                                      | "error"
                                      | "stale",
                                  >,
                              >,
                          ) => void;
                          setListStale: (key: string, stale: boolean) => void;
                          syncMetadata: {
                              [x: string]: {
                                  origin: SyncOrigin;
                                  synced: boolean;
                                  updatedAt: number | null;
                              };
                          };
                          unpatchEntity: (type: string, id: string, keys: string[]) => void;
                          upsertEntities: (
                              type: string,
                              entries: { data: Record<string, unknown>; id: string }[],
                          ) => void;
                          upsertEntity: (
                              type: string,
                              id: string,
                              data: Record<string, unknown>,
                          ) => void;
                      },
                  ) => void
              ),
          shouldReplace: true,
      ): void;
  }