@pagopa/io-react-native-wallet 3.6.2 → 3.6.4

package/src/credentials-catalogue/v1.3.3/fetch-and-parse-catalogue.ts

@@ -1,5 +1,6 @@
 import { getTrustAnchorEntityConfiguration } from "../../trust/v1.0.0/entities"; // TODO: use trust from v1.3.3
 import { type CredentialsCatalogueApi as Api } from "../api";
+import { mapToCredentialsCatalogue } from "./mappers";
 import {
   AuthenticSourceRegistry,
   DigitalCredentialsCatalogueJwt,
@@ -7,50 +8,49 @@ import {
   SchemaRegistry,
   TaxonomyRegistry,
 } from "./types";
-import { mapToCredentialsCatalogue } from "./mappers";
 import { fetchRegistry } from "./utils";
 
 export const fetchAndParseCatalogue: Api["fetchAndParseCatalogue"] = async (
   trustAnchorBaseUrl,
-  { appFetch = fetch } = {}
+  { appFetch = fetch } = {},
 ) => {
   const trustAnchorConfig = await getTrustAnchorEntityConfiguration(
     trustAnchorBaseUrl,
-    { appFetch }
+    { appFetch },
   );
   const trustAnchorJwks = trustAnchorConfig.payload.jwks.keys;
 
   const discovery = await fetchRegistry(
     `${trustAnchorConfig.payload.sub}/.well-known/it-wallet-registry`,
     {
-      schema: RegistryDiscoveryJwt,
-      jwks: trustAnchorJwks,
       appFetch,
-    }
+      jwks: trustAnchorJwks,
+      schema: RegistryDiscoveryJwt,
+    },
   );
   const { endpoints } = discovery.payload;
 
   // Fetch registries necessary to build the full catalogue
   const registries = await Promise.all([
     fetchRegistry(endpoints.credential_catalog, {
-      schema: DigitalCredentialsCatalogueJwt,
-      jwks: trustAnchorJwks,
       appFetch,
+      jwks: trustAnchorJwks,
+      schema: DigitalCredentialsCatalogueJwt,
     }),
     fetchRegistry(endpoints.authentic_sources, {
-      schema: AuthenticSourceRegistry,
-      asJson: true,
       appFetch,
+      asJson: true,
+      schema: AuthenticSourceRegistry,
     }),
     fetchRegistry(endpoints.schema_registry, {
-      schema: SchemaRegistry,
-      asJson: true,
       appFetch,
+      asJson: true,
+      schema: SchemaRegistry,
     }),
     fetchRegistry(endpoints.taxonomy, {
-      schema: TaxonomyRegistry,
-      asJson: true,
       appFetch,
+      asJson: true,
+      schema: TaxonomyRegistry,
     }),
   ]);
 

package/src/credentials-catalogue/v1.3.3/fetch-translations.ts

@@ -1,10 +1,11 @@
 import type { CredentialsCatalogueApi as Api } from "../api";
+
 import { fetchLocaleBundle } from "./utils";
 
 export const fetchTranslations: NonNullable<Api["fetchTranslations"]> = async (
-  { catalogue, authenticSources, taxonomy },
+  { authenticSources, catalogue, taxonomy },
   locales,
-  { appFetch = fetch } = {}
+  { appFetch = fetch } = {},
 ) => {
   const result: Record<string, Record<string, string>> = {};
 
@@ -28,7 +29,7 @@ export const fetchTranslations: NonNullable<Api["fetchTranslations"]> = async (
       if (Object.keys(merged).length > 0) {
         result[locale] = merged;
       }
-    })
+    }),
   );
 
   return result;

package/src/credentials-catalogue/v1.3.3/index.ts

@@ -1,7 +1,8 @@
 import type { CredentialsCatalogueApi } from "../api";
+
+import { getStatusL10nIds } from "../common/get-status-l10n-ids";
 import { fetchAndParseCatalogue } from "./fetch-and-parse-catalogue";
 import { fetchTranslations } from "./fetch-translations";
