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

package/src/utils/date.ts

@@ -1,13 +1,13 @@
 // Date & Time formatted as specified in SW-610
 
-import { NativeModules, Platform } from 'react-native';
+import { I18nManager, Platform, Settings } from 'react-native';
 import { format } from 'timeago.js';
 
 const MINUTE = 60 * 1000;
 const DAY = 24 * 60 * MINUTE;
 
 // OS locale
-const systemLocale: string = NativeModules.I18nManager?.localeIdentifier
+const systemLocale: string | undefined = I18nManager.getConstants().localeIdentifier
   ?.replace(/_/g, '-')
   .split('#')[0]
   .replace(/-$/, '');
@@ -138,10 +138,10 @@ export const formatDateOnlyFromUTCTimestamp = (utcTimestamp: number): string =>
 
 const locale = (
   Platform.OS === 'ios'
-    ? NativeModules.SettingsManager.settings.AppleLocale
-    : NativeModules.I18nManager.localeIdentifier
+    ? Settings.get('AppleLocale')
+    : I18nManager.getConstants().localeIdentifier
 )
-  .split('@')[0]
+  ?.split('@')[0]
   .replace('_', '-');
 
 export const formatDateTimeLocalized = (date: Date) => {

package/src/utils/filtering.ts

@@ -0,0 +1,5 @@
+export const nonEmptyFilter = <TValue>(
+  value: TValue | null | undefined,
+): value is TValue => {
+  return value !== null && value !== undefined;
+};

package/src/utils/history.ts

@@ -0,0 +1,71 @@
+import { Claim, ClaimValue, DataTypeEnum, HistoryListItem, ProofInputClaim } from '@procivis/react-native-one-core';
+import moment, { Moment } from 'moment';
+
+import { nonEmptyFilter } from './filtering';
+
+export interface HistoryGroupByDaySection {
+  data: HistoryListItem[];
+  date: Moment;
+  firstYearEntry: boolean;
+}
+
+export const groupEntriesByDay = (entries: HistoryListItem[]) => {
+  const groupedEntries = entries.reduce((result: HistoryGroupByDaySection[], entry: HistoryListItem) => {
+    const entryDate = moment(entry.createdDate);
+
+    const matchingEntry = result.find(({ date }) => date.isSame(entryDate, 'day'));
+    if (matchingEntry) {
+      matchingEntry.data.push(entry);
+    } else {
+      result.push({ data: [entry], date: entryDate, firstYearEntry: false });
+    }
+
+    return result;
+  }, []);
+
+  return groupedEntries
+    .sort(({ date: a }, { date: b }) => b.valueOf() - a.valueOf())
+    .map((item, index, list) => {
+      item.firstYearEntry = !index || !list[index - 1].date.isSame(item.date, 'year');
+      return item;
+    });
+};
+
+export const claimValueFromProofInputClaim = ({ schema, value }: ProofInputClaim): ClaimValue | undefined => {
+  if (!value) {
+    return undefined;
+  }
+
+  if (Array.isArray(value)) {
+    const values = value.map(claimFromProofInputClaim).filter(nonEmptyFilter);
+    return schema.dataType === (DataTypeEnum.Object as string)
+      ? {
+          array: schema.array,
+          dataType: DataTypeEnum.Object,
+          value: values,
+        }
+      : {
+          array: true,
+          dataType: schema.dataType,
+          value: values,
+        };
+  }
+
+  return {
+    array: false,
+    dataType: schema.dataType,
+    value,
+  };
+};
+
+export const claimFromProofInputClaim = (input: ProofInputClaim): Claim | undefined => {
+  const value = claimValueFromProofInputClaim(input);
+  if (!value) {
+    return undefined;
+  }
+  return {
+    ...value,
+    id: input.schema.id,
+    key: input.schema.key,
+  };
+};

package/src/utils/hooks/connectivity/connectivity.test.ts

@@ -1,5 +1,13 @@
 import { getInvitationUrlTransports, Transport } from './connectivity';
 
+jest.mock('@procivis/react-native-one-core', () => ({
+  initializeCore: () => Promise.resolve({} as any),
+}));
+
+jest.mock('@sentry/react-native', () => ({
+  captureException: () => {},
+}));
+
 jest.mock('@react-native-community/netinfo', () => ({
   addEventListener: () => {},
 }));

package/src/utils/hooks/connectivity/connectivity.ts

@@ -8,6 +8,8 @@ import { useEffect, useMemo, useState } from 'react';
 import { EventSubscription } from 'react-native';
 import BTStateManager from 'react-native-bluetooth-state-manager';
 
+import { getEnabledTransports, useCoreConfig } from '../core/core-config';
+
 export enum InternetState {
   Available,
   Unreachable,
@@ -37,7 +39,7 @@ export type TransportError = {
 };
 
 export const useAvailableTransports = (
-  supportedTransports: Transport[],
+  possibleTransports: Transport[],
 ): {
   availableTransport: Transport[] | undefined;
   transportError: TransportError;
@@ -45,7 +47,22 @@ export const useAvailableTransports = (
   const [internetState, setInternetState] = useState<InternetState>();
   const [bluetoothState, setBluetoothState] = useState<BluetoothState>();
 
+  const { data: coreConfig } = useCoreConfig();
+
+  const supportedTransports = useMemo(() => {
+    if (!coreConfig) {
+      return;
+    }
+    const enabledTransports = getEnabledTransports(coreConfig);
+
+    return possibleTransports.filter((t) => enabledTransports.includes(t));
+  }, [possibleTransports, coreConfig]);
+
   useEffect(() => {
+    if (!supportedTransports) {
+      return;
+    }
+
     let btSubscription: EventSubscription | undefined;
     if (supportedTransports.includes(Transport.Bluetooth)) {
       btSubscription = BTStateManager.onStateChange((state) => {
@@ -88,6 +105,13 @@ export const useAvailableTransports = (
   }, [supportedTransports]);
 
   const transportStatus = useMemo(() => {
+    if (!supportedTransports) {
+      return {
+        availableTransport: undefined,
+        transportError: {},
+      };
+    }
+
     const waitingForInternetState =
       (supportedTransports.includes(Transport.HTTP) || supportedTransports.includes(Transport.MQTT)) &&
       internetState === undefined;
@@ -101,8 +125,8 @@ export const useAvailableTransports = (
     const availableTransport: Transport[] = [];
     const transportError: TransportError = {};
     if (internetState === InternetState.Available) {
-      availableTransport.push(Transport.MQTT);
-      availableTransport.push(Transport.HTTP);
+      supportedTransports.includes(Transport.MQTT) && availableTransport.push(Transport.MQTT);
+      supportedTransports.includes(Transport.HTTP) && availableTransport.push(Transport.HTTP);
     } else {
       transportError.internet = internetState;
     }
@@ -144,7 +168,7 @@ export const getInvitationUrlTransports = (url: string, customOpenIdUrlScheme?:
     if (hasAllParameters('name', 'key')) {
       transports.push(Transport.Bluetooth);
     }
-    if (hasAllParameters('key', 'brokerUrl', 'topicId')) {
+    if (hasAllParameters('brokerUrl', 'topicId')) {
       transports.push(Transport.MQTT);
     }
 

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

@@ -4,7 +4,7 @@ import { useMutation, useQuery, useQueryClient } from 'react-query';
 
 import { generateUUID } from '../../uuid';
 import { useONECore } from './core-context';
-import { HW_DID_NAME_PREFIX, SW_DID_NAME_PREFIX } from './core-init';
+import { HW_DID_NAME_PREFIX, IdentifiersInitializationConfig, SW_DID_NAME_PREFIX } from './core-init';
 import { OneErrorCode } from './error-code';
 import { HISTORY_LIST_QUERY_KEY } from './history';
 
@@ -61,7 +61,7 @@ export const useRollbackImport = () => {
   });
 };
 
-export const useBackupFinalizeImportProcedure = () => {
+export const useBackupFinalizeImportProcedure = ({ generateHwKey, generateSwKey }: IdentifiersInitializationConfig) => {
   const { mutateAsync: finalizeImport } = useFinalizeImport();
   const { core, organisationId } = useONECore();
 
@@ -78,7 +78,7 @@ export const useBackupFinalizeImportProcedure = () => {
     });
     let swDidId = dids.values.find((did) => did.name.startsWith(SW_DID_NAME_PREFIX))?.id;
 
-    if (!swDidId) {
+    if (!swDidId && generateSwKey) {
       const swKeyId = await core.generateKey({
         keyParams: {},
         keyType: 'EDDSA',
@@ -102,23 +102,27 @@ export const useBackupFinalizeImportProcedure = () => {
       });
     }
 
+    let hwKeyId: string | null = null;
+    if (generateHwKey) {
+      hwKeyId = await core
+        .generateKey({
+          keyParams: {},
+          keyType: 'ECDSA',
+          name: `holder-key-hw-${generateUUID()}`,
+          organisationId,
+          storageParams: {},
+          storageType: 'SECURE_ELEMENT',
+        })
+        .catch((e) => {
+          // ignore if HW keys not supported by device
+          if (e instanceof OneError && e.code === OneErrorCode.KeyStorageNotSupported) {
+            return null;
+          }
+          throw e;
+        });
+    }
+
     let hwDidId: string | null = null;
-    const hwKeyId = await core
-      .generateKey({
-        keyParams: {},
-        keyType: 'ES256',
-        name: `holder-key-hw-${generateUUID()}`,
-        organisationId,
-        storageParams: {},
-        storageType: 'SECURE_ELEMENT',
-      })
-      .catch((e) => {
-        // ignore if HW keys not supported by device
-        if (e instanceof OneError && e.code === OneErrorCode.KeyStorageNotSupported) {
-          return null;
-        }
-        throw e;
-      });
     if (hwKeyId) {
       hwDidId = await core.createDid({
         didMethod: 'KEY',
@@ -135,6 +139,6 @@ export const useBackupFinalizeImportProcedure = () => {
       });
     }
 
-    return [hwDidId, swDidId] as [string | null, string];
-  }, [core, organisationId, finalizeImport]);
+    return [hwDidId, swDidId] as [string | null, string | undefined];
+  }, [core, organisationId, finalizeImport, generateHwKey, generateSwKey]);
 };

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

@@ -0,0 +1,43 @@
+import { CacheType } from '@procivis/react-native-one-core';
+import { useMutation, useQueryClient } from 'react-query';
+
+import { useONECore } from './core-context';
+import { CREDENTIAL_DETAIL_QUERY_KEY, CREDENTIAL_LIST_PAGED_QUERY_KEY, CREDENTIAL_LIST_QUERY_KEY } from './credentials';
+import { REMOTE_TRUST_ENTITY_DETAIL_QUERY_KEY, TRUST_ENTITY_DETAIL_QUERY_KEY } from './trust-entity';
+
+const CREDENTIAL_QUERY_KEYS = [CREDENTIAL_LIST_QUERY_KEY, CREDENTIAL_LIST_PAGED_QUERY_KEY, CREDENTIAL_DETAIL_QUERY_KEY];
+const TRUST_ENTITY_QUERY_KEYS = [TRUST_ENTITY_DETAIL_QUERY_KEY, REMOTE_TRUST_ENTITY_DETAIL_QUERY_KEY];
+
+// Map each CacheType to the query keys that should be invalidated when that cache is cleared.
+const cacheTypeToQueryKeys: Record<CacheType, string[]> = {
+  [CacheType.DID_DOCUMENT]: CREDENTIAL_QUERY_KEYS,
+  [CacheType.JSON_LD_CONTEXT]: CREDENTIAL_QUERY_KEYS,
+  [CacheType.STATUS_LIST_CREDENTIAL]: CREDENTIAL_QUERY_KEYS,
+  [CacheType.VCT_METADATA]: CREDENTIAL_QUERY_KEYS,
+  [CacheType.JSON_SCHEMA]: CREDENTIAL_QUERY_KEYS,
+  [CacheType.TRUST_LIST]: [...TRUST_ENTITY_QUERY_KEYS, ...CREDENTIAL_QUERY_KEYS],
+};
+
+export const useCacheClear = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async (cacheTypes: CacheType[]) => {
+      await core.deleteCache(cacheTypes);
+      return cacheTypes;
+    },
+    {
+      onSuccess: async (_, cacheTypes) => {
+        const queryKeysToInvalidate = new Set<string>();
+
+        cacheTypes.forEach((cacheType) => {
+          const keys = cacheTypeToQueryKeys[cacheType] || [];
+          keys.forEach((key) => queryKeysToInvalidate.add(key));
+        });
+
+        await Promise.all([...queryKeysToInvalidate].map((queryKey) => queryClient.invalidateQueries(queryKey)));
+      },
+    },
+  );
+};

package/src/utils/hooks/core/core-config.ts

@@ -1,3 +1,4 @@
+import { Config, ConfigEntities } from '@procivis/react-native-one-core';
 import { useQuery } from 'react-query';
 
 import { useONECore } from './core-context';
@@ -11,3 +12,21 @@ export const useCoreConfig = () => {
     keepPreviousData: true,
   });
 };
+
+export const getEnabledTransports = (config: Config): string[] => {
+  return Object.values(config?.transport ?? {})
+    .filter((t) => t.enabled !== false)
+    .map((transport) => transport.type);
+};
+
+export const getEnabledExchangeProtocols = (exchangeProtocol: ConfigEntities<any>): string[] => {
+  return Object.values(exchangeProtocol ?? {})
+    .filter((t) => t.enabled !== false)
+    .map((exchange) => exchange.type);
+};
+
+export const getEnabledTrustManagement = (config: Config): string[] => {
+  return Object.values(config?.trustManagement ?? {})
+    .filter((t) => t.enabled !== false)
+    .map((trustManagement) => trustManagement.type);
+};

package/src/utils/hooks/core/core-context.tsx

@@ -11,7 +11,8 @@ import React, {
 } from 'react';
 
 import { reportException } from '../../reporting';
-import { useCreateTrustAnchor } from './trust-entity';
+import { getEnabledTrustManagement } from './core-config';
+import { TrustManagementEnum, useCreateTrustAnchor } from './trust-entity';
 
 interface ContextValue {
   core: ONECore;
@@ -79,7 +80,19 @@ export const ONECoreContextProvider: FC<PropsWithChildren<ONECoreContextProvider
     if (!core) {
       return;
     }
-    createTrustAnchor(core).catch(() => {});
+
+    core
+      .getConfig()
+      .then((coreConfig) => {
+        const trustManagementEnabled = getEnabledTrustManagement(coreConfig).includes(
+          TrustManagementEnum.SimpleTrustList,
+        );
+
+        if (trustManagementEnabled) {
+          createTrustAnchor(core).catch(() => {});
+        }
+      })
+      .catch(() => {});
   }, [core, createTrustAnchor]);
 
   const contextValue = useMemo(

package/src/utils/hooks/core/core-init.ts

@@ -12,7 +12,7 @@ const generateHwDid = async (core: ONECore, organisationId: string) => {
   const hwKeyId = await core
     .generateKey({
       keyParams: {},
-      keyType: 'ES256',
+      keyType: 'ECDSA',
       name: 'holder-key-hw',
       organisationId,
       storageParams: {},
@@ -48,7 +48,7 @@ const generateHwDid = async (core: ONECore, organisationId: string) => {
 const generateSwDid = async (core: ONECore, organisationId: string) => {
   const swKeyId = await core.generateKey({
     keyParams: {},
-    keyType: 'EDDSA',
+    keyType: 'ECDSA',
     name: 'holder-key-sw',
     organisationId,
     storageParams: {},
@@ -70,23 +70,37 @@ const generateSwDid = async (core: ONECore, organisationId: string) => {
   });
 };
 
-// create base local identifiers in the wallet
-export const useInitializeONECoreIdentifiers = () => {
+export interface IdentifiersInitializationConfig {
+  generateHwKey: boolean;
+  generateSwKey: boolean;
+}
+
+/**
+ * Create base local identifiers
+ * @param {IdentifiersInitializationConfig} config Select desired keys/dids to be created
+ * @returns [hwDidId, swDidId]
+ */
+export const useInitializeONECoreIdentifiers = ({ generateHwKey, generateSwKey }: IdentifiersInitializationConfig) => {
   const { core, organisationId } = useONECore();
 
   return useCallback(async () => {
     return await core
-      .createOrganisation(organisationId)
+      .createOrganisation({ id: organisationId })
       .catch((e) => {
         if (e instanceof OneError && e.code === OneErrorCode.OrganisationAlreadyExists) {
           return;
         }
         throw e;
       })
-      .then(() => Promise.all([generateHwDid(core, organisationId), generateSwDid(core, organisationId)]))
+      .then(() =>
+        Promise.all([
+          generateHwKey ? generateHwDid(core, organisationId) : null,
+          generateSwKey ? generateSwDid(core, organisationId) : null,
+        ]),
+      )
       .catch((err) => {
         reportException(err, 'Failed to create base identifiers');
         throw err;
       });
-  }, [core, organisationId]);
+  }, [core, organisationId, generateHwKey, generateSwKey]);
 };

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

@@ -90,7 +90,7 @@ export const useCredentialSchemaDelete = () => {
   return useMutation(async (credentialSchemaId: string) => core.deleteCredentialSchema(credentialSchemaId), {
     onSuccess: async (_, credentialId) => {
       await queryClient.invalidateQueries(CREDENTIAL_SCHEMA_LIST_QUERY_KEY);
-      await queryClient.invalidateQueries([CREDENTIAL_SCHEMA_DETAIL_QUERY_KEY, credentialId]);
+      await queryClient.removeQueries([CREDENTIAL_SCHEMA_DETAIL_QUERY_KEY, credentialId]);
       await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
     },
   });

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

@@ -1,22 +1,17 @@
-import {
-  BypassCache,
-  CredentialListQuery,
-  CredentialStateEnum,
-  InvitationResult,
-  OneError,
-} from '@procivis/react-native-one-core';
+import { CredentialListQuery, CredentialStateEnum, InvitationResult, OneError } from '@procivis/react-native-one-core';
 import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from 'react-query';
 
 import { getQueryKeyFromCredentialListQueryParams } from '../../parsers/query';
+import { Transport } from '../connectivity/connectivity';
 import { useONECore } from './core-context';
 import { CREDENTIAL_SCHEMA_LIST_QUERY_KEY } from './credential-schemas';
 import { OneErrorCode } from './error-code';
 import { HISTORY_LIST_QUERY_KEY } from './history';
 
 const PAGE_SIZE = 20;
-const CREDENTIAL_LIST_QUERY_KEY = 'credential-list';
-const CREDENTIAL_LIST_PAGED_QUERY_KEY = 'credential-list-paged';
-const CREDENTIAL_DETAIL_QUERY_KEY = 'credential-detail';
+export const CREDENTIAL_LIST_QUERY_KEY = 'credential-list';
+export const CREDENTIAL_LIST_PAGED_QUERY_KEY = 'credential-list-paged';
+export const CREDENTIAL_DETAIL_QUERY_KEY = 'credential-detail';
 
 export const useCredentials = (queryParams?: Partial<CredentialListQuery>) => {
   const { core, organisationId } = useONECore();
@@ -82,7 +77,7 @@ export const useInvitationHandler = () => {
   const { core, organisationId } = useONECore();
 
   return useMutation(
-    async ({ invitationUrl, transport }: { invitationUrl: string; transport: 'HTTP' | 'MQTT' | 'BLE' }) =>
+    async ({ invitationUrl, transport }: { invitationUrl: string; transport: Transport }) =>
       core.handleInvitation(invitationUrl, organisationId, [transport]),
     {
       onSuccess: async (result: InvitationResult) => {
@@ -137,11 +132,11 @@ export const useCredentialReject = () => {
   );
 };
 
-export const useCredentialRevocationCheck = (bypassCache?: BypassCache[]) => {
+export const useCredentialRevocationCheck = (forceRefresh: boolean) => {
   const queryClient = useQueryClient();
   const { core } = useONECore();
 
-  return useMutation(async (credentialIds: string[]) => core.checkRevocation(credentialIds, bypassCache), {
+  return useMutation(async (credentialIds: string[]) => core.checkRevocation(credentialIds, forceRefresh), {
     onSuccess: async () => {
       await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
       await queryClient.invalidateQueries(CREDENTIAL_DETAIL_QUERY_KEY);
@@ -157,7 +152,7 @@ export const useCredentialDelete = () => {
   return useMutation(async (credentialId: string) => core.deleteCredential(credentialId), {
     onSuccess: async (_, credentialId) => {
       await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
-      await queryClient.invalidateQueries([CREDENTIAL_DETAIL_QUERY_KEY, credentialId]);
+      await queryClient.removeQueries([CREDENTIAL_DETAIL_QUERY_KEY, credentialId]);
       await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
     },
   });

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

@@ -1,13 +1,9 @@
-import { HistoryEntityTypeEnum, HistoryListItem, HistoryListQuery, ItemList } from '@procivis/react-native-one-core';
+import { HistoryListQuery } from '@procivis/react-native-one-core';
 import { useInfiniteQuery } from 'react-query';
 
 import { getQueryKeyFromHistoryListQueryParams } from '../../parsers/query';
 import { useONECore } from './core-context';
 
-export type HistoryListItemWithDid = HistoryListItem & {
-  did?: string;
-};
-
 const PAGE_SIZE = 20;
 export const HISTORY_LIST_QUERY_KEY = 'history-list';
 
@@ -24,58 +20,7 @@ export const useHistory = (queryParams?: Partial<HistoryListQuery>) => {
         ...queryParams,
       });
 
-      const credentialIds = Array.from(
-        new Set(
-          historyPage.values
-            .filter((historyItem) => historyItem.entityType === HistoryEntityTypeEnum.CREDENTIAL)
-            .map((historyItem) => historyItem.entityId!),
-        ),
-      );
-      const proofIds = Array.from(
-        new Set(
-          historyPage.values
-            .filter((historyItem) => historyItem.entityType === HistoryEntityTypeEnum.PROOF)
-            .map((historyItem) => historyItem.entityId!),
-        ),
-      );
-
-      const credentials = await core.getCredentials({
-        ids: credentialIds,
-        organisationId,
-        page: 0,
-        pageSize: credentialIds.length,
-      });
-      const credentialDidsMap: Record<string, string> = Object.assign(
-        {},
-        ...credentials.values.map((credential) => ({
-          [credential.id]: credential.issuerDid,
-        })),
-      );
-
-      const proofs = await Promise.all(proofIds.map((id) => core.getProof(id)));
-      const proofDidsMap: Record<string, string> = Object.assign(
-        {},
-        ...proofs.map((proof) => ({
-          [proof.id]: proof.verifierDid?.did,
-        })),
-      );
-
-      const result: ItemList<HistoryListItemWithDid> = {
-        totalItems: historyPage.totalItems,
-        totalPages: historyPage.totalPages,
-        values: historyPage.values.map((item) => {
-          const did =
-            item.entityType === HistoryEntityTypeEnum.CREDENTIAL
-              ? credentialDidsMap[item.entityId!]
-              : proofDidsMap[item.entityId!];
-          return {
-            ...item,
-            did,
-          };
-        }),
-      };
-
-      return result;
+      return historyPage;
     },
     {
       getNextPageParam: (lastPage, allPages) => (allPages.length < lastPage.totalPages ? allPages.length : undefined),

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

@@ -1,4 +1,5 @@
 export * from './backup';
+export * from './cache';
 export * from './core-config';
 export * from './core-context';
 export * from './core-init';

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

@@ -111,7 +111,7 @@ export const useProofSchemaDelete = () => {
     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]);
+      await queryClient.removeQueries([PROOF_SCHEMA_DETAIL_QUERY_KEY, proofSchemaId]);
     },
   });
 };