@procivis/one-react-native-components 0.1.63 → 0.3.22

package/src/utils/hooks/core/proofs.ts

@@ -0,0 +1,409 @@
+import {
+  Config,
+  CreateProofRequest,
+  DidListQuery,
+  OneError,
+  PresentationSubmitCredentialRequest,
+  ProofListQuery,
+  ProofSchema,
+  ProofStateEnum,
+  ShareProofRequest,
+} from '@procivis/react-native-one-core';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useMutation, useQuery, useQueryClient } from 'react-query';
+
+import { getQueryKeyFromProofListQueryParams } from '../../parsers/query';
+import { Transport } from '../connectivity/connectivity';
+import { useCoreConfig } from './core-config';
+import { useONECore } from './core-context';
+import { useDids } from './dids';
+import { OneErrorCode } from './error-code';
+import { HISTORY_LIST_QUERY_KEY } from './history';
+import { useProofSchemaDetail } from './proof-schemas';
+
+const PAGE_SIZE = 10;
+export const PROOF_DETAIL_QUERY_KEY = 'proof-detail';
+export const PROOF_STATE_QUERY_KEY = 'proof-state';
+export const PROOF_LIST_QUERY_KEY = 'proof-list';
+
+export const useProofDetail = (proofId: string | undefined) => {
+  const { core } = useONECore();
+
+  return useQuery([PROOF_DETAIL_QUERY_KEY, proofId], () => (proofId ? core.getProof(proofId) : undefined), {
+    enabled: Boolean(proofId),
+    keepPreviousData: true,
+  });
+};
+
+export const useProofState = (proofId: string | undefined, isPolling: boolean) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [PROOF_STATE_QUERY_KEY, proofId],
+    () => (proofId ? core.getProof(proofId).then((proof) => proof.state) : undefined),
+    {
+      enabled: Boolean(proofId),
+      refetchInterval: isPolling ? 1000 : false,
+    },
+  );
+};
+
+type ProofUrlHookParams = { proofId: string; request?: ShareProofRequest };
+
+export const useProofUrl = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async ({ proofId, request }: ProofUrlHookParams) =>
+      core.shareProof(proofId, request ?? {}).then((proof) => proof.url),
+    {
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(PROOF_DETAIL_QUERY_KEY);
+        await queryClient.invalidateQueries(PROOF_STATE_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useProofAccept = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async ({
+      interactionId,
+      credentials,
+      didId,
+      keyId,
+    }: {
+      credentials: Record<string, PresentationSubmitCredentialRequest>;
+      didId: string;
+      interactionId: string;
+      keyId?: string;
+    }) => core.holderSubmitProof(interactionId, credentials, didId, keyId),
+    {
+      onError: async () => {
+        await queryClient.invalidateQueries(PROOF_DETAIL_QUERY_KEY);
+      },
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(PROOF_DETAIL_QUERY_KEY);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useProofReject = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async (interactionId: string) =>
+      core.holderRejectProof(interactionId).catch((e) => {
+        if (e instanceof OneError && e.code === OneErrorCode.OperationNotSupported) {
+          return;
+        }
+        throw e;
+      }),
+    {
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(PROOF_DETAIL_QUERY_KEY);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export enum IssuanceProtocol {
+  OPENID4VCI_DRAFT13 = 'OPENID4VCI_DRAFT13',
+}
+
+export enum VerificationProtocol {
+  ISO_MDL = 'ISO_MDL',
+  OPENID4VP_DRAFT20 = 'OPENID4VP_DRAFT20',
+  OPENID4VP_DRAFT25 = 'OPENID4VP_DRAFT25',
+  OPENID4VP_PROXIMITY_DRAFT00 = 'OPENID4VP_PROXIMITY_DRAFT00',
+  SCAN_TO_VERIFY = 'SCAN_TO_VERIFY',
+}
+
+export const useProposeProof = () => {
+  const queryClient = useQueryClient();
+  const { core, organisationId } = useONECore();
+
+  return useMutation(async (exchange: VerificationProtocol) => core.proposeProof(exchange, organisationId), {
+    onSuccess: async () => {
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export const useProofDelete = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async (proofId: string) => {
+      return core.deleteProof(proofId).catch((e) => {
+        if (e instanceof OneError && e.code === OneErrorCode.OperationNotSupported) {
+          return;
+        }
+        throw e;
+      });
+    },
+    {
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(PROOF_LIST_QUERY_KEY);
+        await queryClient.invalidateQueries(PROOF_STATE_QUERY_KEY);
+        await queryClient.invalidateQueries(PROOF_DETAIL_QUERY_KEY);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useProofs = (queryParams?: Partial<ProofListQuery>) => {
+  const { core, organisationId } = useONECore();
+
+  const queryKey = [PROOF_LIST_QUERY_KEY, ...getQueryKeyFromProofListQueryParams(queryParams)];
+
+  return useQuery(
+    queryKey,
+    ({ pageParam = 0 }) =>
+      core.getProofs({
+        organisationId,
+        page: pageParam,
+        pageSize: PAGE_SIZE,
+        ...queryParams,
+      }),
+    {
+      keepPreviousData: false,
+    },
+  );
+};
+
+export const useProofCreate = () => {
+  const queryClient = useQueryClient();
+
+  const { core } = useONECore();
+
+  return useMutation(async (data: CreateProofRequest) => core.createProof(data), {
+    onSuccess: async () => {
+      await queryClient.invalidateQueries(PROOF_LIST_QUERY_KEY);
+      await queryClient.invalidateQueries(PROOF_STATE_QUERY_KEY);
+      await queryClient.invalidateQueries(PROOF_DETAIL_QUERY_KEY);
+    },
+  });
+};
+
+const getDidFilterForProofSchema = (proofSchema: ProofSchema, config: Config): Partial<DidListQuery> => {
+  const requestedFormats = proofSchema.proofInputSchemas.map((schema) => schema.credentialSchema.format);
+  const requestedFormatsCapabilities = requestedFormats
+    .map((format) => config.format[format]?.capabilities)
+    .filter((x) => x);
+
+  // key algorithms must be supported by all requested formats
+  const keyAlgorithms = requestedFormatsCapabilities.reduce<string[] | undefined>((others, capabilities) => {
+    const current = capabilities.verificationKeyAlgorithms;
+    return others?.filter((item) => current.includes(item)) ?? current;
+  }, undefined);
+
+  // key storages must be supported by all requested formats
+  const keyStorages = requestedFormatsCapabilities.reduce<string[] | undefined>((others, capabilities) => {
+    const current = capabilities.verificationKeyStorages;
+    return others?.filter((item) => current.includes(item)) ?? current;
+  }, undefined);
+
+  return { keyAlgorithms, keyStorages };
+};
+
+export const useProofForSchemaIdWithTransport = (
+  proofSchemaId: string,
+  transport: Transport[] | undefined,
+  enabled: boolean,
+) => {
+  const { data: proofSchema } = useProofSchemaDetail(proofSchemaId, enabled);
+  const { data: config } = useCoreConfig();
+
+  const didFilter = useMemo(
+    () => (proofSchema && config ? getDidFilterForProofSchema(proofSchema, config) : undefined),
+    [config, proofSchema],
+  );
+
+  const { data: dids } = useDids(didFilter);
+  const { mutateAsync: createProof } = useProofCreate();
+  const { mutateAsync: deleteProof } = useProofDelete();
+
+  const [deleting, setDeleting] = useState(false);
+  const [proofId, setProofIdState] = useState<string | undefined>(undefined);
+  const proofIdRef = useRef<string>();
+
+  const { data: proofState } = useProofState(deleting ? undefined : proofId, enabled);
+
+  const setProofId = useCallback((id: string | undefined) => {
+    proofIdRef.current = id;
+    setProofIdState(id);
+  }, []);
+
+  useEffect(() => {
+    if (!proofIdRef.current) {
+      return;
+    }
+    setDeleting(true);
+    deleteProof(proofIdRef.current)
+      .then(() => {
+        setProofId(undefined);
+        setDeleting(false);
+      })
+      .catch(() => {});
+  }, [proofIdRef, deleteProof, proofSchemaId, transport, setProofId]);
+
+  useEffect(() => {
+    if (enabled) {
+      return;
+    }
+    if (proofState !== ProofStateEnum.CREATED && proofState !== ProofStateEnum.PENDING) {
+      setProofId(undefined);
+    }
+  }, [enabled, proofState, setProofId]);
+
+  useEffect(() => {
+    if (
+      deleting ||
+      !enabled ||
+      proofId ||
+      !dids ||
+      !didFilter ||
+      !dids.values.length ||
+      !transport ||
+      transport.length === 0
+    ) {
+      return;
+    }
+
+    createProof({
+      exchange: VerificationProtocol.OPENID4VP_PROXIMITY_DRAFT00,
+      proofSchemaId,
+      transport,
+      verifierDidId: dids.values[0].id,
+    })
+      .then((id) => {
+        setProofId(id);
+      })
+      .catch(() => {});
+  }, [proofSchemaId, dids, didFilter, createProof, enabled, transport, proofId, setProofId, deleting]);
+
+  return deleting ? undefined : proofId;
+};
+
+export const useCleanupUnusedProofs = () => {
+  const { mutateAsync: deleteProof } = useProofDelete();
+  const { data: proofs } = useProofs({
+    page: 0,
+    pageSize: 100,
+    proofStates: [ProofStateEnum.CREATED, ProofStateEnum.PENDING],
+  });
+  const [cleaned, setCleaned] = useState(false);
+
+  useEffect(() => {
+    if (cleaned || !proofs) {
+      return;
+    }
+    setCleaned(true);
+    proofs.values.forEach((proof) => deleteProof(proof.id));
+  }, [cleaned, deleteProof, proofs]);
+};
+
+export const useShareProof = (proofUrlProps: ProofUrlHookParams | undefined, enabled: boolean) => {
+  const { mutateAsync: shareProof } = useProofUrl();
+  const { data: proofState } = useProofState(proofUrlProps?.proofId, enabled);
+
+  const [sharedProof, setSharedProof] = useState<{
+    bleAdapterDisabled: boolean;
+    url?: string;
+  }>();
+
+  // reset when proofId changes or the proof was retracted
+  useEffect(() => {
+    if (!proofUrlProps?.proofId || proofState === ProofStateEnum.CREATED) {
+      setSharedProof(undefined);
+    }
+  }, [proofUrlProps?.proofId, proofState]);
+
+  useEffect(() => {
+    if (!proofUrlProps || !enabled || sharedProof) {
+      return;
+    }
+
+    shareProof(proofUrlProps)
+      .then((url) => {
+        setSharedProof({
+          bleAdapterDisabled: false,
+          url,
+        });
+      })
+      .catch((err: unknown) => {
+        // TODO emit error with specific error code from core.
+        if (err instanceof OneError && err.cause?.includes('BLE adapter not enabled')) {
+          setSharedProof({
+            bleAdapterDisabled: true,
+          });
+        }
+      });
+  }, [enabled, proofUrlProps, shareProof, sharedProof]);
+
+  return sharedProof;
+};
+
+export const useRetainProofCheck = (proofId?: string) => {
+  const queryClient = useQueryClient();
+
+  const { core } = useONECore();
+
+  return useMutation(async () => core.runTask('RETAIN_PROOF_CHECK'), {
+    onSuccess: async () => {
+      if (proofId) {
+        await queryClient.removeQueries([PROOF_DETAIL_QUERY_KEY, proofId]);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      }
+    },
+  });
+};
+
+export const useDeleteProofData = (proofId: string) => {
+  const queryClient = useQueryClient();
+
+  const { core } = useONECore();
+
+  return useMutation(async () => core.deleteProofClaims(proofId), {
+    onSuccess: async () => {
+      await queryClient.removeQueries([PROOF_DETAIL_QUERY_KEY, proofId]);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export const useDeleteAllProofsData = (schemaId: string) => {
+  const queryClient = useQueryClient();
+
+  const { core, organisationId } = useONECore();
+
+  return useMutation(
+    async () =>
+      core
+        .getProofs({
+          organisationId,
+          page: 0,
+          pageSize: 1000,
+          proofSchemaIds: [schemaId],
+          proofStates: [ProofStateEnum.ACCEPTED],
+        })
+        .then((result) => Promise.all(result.values.reverse().map((proof) => core.deleteProofClaims(proof.id)))),
+    {
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(PROOF_DETAIL_QUERY_KEY);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};

package/src/utils/hooks/core/query.ts

@@ -0,0 +1,19 @@
+import { QueryClient } from 'react-query';
+
+import { reportException } from '../../reporting';
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    mutations: {
+      onError: (err) => {
+        reportException(err, 'Mutation failure');
+      },
+    },
+    queries: {
+      onError: (err) => {
+        reportException(err, 'Query failure');
+      },
+      staleTime: Infinity,
+    },
+  },
+});

package/src/utils/hooks/core/trust-entity.ts

@@ -0,0 +1,113 @@
+import {
+  CreateRemoteTrustEntityRequest,
+  ONECore,
+  OneError,
+  TrustAnchor,
+  UpdateRemoteTrustEntityRequest,
+} from '@procivis/react-native-one-core';
+import { useCallback } from 'react';
+import { useMutation, useQuery, useQueryClient } from 'react-query';
+
+import { reportException } from '../../reporting';
+import { useHTTPClient } from '../http/client';
+import { useONECore } from './core-context';
+import { OneErrorCode } from './error-code';
+import { HISTORY_LIST_QUERY_KEY } from './history';
+
+export const TRUST_ENTITY_DETAIL_QUERY_KEY = 'trust-entity-detail';
+export const REMOTE_TRUST_ENTITY_DETAIL_QUERY_KEY = 'remote-trust-entity-detail';
+
+export const useCreateTrustAnchor = (publisherReference: string) => {
+  const httpClient = useHTTPClient();
+
+  return useCallback(
+    async (core: ONECore) => {
+      const trustAnchors = await core.getTrustAnchors({
+        page: 0,
+        pageSize: 1,
+      });
+      if (trustAnchors.values.length > 0) {
+        return;
+      }
+      const response = await httpClient.get<TrustAnchor>(publisherReference);
+      if (!response.ok || !response.data) {
+        return;
+      }
+      const trustAnchor = response.data;
+      await core
+        .createTrustAnchor({
+          isPublisher: false,
+          name: trustAnchor.name,
+          publisherReference,
+          type: TrustManagementEnum.SimpleTrustList,
+        })
+        .catch((err) => {
+          reportException(err, 'Failed to create trust anchor');
+          throw err;
+        });
+    },
+    [publisherReference, httpClient],
+  );
+};
+
+export const useTrustEntity = (didId: string | undefined) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [TRUST_ENTITY_DETAIL_QUERY_KEY, didId],
+    () =>
+      didId
+        ? core.getTrustEntityByDid(didId).catch((e) => {
+            if (e instanceof OneError && e.code === OneErrorCode.NoTrustEntityFound) {
+              return null;
+            }
+            throw e;
+          })
+        : undefined,
+    {
+      enabled: Boolean(didId),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useRemoteTrustEntity = (did: string | undefined) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [REMOTE_TRUST_ENTITY_DETAIL_QUERY_KEY, did],
+    () => (did ? core.getRemoteTrustEntity(did) : undefined),
+    {
+      enabled: Boolean(did),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useCreateRemoteTrustEntity = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(async (request: CreateRemoteTrustEntityRequest) => core.createRemoteTrustEntity(request), {
+    onSuccess: async () => {
+      await queryClient.invalidateQueries(REMOTE_TRUST_ENTITY_DETAIL_QUERY_KEY);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export const useUpdateRemoteTrustEntity = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(async (request: UpdateRemoteTrustEntityRequest) => core.updateRemoteTrustEntity(request), {
+    onSuccess: async () => {
+      await queryClient.invalidateQueries(REMOTE_TRUST_ENTITY_DETAIL_QUERY_KEY);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export enum TrustManagementEnum {
+  SimpleTrustList = 'SIMPLE_TRUST_LIST',
+}

package/src/utils/hooks/credential-card/credential-card-expanding.tsx

@@ -0,0 +1,45 @@
+import { useCallback, useState } from 'react';
+
+export const useCredentialCardExpanded = () => {
+  const [expanded, setExpanded] = useState(true);
+
+  const onHeaderPress = useCallback(() => {
+    setExpanded((oldValue) => !oldValue);
+  }, []);
+
+  return { expanded, onHeaderPress };
+};
+
+export const useCredentialListExpandedCard = () => {
+  const [expandedCredential, setExpandedCredential] = useState<string>();
+  const [initialized, setInitialized] = useState(false);
+
+  const onHeaderPress = useCallback((credentialId?: string) => {
+    if (!credentialId) {
+      return;
+    }
+    setInitialized(true);
+    setExpandedCredential((oldValue) => {
+      if (credentialId === oldValue) {
+        return undefined;
+      }
+      return credentialId;
+    });
+  }, []);
+
+  const setInitialCredential = useCallback(
+    (credentialId: string) => {
+      if (!initialized) {
+        setExpandedCredential(credentialId);
+      }
+      setInitialized(true);
+    },
+    [initialized],
+  );
+
+  const foldCards = useCallback(() => {
+    setExpandedCredential(undefined);
+  }, []);
+
+  return { expandedCredential, foldCards, onHeaderPress, setInitialCredential };
+};

package/src/utils/hooks/http/client.ts

@@ -0,0 +1,13 @@
+import { ApisauceInstance, create } from 'apisauce';
+import { useMemo } from 'react';
+
+export const useHTTPClient = () => {
+  return useMemo<ApisauceInstance>(() => {
+    return create({
+      headers: {
+        Accept: 'application/json',
+      },
+      baseURL: undefined,
+    });
+  }, []);
+};

package/src/utils/hooks/index.ts

@@ -1,5 +1,8 @@
-import { useOnScrollHeaderState } from './header/on-scroll-header-state';
-import { useListContentInset } from './list/list-content-inset';
-
-export { useOnScrollHeaderState };
-export { useListContentInset };
+export * from './connectivity/connectivity';
+export * from './core';
+export * from './credential-card/credential-card-expanding';
+export * from './header/on-scroll-header-state';
+export * from './list/list-content-inset';
+export * from './navigation';
+export * from './pin-security/pin-security';
+export * from './revocation/credential-status';

package/src/utils/hooks/navigation/before-remove.tsx

@@ -0,0 +1,22 @@
+import { useNavigation } from '@react-navigation/native';
+import { useEffect, useRef } from 'react';
+
+export const useBeforeRemove = (callback: () => void) => {
+  const navigation = useNavigation();
+  const removed = useRef<boolean>();
+
+  useEffect(() => {
+    if (removed.current) {
+      return;
+    }
+    return navigation.addListener('beforeRemove', (e) => {
+      if (removed.current) {
+        return;
+      }
+      removed.current = true;
+      e.preventDefault();
+      callback();
+      navigation.dispatch(e.data.action);
+    });
+  }, [callback, navigation]);
+};

package/src/utils/hooks/navigation/close-button-timeout.tsx

@@ -0,0 +1,29 @@
+import { useEffect, useState } from 'react';
+
+export const useCloseButtonTimeout = (active: boolean, closeButtonHandler: () => void) => {
+  const [closeTimeout, setCloseTimeout] = useState(5);
+
+  useEffect(() => {
+    if (!active) {
+      return;
+    }
+
+    const interval = setInterval(() => {
+      setCloseTimeout((prev) => {
+        const next = prev - 1;
+        return next > 0 ? next : 0;
+      });
+    }, 1000);
+    return () => {
+      clearInterval(interval);
+    };
+  }, [active]);
+
+  useEffect(() => {
+    if (active && closeTimeout === 0) {
+      closeButtonHandler();
+    }
+  }, [closeTimeout, active, closeButtonHandler]);
+
+  return { closeTimeout };
+};