-import { getStatusL10nIds } from "../common/get-status-l10n-ids";
 
 export const CredentialsCatalogue: CredentialsCatalogueApi = {
   fetchAndParseCatalogue,

package/src/credentials-catalogue/v1.3.3/mappers.ts

@@ -1,10 +1,10 @@
-import { assert } from "../../utils/misc";
-import { keyBy, groupBy } from "../../utils/object";
 import { createMapper } from "../../utils/mappers";
+import { assert } from "../../utils/misc";
+import { groupBy, keyBy } from "../../utils/object";
 import {
-  DigitalCredentialsCatalogue,
-  type CredentialFormat as ApiCredentialFormat,
   type AuthenticSource as ApiAuthenticSource,
+  type CredentialFormat as ApiCredentialFormat,
+  DigitalCredentialsCatalogue,
 } from "../api/DigitalCredentialsCatalogue";
 import {
   AuthenticSourceRegistry,
@@ -33,31 +33,32 @@ export const mapToCredentialsCatalogue = createMapper<
   ]) => {
     const authSourcesById = keyBy(
       authSourceRegistry.authentic_sources,
-      "entity_id"
+      "entity_id",
     );
     const schemasByCredentialType = groupBy(
       schemaRegistry.schemas,
-      "credential_type"
+      "credential_type",
     );
 
     const resolveAuthSource = ({
-      id,
       dataset_id,
+      id,
     }: {
-      id: string;
       dataset_id: string;
+      id: string;
     }): ApiAuthenticSource => {
       const as = authSourcesById.get(id);
       assert(as, `AS ${id} must be present in the Authentic Source Registry`);
       const { ipa_code, organization_name_l10n_id, ...rest } =
         as.organization_info;
       const dataCapability = as.data_capabilities.find(
-        (dc) => dc.dataset_id === dataset_id
+        (dc) => dc.dataset_id === dataset_id,
       );
       return {
+        data_origin_l10n_id: dataCapability?.data_origin_l10n_id,
         id,
-        organization_name_l10n_id,
         organization_code: ipa_code,
+        organization_name_l10n_id,
         user_information_l10n_id: dataCapability?.user_information_l10n_id,
         ...rest,
       };
@@ -67,40 +68,46 @@ export const mapToCredentialsCatalogue = createMapper<
       const schemas = schemasByCredentialType.get(credentialType);
       assert(
         schemas,
-        `Schemas for ${credentialType} must be present in the Schema Registry`
+        `Schemas for ${credentialType} must be present in the Schema Registry`,
       );
       return schemas.map((schema) => ({
-        configuration_id: schema.id, // TODO: [SIW-3978] Fix this, the schema ID does not correspond to configuration_id
-        ...schema,
+        // Since the schema registry does not contain the actual configuration ID, it is composed according
+        // to the IT-Wallet Credential Issuer's convention. Note that this might not be true for every Issuer.
+        configuration_id: `${schema.format.replace(/[+-]/g, "_")}_${schema.credential_type}`,
+        docType: schema.docType,
+        format: schema.format,
+        schema_uri: schema.schema_uri,
+        "schema_uri#integrity": schema["schema_uri#integrity"],
+        vct: schema.vct,
       }));
     };
 
     return {
       ...catalogueJwt.payload,
-      taxonomy_uri: discoveryJwt.payload.endpoints.taxonomy,
-      taxonomy: {
-        id: taxonomyRegistry.id,
-        name_l10n_id: taxonomyRegistry.name_l10n_id,
-        description_l10n_id: taxonomyRegistry.description_l10n_id,
-        domains: taxonomyRegistry.domains,
-        purposes: taxonomyRegistry.purposes,
-        localization: taxonomyRegistry.localization,
-      },
-      localization: catalogueJwt.payload.localization,
       as_localization: authSourceRegistry.localization,
       credentials: catalogueJwt.payload.credentials.map(
         ({ authentic_sources, credential_name_l10n_id, ...credential }) => ({
-          name_l10n_id: credential_name_l10n_id,
-          formats: resolveFormats(credential.credential_type),
           authentic_sources: authentic_sources
             ? authentic_sources.map(resolveAuthSource)
             : [],
+          formats: resolveFormats(credential.credential_type),
+          name_l10n_id: credential_name_l10n_id,
           ...credential,
-        })
+        }),
       ),
