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

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

@@ -0,0 +1,110 @@
+import { CredentialSchemaListQuery, ImportCredentialSchemaRequestSchema } from '@procivis/react-native-one-core';
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from 'react-query';
+
+import { getQueryKeyFromCredentialSchemaListQueryParams } from '../../parsers/query';
+import { useHTTPClient } from '../http/client';
+import { useONECore } from './core-context';
+import { HISTORY_LIST_QUERY_KEY } from './history';
+
+const PAGE_SIZE = 10;
+export const CREDENTIAL_SCHEMA_LIST_QUERY_KEY = 'credential-schema-list';
+export const CREDENTIAL_SCHEMA_DETAIL_QUERY_KEY = 'credential-schema-detail';
+export const CREDENTIAL_SCHEMA_PREVIEW_QUERY_KEY = 'credential-schema-preview';
+export const CREDENTIAL_SCHEMA_SHARE_QUERY_KEY = 'credential-schema-share';
+
+export const useCredentialSchemas = (queryParams?: Partial<CredentialSchemaListQuery>) => {
+  const { core, organisationId } = useONECore();
+
+  return useInfiniteQuery(
+    [CREDENTIAL_SCHEMA_LIST_QUERY_KEY, ...getQueryKeyFromCredentialSchemaListQueryParams(queryParams)],
+    ({ pageParam = 0 }) =>
+      core
+        .getCredentialSchemas({
+          organisationId,
+          page: pageParam,
+          pageSize: PAGE_SIZE,
+          ...queryParams,
+        })
+        .then(({ values }) => values),
+    {
+      getNextPageParam: (lastPage, allPages) => (lastPage.length === PAGE_SIZE ? allPages.length : undefined),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useCredentialSchemaPreview = (url: string) => {
+  const httpClient = useHTTPClient();
+
+  return useQuery(
+    [CREDENTIAL_SCHEMA_PREVIEW_QUERY_KEY, url],
+    () =>
+      httpClient.get(url).then((response) => {
+        if (!response.ok) {
+          throw response.originalError;
+        }
+        return response.data as ImportCredentialSchemaRequestSchema;
+      }),
+    {
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useCredentialSchemaAccept = () => {
+  const queryClient = useQueryClient();
+  const { core, organisationId } = useONECore();
+
+  return useMutation(
+    async (schema: ImportCredentialSchemaRequestSchema) =>
+      core.importCredentialSchema({
+        organisationId,
+        schema,
+      }),
+    {
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(CREDENTIAL_SCHEMA_LIST_QUERY_KEY);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useCredentialSchemaDetail = (credentialId: string | undefined, active = true) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [CREDENTIAL_SCHEMA_DETAIL_QUERY_KEY, credentialId],
+    () => (credentialId ? core.getCredentialSchema(credentialId) : undefined),
+    {
+      enabled: active && Boolean(credentialId),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useCredentialSchemaDelete = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(async (credentialSchemaId: string) => core.deleteCredentialSchema(credentialSchemaId), {
+    onSuccess: async (_, credentialId) => {
+      await queryClient.invalidateQueries(CREDENTIAL_SCHEMA_LIST_QUERY_KEY);
+      await queryClient.removeQueries([CREDENTIAL_SCHEMA_DETAIL_QUERY_KEY, credentialId]);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export const useShareCredentialSchema = (schemaId?: string) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [CREDENTIAL_SCHEMA_SHARE_QUERY_KEY, schemaId],
+    () => (schemaId ? core.shareCredentialSchema(schemaId) : Promise.reject()),
+    {
+      enabled: Boolean(schemaId),
+      keepPreviousData: true,
+    },
+  );
+};

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

@@ -0,0 +1,166 @@
+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;
+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();
+
+  return useQuery(
+    [CREDENTIAL_LIST_QUERY_KEY, ...getQueryKeyFromCredentialListQueryParams(queryParams)],
+    async () => {
+      const { values } = await core.getCredentials({
+        organisationId,
+        page: 0,
+        // TODO: workaround pagination for now, until it's supported by UI
+        pageSize: 10000,
+        status: [CredentialStateEnum.ACCEPTED, CredentialStateEnum.SUSPENDED, CredentialStateEnum.REVOKED],
+        ...queryParams,
+      });
+      return values;
+    },
+    {
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const usePagedCredentials = (queryParams?: Partial<CredentialListQuery>) => {
+  const { core, organisationId } = useONECore();
+
+  return useInfiniteQuery(
+    [
+      CREDENTIAL_LIST_QUERY_KEY,
+      CREDENTIAL_LIST_PAGED_QUERY_KEY,
+      ...getQueryKeyFromCredentialListQueryParams(queryParams),
+    ],
+    ({ pageParam = 0 }) =>
+      core.getCredentials({
+        organisationId,
+        page: pageParam,
+        pageSize: PAGE_SIZE,
+        status: [CredentialStateEnum.ACCEPTED, CredentialStateEnum.SUSPENDED, CredentialStateEnum.REVOKED],
+        ...queryParams,
+      }),
+    {
+      getNextPageParam: (lastPage, allPages) => (allPages.length < lastPage.totalPages ? allPages.length : undefined),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useCredentialDetail = (credentialId: string | undefined, active = true) => {
+  const { core } = useONECore();
+
+  return useQuery(
+    [CREDENTIAL_DETAIL_QUERY_KEY, credentialId],
+    () => (credentialId ? core.getCredential(credentialId) : undefined),
+    {
+      enabled: active && Boolean(credentialId),
+      keepPreviousData: true,
+    },
+  );
+};
+
+export const useInvitationHandler = () => {
+  const queryClient = useQueryClient();
+  const { core, organisationId } = useONECore();
+
+  return useMutation(
+    async ({ invitationUrl, transport }: { invitationUrl: string; transport: Transport }) =>
+      core.handleInvitation(invitationUrl, organisationId, [transport]),
+    {
+      onSuccess: async (result: InvitationResult) => {
+        if ('credentialIds' in result) {
+          await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
+          await queryClient.invalidateQueries(CREDENTIAL_SCHEMA_LIST_QUERY_KEY);
+        }
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useCredentialAccept = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  type CredentialAcceptHookParams = { didId: string; interactionId: string; keyId?: string; txCode?: string };
+
+  return useMutation(
+    async ({ interactionId, didId, keyId, txCode }: CredentialAcceptHookParams) =>
+      core.holderAcceptCredential(interactionId, didId, keyId, txCode),
+    {
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
+        await queryClient.invalidateQueries(CREDENTIAL_DETAIL_QUERY_KEY);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useCredentialReject = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(
+    async (interactionId: string) =>
+      core.holderRejectCredential(interactionId).catch((e) => {
+        if (e instanceof OneError && e.code === OneErrorCode.OperationNotSupported) {
+          return;
+        }
+        throw e;
+      }),
+    {
+      onSuccess: async () => {
+        await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
+        await queryClient.invalidateQueries(CREDENTIAL_DETAIL_QUERY_KEY);
+        await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+      },
+    },
+  );
+};
+
+export const useCredentialRevocationCheck = (forceRefresh: boolean) => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  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);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export const useCredentialDelete = () => {
+  const queryClient = useQueryClient();
+  const { core } = useONECore();
+
+  return useMutation(async (credentialId: string) => core.deleteCredential(credentialId), {
+    onSuccess: async (_, credentialId) => {
+      await queryClient.invalidateQueries(CREDENTIAL_LIST_QUERY_KEY);
+      await queryClient.removeQueries([CREDENTIAL_DETAIL_QUERY_KEY, credentialId]);
+      await queryClient.invalidateQueries(HISTORY_LIST_QUERY_KEY);
+    },
+  });
+};
+
+export const useInvalidateCredentialDetails = () => {
+  const queryClient = useQueryClient();
+
+  return (credentialId: string | undefined) =>
+    queryClient.invalidateQueries([CREDENTIAL_DETAIL_QUERY_KEY, credentialId]);
+};

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

@@ -0,0 +1,28 @@
+import { DidListQuery, DidTypeEnum } from '@procivis/react-native-one-core';
+import { useQuery } from 'react-query';
+
+import { getQueryKeyFromDidListQueryParams } from '../../parsers/query';
+import { useONECore } from './core-context';
+
+const PAGE_SIZE = 20;
+export const DID_LIST_QUERY_KEY = 'did-list';
+
+export const useDids = (queryParams?: Partial<DidListQuery>) => {
+  const { core, organisationId } = useONECore();
+
+  return useQuery(
+    [DID_LIST_QUERY_KEY, ...getQueryKeyFromDidListQueryParams(queryParams)],
+    async ({ pageParam = 0 }) => {
+      const dids = await core.getDids({
+        deactivated: false,
+        organisationId,
+        page: pageParam,
+        pageSize: PAGE_SIZE,
+        type: DidTypeEnum.LOCAL,
+        ...queryParams,
+      });
+
+      return dids;
+    },
+  );
+};

package/src/utils/hooks/core/error-code.ts

@@ -0,0 +1,6 @@
+export enum OneErrorCode {
+  OrganisationAlreadyExists = 'BR_0023',
+  KeyStorageNotSupported = 'BR_0039',
+  OperationNotSupported = 'BR_0062',
+  NoTrustEntityFound = 'BR_0186',
+}

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

@@ -0,0 +1,30 @@
+import { HistoryListQuery } from '@procivis/react-native-one-core';
+import { useInfiniteQuery } from 'react-query';
+
+import { getQueryKeyFromHistoryListQueryParams } from '../../parsers/query';
+import { useONECore } from './core-context';
+
+const PAGE_SIZE = 20;
+export const HISTORY_LIST_QUERY_KEY = 'history-list';
+
+export const useHistory = (queryParams?: Partial<HistoryListQuery>) => {
+  const { core, organisationId } = useONECore();
+
+  return useInfiniteQuery(
+    [HISTORY_LIST_QUERY_KEY, ...getQueryKeyFromHistoryListQueryParams(queryParams)],
+    async ({ pageParam = 0 }) => {
+      const historyPage = await core.getHistory({
+        organisationId,
+        page: pageParam,
+        pageSize: PAGE_SIZE,
+        ...queryParams,
+      });
+
+      return historyPage;
+    },
+    {
+      getNextPageParam: (lastPage, allPages) => (allPages.length < lastPage.totalPages ? allPages.length : undefined),
+      keepPreviousData: true,
+    },
+  );
+};

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

@@ -0,0 +1,13 @@
+export * from './backup';
+export * from './cache';
+export * from './core-config';
+export * from './core-context';
+export * from './core-init';
+export * from './credential-schemas';
+export * from './credentials';
+export * from './dids';
+export * from './history';
+export * from './proof-schemas';
+export * from './proofs';
+export * from './query';
+export * from './trust-entity';

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.removeQueries([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,
+    },
+  );
+};