synapse-react-client/dist/synapse-queries/dataaccess/useAccessRequirements.js

[](https://badge.fury.io/js/synapse-react-client) [](https://github.com/prettier/prettie

import { sortAccessRequirementsByCompletion as k } from "../../components/AccessRequirementList/AccessRequirementListUtils.js";
import * as a from "../../synapse-client/SynapseClient.js";
import { deleteAccessRequirementAcl as F, createAccessRequirementAcl as S, updateAccessRequirementAcl as l, updateAccessRequirement as K, createAccessRequirement as g } from "../../synapse-client/SynapseClient.js";
import "@sage-bionetworks/synapse-client/generated/models/ErrorResponseCode";
import "@sage-bionetworks/synapse-client/generated/models/TwoFactorAuthErrorResponse";
import "@sage-bionetworks/synapse-client/util/SynapseClientError";
import "@sage-bionetworks/synapse-types";
import "../../utils/functions/EntityTypeUtils.js";
import "../../utils/SynapseConstants.js";
import "lodash-es";
import "@sage-bionetworks/synapse-client/util/synapseClientFetch";
import "../../utils/PermissionLevelToAccessType.js";
import "react";
import { useSynapseContext as n } from "../../utils/context/SynapseContext.js";
import "use-deep-compare-effect";
import { useQueryClient as y, useMutation as m, useQuery as q, useInfiniteQuery as Q, useQueries as f } from "@tanstack/react-query";
import { getAllActionsRequiredQueryFilters as A } from "../QueryFilterUtils.js";
import "lodash-es/isEmpty";
import "lodash-es/isEqual";
import "lodash-es/xorWith";
import "@sage-bionetworks/synapse-client";
import "../../utils/types/IsType.js";
import "react/jsx-runtime";
import "@mui/material";
import "../../utils/hooks/useCookiePreferences.js";
import "../../utils/hooks/useSourceAppConfigs.js";
import "universal-cookie";
import "../../utils/AppUtils/session/ApplicationSessionContext.js";
import "../../utils/context/FullContextProvider.js";
import "../../utils/context/DocumentMetadataContext.js";
import '../../style/components/_spinner.css';/* empty css                                   */
import "react-router";
function ee(e, r) {
  const { accessToken: c, keyFactory: s } = n();
  return q({
    ...r,
    queryKey: s.getAccessRequirementQueryKey(
      String(e)
    ),
    queryFn: () => a.getAccessRequirementById(
      c,
      e
    )
  });
}
function te(e, r) {
  const { accessToken: c, keyFactory: s } = n();
  return q({
    ...r,
    queryKey: s.getEntityAccessRequirementsQueryKey(e),
    queryFn: () => a.getAllAccessRequirements(c, e)
  });
}
function ce(e, r) {
  const { accessToken: c, keyFactory: s } = n();
  return q({
    ...r,
    queryKey: s.getTeamAccessRequirementsQueryKey(e),
    queryFn: () => a.getTeamAccessRequirements(c, e)
  });
}
function se(e, r) {
  const { accessToken: c, keyFactory: s } = n();
  return q({
    ...r,
    queryKey: s.getAccessRequirementWikiPageKey(e),
    queryFn: () => a.getWikiPageKeyForAccessRequirement(
      c,
      e
    )
  });
}
function re(e) {
  const r = y(), { accessToken: c, keyFactory: s } = n();
  return m({
    ...e,
    mutationFn: (t) => g(c, t),
    onSuccess: async (t, u, i) => {
      const o = s.getAccessRequirementQueryKey(
        t.id.toString()
      );
      if (r.setQueryData(o, t), e?.onSuccess)
        return await e.onSuccess(t, u, i);
    }
  });
}
function ne(e) {
  const r = y(), { accessToken: c, keyFactory: s } = n();
  return m({
    ...e,
    mutationFn: (t) => K(c, t),
    onSuccess: async (t, u, i) => {
      const o = s.getAccessRequirementQueryKey(
        t.id.toString()
      );
      if (r.setQueryData(o, t), e?.onSuccess)
        return await e.onSuccess(t, u, i);
    }
  });
}
function ue(e, r) {
  const { accessToken: c, keyFactory: s } = n();
  return q({
    ...r,
    queryKey: s.getAccessRequirementAclQueryKey(e),
    queryFn: () => a.getAccessRequirementAcl(c, e)
  });
}
function ie(e) {
  const r = y(), { accessToken: c, keyFactory: s } = n();
  return m({
    ...e,
    mutationFn: (t) => F(c, t),
    onSuccess: async (t, u, i) => {
      await r.invalidateQueries({
        queryKey: s.getAccessRequirementAclQueryKey(u)
      }), e?.onSuccess && await e.onSuccess(t, u, i);
    }
  });
}
function ae(e) {
  const r = y(), { accessToken: c, keyFactory: s } = n();
  return m({
    ...e,
    mutationFn: (t) => S(c, t),
    onSuccess: async (t, u, i) => {
      const o = s.getAccessRequirementAclQueryKey(t.id);
      if (r.setQueryData(o, t), e?.onSuccess)
        return await e.onSuccess(t, u, i);
    }
  });
}
function oe(e) {
  const r = y(), { accessToken: c, keyFactory: s } = n();
  return m({
    ...e,
    mutationFn: (t) => l(c, t),
    onSuccess: async (t, u, i) => {
      const o = s.getAccessRequirementAclQueryKey(t.id);
      if (r.setQueryData(o, t), e?.onSuccess)
        return await e.onSuccess(t, u, i);
    }
  });
}
function ye(e, r) {
  const { accessToken: c, keyFactory: s } = n();
  return Q({
    ...r,
    queryKey: s.searchAccessRequirementsQueryKey(e),
    queryFn: async (t) => await a.searchAccessRequirements(c, {
      ...e,
      nextPageToken: t.pageParam
    }),
    initialPageParam: void 0,
    getNextPageParam: (t) => t.nextPageToken
  });
}
function me(e) {
  const { accessToken: r } = n(), c = y(), { keyFactory: s } = n();
  return m({
    ...e,
    mutationFn: (t) => a.createLockAccessRequirement(t, r),
    mutationKey: ["createLockAccessRequirement"],
    onSuccess: async (t, u, i) => {
      if (await Promise.all([
        // Invalidate all access requirement queries
        c.invalidateQueries({
          queryKey: s.getAccessRequirementQueryKey()
        }),
        // Invalidate all entity queries (not just the current entity because the new AR may apply to this entity's children)
        // this also invalidates entity actions required
        c.invalidateQueries({
          queryKey: s.getAllEntityDataQueryKey()
        }),
        ...A(s).map(
          (o) => c.invalidateQueries(o)
        )
      ]), e?.onSuccess)
        return e.onSuccess(t, u, i);
    }
  });
}
function R(e, r, c) {
  return {
    queryKey: e.getAccessRequirementStatusQueryKey(c),
    queryFn: () => a.getAccessRequirementStatus(
      r,
      c
    )
  };
}
function qe(e, r) {
  const { accessToken: c, keyFactory: s } = n();
  return q({
    ...r,
    ...R(
      s,
      c,
      e
    )
  });
}
function Ae(e) {
  const { accessToken: r, keyFactory: c } = n();
  return f({
    queries: e.map(
      (s) => R(c, r, s)
    )
  });
}
function Re(e, r) {
  const { accessToken: c, keyFactory: s } = n();
  return q({
    ...r,
    queryKey: s.getSortedAccessRequirementsAndStatusQueryKey(
      e
    ),
    queryFn: () => k(c, e)
  });
}
function ke(e, r) {
  const { accessToken: c, keyFactory: s } = n();
  return q({
    ...r,
    queryKey: s.getAccessRequirementResearchProjectQueryKey(
      e
    ),
    queryFn: () => a.getResearchProject(e, c)
  });
}
function Fe(e) {
  const { accessToken: r } = n(), c = y(), { keyFactory: s } = n();
  return m({
    ...e,
    mutationFn: (t) => a.updateResearchProject(t, r),
    onSuccess: async (t, u, i) => {
      if (await c.invalidateQueries({
        queryKey: s.getAccessRequirementResearchProjectQueryKey(
          t.accessRequirementId
        )
      }), e?.onSuccess)
        return e.onSuccess(t, u, i);
    }
  });
}
function Se(e, r) {
  const { accessToken: c, keyFactory: s } = n();
  return q({
    ...r,
    queryKey: s.getDataAccessRequestForUpdateQueryKey(e),
    queryFn: () => a.getDataAccessRequestForUpdate(
      e,
      c
    )
  });
}
function le(e) {
  const { accessToken: r } = n(), c = y(), { keyFactory: s } = n();
  return m({
    ...e,
    mutationFn: (t) => a.updateDataAccessRequest(t, r),
    onSuccess: async (t, u, i) => {
      if (await c.invalidateQueries({
        queryKey: s.getDataAccessRequestForUpdateQueryKey(
          t.accessRequirementId
        )
      }), e?.onSuccess)
        return e.onSuccess(t, u, i);
    }
  });
}
function Ke(e) {
  const { accessToken: r } = n(), c = y(), { keyFactory: s } = n();
  return m({
    ...e,
    mutationFn: (t) => a.createAccessApproval(r, t),
    onSuccess: async (t, u, i) => {
      if (await Promise.all([
        // Invalidate query for AR status
        c.invalidateQueries({
          queryKey: s.getAccessRequirementStatusQueryKey(
            String(u.requirementId)
          )
        }),
        // changes to access requirement eligibility may impact entity actions required
        ...A(s).map(
          (o) => c.invalidateQueries(o)
        )
      ]), e?.onSuccess)
        return e.onSuccess(t, u, i);
    }
  });
}
function ge(e) {
  const { accessToken: r } = n(), c = y(), { keyFactory: s } = n();
  return m({
    ...e,
    mutationFn: (t) => a.cancelDataAccessRequest(t.submissionId, r),
    onSuccess: async (t, u, i) => {
      if (await Promise.all([
        // Invalidate data access submission queries
        c.invalidateQueries({
          queryKey: s.getDataAccessSubmissionQueryKey()
        }),
        // Invalidate query for AR status
        c.invalidateQueries({
          queryKey: s.getAccessRequirementStatusQueryKey(
            String(u.accessRequirementId)
          )
        })
      ]), e?.onSuccess)
        return e.onSuccess(t, u, i);
    }
  });
}
export {
  ge as useCancelDataAccessRequest,
  Ke as useCreateAccessApproval,
  re as useCreateAccessRequirement,
  ae as useCreateAccessRequirementACL,
  me as useCreateLockAccessRequirement,
  ie as useDeleteAccessRequirementACL,
  ue as useGetAccessRequirementACL,
  qe as useGetAccessRequirementStatus,
  Ae as useGetAccessRequirementStatuses,
  se as useGetAccessRequirementWikiPageKey,
  ee as useGetAccessRequirements,
  te as useGetAccessRequirementsForEntity,
  ce as useGetAccessRequirementsForTeam,
  Se as useGetDataAccessRequestForUpdate,
  ke as useGetResearchProject,
  ye as useSearchAccessRequirementsInfinite,
  Re as useSortAccessRequirementIdsByCompletion,
  ne as useUpdateAccessRequirement,
  oe as useUpdateAccessRequirementACL,
  le as useUpdateDataAccessRequest,
  Fe as useUpdateResearchProject
};
//# sourceMappingURL=useAccessRequirements.js.map