+      localization: catalogueJwt.payload.localization,
+      taxonomy: {
+        description_l10n_id: taxonomyRegistry.description_l10n_id,
+        domains: taxonomyRegistry.domains,
+        id: taxonomyRegistry.id,
+        localization: taxonomyRegistry.localization,
+        name_l10n_id: taxonomyRegistry.name_l10n_id,
+        purposes: taxonomyRegistry.purposes,
+      },
+      taxonomy_uri: discoveryJwt.payload.endpoints.taxonomy,
     };
   },
   {
     outputSchema: DigitalCredentialsCatalogue,
-  }
+  },
 );

package/src/credentials-catalogue/v1.3.3/types.ts

@@ -1,147 +1,148 @@
 import * as z from "zod";
+
 import { UnixTime } from "../../utils/zod";
 
 const ASDataCapability = z.object({
-  // required per spec
-  dataset_id: z.string(),
-  intended_purposes: z.array(z.string()),
+  // optional per spec (api_specification required in spec but absent in actual responses)
+  api_specification: z.string().optional(),
   available_claims: z.array(
     z.object({
       claim_name: z.string(),
-      order: z.number(),
       mandatory: z.boolean(),
-    })
+      order: z.number(),
+    }),
   ),
-  domains: z.array(z.string()).optional(),
-  data_origin_l10n_id: z.string(),
-  integration_endpoint: z.string().optional(),
-  integration_method: z.string(),
-  user_information_l10n_id: z.string().optional(),
-  // optional per spec (api_specification required in spec but absent in actual responses)
-  api_specification: z.string().optional(),
   background_color: z.string().optional(),
   contacts: z.array(z.string()).optional(),
+  data_origin_l10n_id: z.string(),
   data_provision: z
     .object({
       deferred_flow: z.boolean(),
       immediate_flow: z.boolean(),
     })
     .optional(),
+  // required per spec
+  dataset_id: z.string(),
+  domains: z.array(z.string()).optional(),
+  integration_endpoint: z.string().optional(),
+  integration_method: z.string(),
+  intended_purposes: z.array(z.string()),
   logo_uri: z.string().optional(),
   "logo_uri#integrity": z.string().optional(),
   service_documentation: z.string().optional(),
   update_frequency: z.string().optional(),
