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

package/src/utils/hooks/core/proof-schemas.ts

@@ -0,0 +1,130 @@
+import {
+  CreateProofSchemaRequest,
+  ImportProofSchema,
+  ProofSchema,
+  ProofSchemaListItem,
+  ProofSchemaListQuery,
+} from '@procivis/react-native-one-core';
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from 'react-query';
+
+import { getQueryKeyFromProofSchemaListQueryParams } from '../../parsers/query';
+import { useHTTPClient } from '../http/client';
+import { useONECore } from './core-context';
+import { CREDENTIAL_SCHEMA_LIST_QUERY_KEY } from './credential-schemas';
+import { HISTORY_LIST_QUERY_KEY } from './history';
+
+const PAGE_SIZE = 10;
+export const PROOF_SCHEMA_LIST_QUERY_KEY = 'proof-schema-list';
+export const PROOF_SCHEMA_IMPORT_DETAIL_QUERY_KEY = 'proof-schema-import';
+export const PROOF_SCHEMA_DETAIL_QUERY_KEY = 'proof-schema-detail';
+export const PROOF_SCHEMA_SHARE_QUERY_KEY = 'proof-schema-share';
+
+export const useProofSchemas = (queryParams?: Partial<ProofSchemaListQuery>, keepPreviousData = true) => {
+  const { core, organisationId } = useONECore();
+
+  return useInfiniteQuery(
+    [PROOF_SCHEMA_LIST_QUERY_KEY, ...getQueryKeyFromProofSchemaListQueryParams(queryParams)],
+    ({ pageParam = 0 }) =>
+      core
+        .getProofSchemas({
+          organisationId,
+          page: pageParam,
+          pageSize: PAGE_SIZE,
+          ...queryParams,
+        })
+        .then(({ values }) => values),
+    {
+      getNextPageParam: (lastPage, allPages) => (lastPage.length === PAGE_SIZE ? allPages.length : undefined),
+      keepPreviousData,
+    },
+  );
+};
+
+export const useProofSchemaDetail = (proofSchemaId: ProofSchemaListItem['id'] | undefined, active = true) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [PROOF_SCHEMA_DETAIL_QUERY_KEY, proofSchemaId],
+    () => (proofSchemaId ? core.getProofSchema(proofSchemaId) : undefined),
+    {
+      enabled: active && Boolean(proofSchemaId),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useProofSchemaImportDetail = (url: string) => {
+  const httpClient = useHTTPClient();
+
+  return useQuery(
+    [PROOF_SCHEMA_IMPORT_DETAIL_QUERY_KEY, url],
+    () =>
+      httpClient.get(url).then((response) => {
+        if (!response.ok) {
+          throw response.originalError;
+        }
+        return response.data as ImportProofSchema;
+      }),
+    {
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useProofSchemaAccept = () => {
+  const queryClient = useQueryClient();
+  const { core, organisationId } = useONECore();
+
+  return useMutation(
+    async ({ schema }: { schema: ImportProofSchema }) =>
+      core.importProofSchema({
+        organisationId,
+        schema,
+      }),
+    {
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(PROOF_SCHEMA_LIST_QUERY_KEY);
+        await queryClient.invalidateQueries(CREDENTIAL_SCHEMA_LIST_QUERY_KEY);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useProofSchemaCreate = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(async (proofSchema: CreateProofSchemaRequest) => core.createProofSchema(proofSchema), {
+    onSuccess: async () => {
+      await queryClient.invalidateQueries(PROOF_SCHEMA_LIST_QUERY_KEY);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export const useProofSchemaDelete = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(async (proofSchemaId: ProofSchema['id']) => core.deleteProofSchema(proofSchemaId), {
+    onSuccess: async (_, proofSchemaId) => {
+      await queryClient.invalidateQueries(PROOF_SCHEMA_LIST_QUERY_KEY);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      await queryClient.invalidateQueries([PROOF_SCHEMA_DETAIL_QUERY_KEY, proofSchemaId]);
+    },
+  });
+};
+
+export const useShareProofSchema = (schemaId?: string) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [PROOF_SCHEMA_SHARE_QUERY_KEY, schemaId],
+    () => (schemaId ? core.shareProofSchema(schemaId) : Promise.reject()),
+    {
+      enabled: Boolean(schemaId),
+      keepPreviousData: true,
+    },
+  );
+};

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

@@ -0,0 +1,351 @@
+import {
+  Config,
+  CreateProofRequest,
+  DidListQuery,
+  OneError,
+  PresentationSubmitCredentialRequest,
+  ProofListQuery,
+  ProofSchema,
+  ProofStateEnum,
+  ShareProofRequest,
+} from '@procivis/react-native-one-core';
+import { useEffect, useMemo, 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], () => core.getProof(proofId!).then((proof) => proof.state), {
+    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 ExchangeProtocol {
+  ISO_MDL = 'ISO_MDL',
+  OPENID4VC = 'OPENID4VC',
+  PROCIVIS = 'PROCIVIS_TEMPORARY',
+}
+
+export const useProposeProof = () => {
+  const queryClient = useQueryClient();
+  const { core, organisationId } = useONECore();
+
+  return useMutation(async (exchange: ExchangeProtocol) => core.proposeProof(exchange, organisationId), {
+    onSuccess: async () => {
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export const useProofRetract = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async (proofId: string) => {
+      return core.retractProof(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 useProofCreateOrReuse = (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 { data: proofs } = useProofs({
+    page: 0,
+    pageSize: 100,
+    proofSchemaIds: [proofSchemaId],
+    proofStates: [ProofStateEnum.CREATED, ProofStateEnum.PENDING],
+  });
+
+  const [proofId, setProofId] = useState<string | undefined>(undefined);
+
+  useEffect(() => {
+    if (!dids || !didFilter || !dids.values.length || !proofs || !transport || transport.length === 0) {
+      return;
+    }
+
+    const transportFilter = transport.length === 2 ? '' : transport[0];
+    const filteredProofs = proofs.values.filter(
+      (p) => p.exchange === ExchangeProtocol.OPENID4VC && p.transport === transportFilter,
+    );
+    const proof =
+      filteredProofs.length > 0
+        ? filteredProofs.find((p) => p.state === ProofStateEnum.PENDING) ?? filteredProofs[0]
+        : undefined;
+
+    const reusableProof = proof?.id;
+
+    if (!enabled) {
+      if (!reusableProof) {
+        setProofId(undefined);
+      }
+      return;
+    }
+
+    if (reusableProof) {
+      setProofId(reusableProof);
+    } else {
+      createProof({
+        exchange: ExchangeProtocol.OPENID4VC,
+        proofSchemaId,
+        transport,
+        verifierDidId: dids.values[0].id,
+      }).catch(() => {});
+    }
+  }, [proofSchemaId, proofs, dids, didFilter, createProof, enabled, transport]);
+
+  return proofId;
+};
+
+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 = () => {
+  const { core } = useONECore();
+
+  return useMutation(async () => core.runTask('RETAIN_PROOF_CHECK'));
+};
+
+export const useDeleteProofData = (proofId: string) => {
+  const queryClient = useQueryClient();
+
+  const { core } = useONECore();
+
+  return useMutation(async () => core.deleteProofClaims(proofId), {
+    onSuccess: async () => {
+      await queryClient.invalidateQueries([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,109 @@
+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';
+
+const TRUST_ENTITY_DETAIL_QUERY_KEY = 'trust-entity-detail';
+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: 'SIMPLE_TRUST_LIST',
+        })
+        .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);
+    },
+  });
+};

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]);
+};