+  user_information_l10n_id: z.string().optional(),
 });
 
 export const AuthenticSource = z.object({
+  data_capabilities: z.array(ASDataCapability),
   entity_id: z.string(),
   organization_info: z.object({
-    // required per spec
-    organization_name_l10n_id: z.string(),
-    organization_type: z.string(),
-    organization_country: z.string(),
-    legal_identifier: z.string(),
-    homepage_uri: z.string(),
     contacts: z.array(z.string()),
-    policy_uri: z.string(),
+    dpa_contact: z.string().optional(),
+    homepage_uri: z.string(),
     // conditional: required for public AS
     ipa_code: z.string().optional(),
-    // conditional: required for private AS
-    tos_uri: z.string().optional(),
+    legal_identifier: z.string(),
+    logo_extended_uri: z.string().optional(),
+    "logo_extended_uri#integrity": z.string().optional(),
     // optional per spec
     logo_uri: z.string().optional(),
     "logo_uri#integrity": z.string().optional(),
-    logo_extended_uri: z.string().optional(),
-    "logo_extended_uri#integrity": z.string().optional(),
-    dpa_contact: z.string().optional(),
+    organization_country: z.string(),
+    // required per spec
+    organization_name_l10n_id: z.string(),
+    organization_type: z.string(),
+    policy_uri: z.string(),
+    // conditional: required for private AS
+    tos_uri: z.string().optional(),
   }),
-  data_capabilities: z.array(ASDataCapability),
 });
 export type AuthenticSource = z.infer<typeof AuthenticSource>;
 
 export const Schema = z.object({
-  id: z.string(),
-  version: z.string(),
   credential_type: z.string(),
-  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
+  description: z.string().optional(),
   docType: z.string().optional(),
-  vct: z.string().optional(),
+  format: z.enum(["dc+sd-jwt", "mso_mdoc"]),
+  id: z.string(),
   schema_uri: z.string(),
   "schema_uri#integrity": z.string(),
-  description: z.string().optional(),
+  vct: z.string().optional(),
+  version: z.string(),
 });
 export type Schema = z.infer<typeof Schema>;
 
 const AdministrativeExpirationUserInfo = z.object({
-  title_l10n_id: z.string(),
   description_l10n_id: z.string(),
+  title_l10n_id: z.string(),
 });
 
 const AllowedState = z
   .object({
-    title_l10n_id: z.string(),
     description_l10n_id: z.string(),
+    title_l10n_id: z.string(),
   })
   .catchall(z.string());
 
 const CredentialIssuer = z.object({
-  id: z.string(),
-  organization_name_l10n_id: z.string(),
-  organization_code: z.string(),
-  organization_country: z.string(),
-  legal_type: z.string().optional(),
   contacts: z.array(z.string()).optional(),
   homepage_uri: z.string().optional(),
+  id: z.string(),
+  issuance_flows: z.object({ deferred_flow: z.boolean() }).optional(),
+  legal_type: z.string().optional(),
   logo_uri: z.string().optional(),
+  organization_code: z.string(),
+  organization_country: z.string(),
+  organization_name_l10n_id: z.string(),
   policy_uri: z.string().optional(),
-  tos_uri: z.string().optional(),
   service_documentation: z.string().optional(),
-  issuance_flows: z.object({ deferred_flow: z.boolean() }).optional(),
+  tos_uri: z.string().optional(),
 });
 
 export const DigitalCredential = z.object({
-  version: z.string(),
-  credential_type: z.string(),
+  administrative_expiration_user_info:
+    AdministrativeExpirationUserInfo.optional(),
+  authentic_sources: z
+    .array(z.object({ dataset_id: z.string(), id: z.string() }))
+    .optional(),
+  authentication: z.object({
+    min_loa: z.string(),
+    supported_schemes: z.array(z.string()),
+    user_auth_required: z.boolean(),
+  }),
+  classes: z.array(z.string()).optional(),
   credential_name_l10n_id: z.string(),
+  credential_type: z.string(),
+  domains: z.array(z.string()).optional(),
+  issuers: z.array(CredentialIssuer),
   legal_type: z.string(),
+  parent_credentials: z.array(z.string()).optional(),
+  purposes: z.array(z.string()),
   restriction_policy: z
     .object({
-      allowed_wallet_ids: z.array(z.string()).optional(),
       allowed_issuer_ids: z.array(z.string()).optional(),
+      allowed_wallet_ids: z.array(z.string()).optional(),
       presentation_flows: z.object({
-        remote: z.boolean(),
         proximity: z.boolean(),
+        remote: z.boolean(),
       }),
     })
     .optional(),
   validity_info: z.object({
-    max_validity_days: z.number(),
-    status_methods: z.array(z.string()),
     administrative_expiration_user_info:
       AdministrativeExpirationUserInfo.optional(),
     allowed_states: z.array(AllowedState),
+    max_validity_days: z.number(),
+    status_methods: z.array(z.string()),
   }),
-  administrative_expiration_user_info:
-    AdministrativeExpirationUserInfo.optional(),
-  authentication: z.object({
-    user_auth_required: z.boolean(),
-    min_loa: z.string(),
-    supported_schemes: z.array(z.string()),
-  }),
-  domains: z.array(z.string()).optional(),
-  classes: z.array(z.string()).optional(),
-  purposes: z.array(z.string()),
-  issuers: z.array(CredentialIssuer),
-  authentic_sources: z
-    .array(z.object({ id: z.string(), dataset_id: z.string() }))
-    .optional(),
-  parent_credentials: z.array(z.string()).optional(),
+  version: z.string(),
 });
 
 const JwtHeader = z.object({
-  typ: z.string(),
   alg: z.string(),
   kid: z.string(),
+  typ: z.string(),
   x5c: z.array(z.string()).optional(),
 });
 
@@ -150,10 +151,10 @@ const JwtHeader = z.object({
  * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#schema-registry
  */
 export const SchemaRegistry = z.object({
-  version: z.string(),
   last_modified: z.string().optional(),
   last_updated: z.string().optional(),
   schemas: z.array(Schema),
+  version: z.string(),
 });
 export type SchemaRegistry = z.infer<typeof SchemaRegistry>;
 
@@ -162,8 +163,8 @@ export type SchemaRegistry = z.infer<typeof SchemaRegistry>;
  * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#authentic-source-registry
  */
 export const AuthenticSourceRegistry = z.object({
+  authentic_sources: z.array(AuthenticSource),
   id: z.string().optional(),
-  version: z.string(),
   last_modified: z.string(),
   localization: z
     .object({
@@ -173,7 +174,7 @@ export const AuthenticSourceRegistry = z.object({
       version: z.string(),
     })
     .optional(),
-  authentic_sources: z.array(AuthenticSource),
+  version: z.string(),
 });
 export type AuthenticSourceRegistry = z.infer<typeof AuthenticSourceRegistry>;
 
@@ -184,9 +185,11 @@ export type AuthenticSourceRegistry = z.infer<typeof AuthenticSourceRegistry>;
 export const DigitalCredentialsCatalogueJwt = z.object({
   header: JwtHeader,
   payload: z.object({
-    iss: z.string(),
+    credentials: z.array(DigitalCredential),
+    exp: UnixTime,
+    iat: UnixTime,
     id: z.string(),
-    version: z.string(),
+    iss: z.string(),
     last_modified: z.string(),
     localization: z
       .object({
@@ -196,9 +199,7 @@ export const DigitalCredentialsCatalogueJwt = z.object({
         version: z.string(),
       })
       .optional(),
-    credentials: z.array(DigitalCredential),
-    iat: UnixTime,
-    exp: UnixTime,
+    version: z.string(),
   }),
 });
 export type DigitalCredentialsCatalogueJwt = z.infer<
@@ -211,23 +212,23 @@ export type DigitalCredentialsCatalogueJwt = z.infer<
  * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#registry-discovery-endpoint
  */
 const RegistryDiscoveryEndpoints = z.object({
-  claims_registry: z.string(),
   authentic_sources: z.string(),
+  claims_registry: z.string(),
   credential_catalog: z.string(),
-  taxonomy: z.string(),
-  schema_registry: z.string(),
-  federation_list_endpoint: z.string(),
   federation_fetch_endpoint: z.string(),
+  federation_list_endpoint: z.string(),
   federation_resolve_endpoint: z.string(),
   federation_trust_mark_status_endpoint: z.string(),
+  schema_registry: z.string(),
+  taxonomy: z.string(),
 });
 
 export const RegistryDiscoveryJwt = z.object({
   header: JwtHeader,
   payload: z.object({
-    registry_version: z.string(),
-    last_updated: z.string(),
     endpoints: RegistryDiscoveryEndpoints,
+    last_updated: z.string(),
+    registry_version: z.string(),
   }),
 });
 export type RegistryDiscoveryJwt = z.infer<typeof RegistryDiscoveryJwt>;
@@ -253,10 +254,10 @@ const TaxonomyClass = z.object({
  * Taxonomy domain containing classes.
  */
 const TaxonomyDomain = z.object({
+  classes: z.array(TaxonomyClass),
+  description_l10n_id: z.string(),
   id: z.string(),
   name_l10n_id: z.string(),
-  description_l10n_id: z.string(),
-  classes: z.array(TaxonomyClass),
 });
 
 /**
@@ -265,9 +266,10 @@ const TaxonomyDomain = z.object({
  * @see https://italia.github.io/eid-wallet-it-docs/releases/1.3.3/en/registry.html#taxonomy
  */
 export const TaxonomyRegistry = z.object({
-  version: z.string(),
-  last_modified: z.string(),
+  description_l10n_id: z.string(),
+  domains: z.array(TaxonomyDomain),
   id: z.string(),
+  last_modified: z.string(),
   localization: z
     .object({
       available_locales: z.array(z.string()),
@@ -277,8 +279,7 @@ export const TaxonomyRegistry = z.object({
     })
     .optional(),
   name_l10n_id: z.string(),
-  description_l10n_id: z.string(),
-  domains: z.array(TaxonomyDomain),
   purposes: z.array(TaxonomyPurpose),
+  version: z.string(),
 });
 export type TaxonomyRegistry = z.infer<typeof TaxonomyRegistry>;

package/src/credentials-catalogue/v1.3.3/utils.ts

@@ -1,12 +1,14 @@
-import * as z from "zod";
 import { decode as decodeJwt, verify } from "@pagopa/io-react-native-jwt";
-import { assert, hasStatusOrThrow } from "../../utils/misc";
-import { IoWalletError } from "../../utils/errors";
+import * as z from "zod";
+
 import type { JWK } from "../../utils/jwk";
 
+import { IoWalletError } from "../../utils/errors";
+import { assert, hasStatusOrThrow } from "../../utils/misc";
+
 type FetchRegistryParams<T> = {
-  schema: z.ZodType<T>;
   appFetch?: GlobalFetch["fetch"];
+  schema: z.ZodType<T>;
 } & ({ asJson: true } | { asJson?: false; jwks: JWK[] });
 
 /**
@@ -23,15 +25,15 @@ type FetchRegistryParams<T> = {
  */
 export const fetchRegistry = async <T>(
   url: string,
-  params: FetchRegistryParams<T>
+  params: FetchRegistryParams<T>,
 ): Promise<T> => {
-  const { schema, appFetch = fetch, asJson = false } = params;
+  const { appFetch = fetch, asJson = false, schema } = params;
 
   const response = await appFetch(url, {
-    method: "GET",
     headers: {
       Accept: asJson ? "application/json" : "application/jose, application/jwt",
     },
+    method: "GET",
   }).then(hasStatusOrThrow(200));
 
   const contentType = response.headers.get("Content-Type");
@@ -53,7 +55,7 @@ export const fetchRegistry = async <T>(
     const signatureJwk = params.jwks.find((jwk) => jwk.kid === headerKid);
     if (!signatureJwk) {
       throw new IoWalletError(
-        `Could not find JWK with kid ${headerKid} in Trust Anchor's Entity Configuration`
+        `Could not find JWK with kid ${headerKid} in Trust Anchor's Entity Configuration`,
       );
     }
     await verify(responseText, signatureJwk);
@@ -64,7 +66,7 @@ export const fetchRegistry = async <T>(
   }
 
   throw new IoWalletError(
-    `Unsupported content-type for ${url}: ${contentType}`
+    `Unsupported content-type for ${url}: ${contentType}`,
   );
 };
 
@@ -81,19 +83,19 @@ export const fetchRegistry = async <T>(
 export const fetchLocaleBundle = async (
   baseUri: string,
   locale: string,
-  appFetch: GlobalFetch["fetch"] = fetch
+  appFetch: GlobalFetch["fetch"] = fetch,
 ): Promise<Record<string, string>> => {
   const url = `${baseUri.replace(/\/$/, "")}/${locale}.json`;
 
   const response = await appFetch(url, {
-    method: "GET",
     headers: { Accept: "application/json" },
+    method: "GET",
   }).then(hasStatusOrThrow(200));
 
   const contentType = response.headers.get("Content-Type");
   if (!contentType?.includes("application/json")) {
     throw new IoWalletError(
-      `Locale bundle at ${url} returned unexpected Content-Type: ${contentType}`
+      `Locale bundle at ${url} returned unexpected Content-Type: ${contentType}`,
     );
   }