@opencrvs/mosip 1.7.0-alpha.9 → 1.8.0-alpha.1

package/src/forms.ts

@@ -1,5 +1,3 @@
-// @TODO: Yet to be implemented! Placeholders for NPM publish.
-
 /**
  * E-Signet popup button and hidden field form definitions
  * @example
@@ -17,220 +15,400 @@
  *
  */
 export const esignet = (
-  event: string,
-  sectionId: string,
   esignetAuthUrl: string,
   openIdProviderClientId: string,
-  openIdProviderClaims: string = 'name,family_name,given_name,middle_name,birthdate,address',
+  openIdProviderClaims: string = "name,family_name,given_name,middle_name,birthdate,address",
   fieldName: string,
-  callbackFieldName: string
+  callbackFieldName: string,
 ) => {
   const url = new URL(esignetAuthUrl);
 
   url.searchParams.append(
-    'client_id',
-    openIdProviderClientId || 'mock-client_id'
-  );
-  url.searchParams.append('response_type', 'code');
-  url.searchParams.append('scope', 'openid profile');
-  url.searchParams.append('acr_values', 'mosip:idp:acr:static-code');
-  url.searchParams.append('claims', openIdProviderClaims);
-  url.searchParams.append('state', 'fetch-on-mount');
-  url.searchParams.append(
-    'redirect_uri',
-    '${window.location.origin}/drafts/${window.location.pathname.split("/")[2]}/events/${event}/${sectionId}/group/${sectionId}'
+    "client_id",
+    openIdProviderClientId || "mock-client_id",
   );
+  url.searchParams.append("response_type", "code");
+  url.searchParams.append("scope", "openid profile");
+  url.searchParams.append("acr_values", "mosip:idp:acr:static-code");
+  url.searchParams.append("claims", openIdProviderClaims);
+  url.searchParams.append("state", "fetch-on-mount");
+  url.searchParams.append("redirect_uri", "${window.location.href}");
 
   return {
     name: fieldName,
     validator: [],
     icon: {
-      desktop: 'Globe',
-      mobile: 'Fingerprint'
+      desktop: "Globe",
+      mobile: "Fingerprint",
     },
-    type: 'LINK_BUTTON',
+    type: "LINK_BUTTON",
     custom: true,
     label: {
-      id: 'views.idReader.label.eSignet',
-      defaultMessage: 'E-signet'
+      id: "views.idReader.label.eSignet",
+      defaultMessage: "E-signet",
     },
     hideInPreview: true,
     conditionals: [
       {
-        action: 'disable',
-        expression: '!!$form.redirectCallbackFetch'
-      }
+        action: "disable",
+        expression: "!!$form.redirectCallbackFetch",
+      },
     ],
+    mapping: {
+      mutation: {
+        operation: "ignoreFieldTransformer",
+      },
+    },
     options: {
       url: url.toString(),
       callback: {
         params: {
-          state: 'fetch-on-mount'
+          state: "fetch-on-mount",
         },
-        trigger: callbackFieldName
-      }
-    }
+        trigger: callbackFieldName,
+      },
+    },
   };
 };
 
 export const popupButton = ({
   /** URL to OpenCRVS-MOSIP gateway (e.g. https://opencrvs-mosip-gateway.farajaland.opencrvs.org) */
-  url
+  url,
 }: {
   url: string;
 }) => {
   return {
-    name: 'INFORMANT_AUTHENTICATION_POPUP_BUTTON',
-    type: 'POPUP_BUTTON',
-    url
+    name: "INFORMANT_AUTHENTICATION_POPUP_BUTTON",
+    type: "POPUP_BUTTON",
+    url,
   };
 };
 
 /**
  *
- * @description esignet callback button form definition.  Calls mosip-api/esignet-api /esignet/get-oidp-user-info (this field may not be supported in the latest release of OpenCRVS yet)
+ * @description esignet callback button form definition.  Calls https://mosip-api.{{hostname}}/esignet/get-oidp-user-info
  *
  */
 
 export const esignetCallback = ({
   fieldName,
-  event,
-  sectionId,
-  getOIDPUserInfoUrl,
-  openIdProviderClientId
+  mosipAPIUserInfoUrl,
+  openIdProviderClientId,
 }: {
   fieldName: string;
-  event: string;
-  sectionId: string;
-  getOIDPUserInfoUrl: string;
+  mosipAPIUserInfoUrl: string;
   openIdProviderClientId: string;
 }) => ({
   name: fieldName,
-  type: 'HTTP',
+  type: "HTTP",
   custom: true,
   label: {
-    id: 'form.field.label.empty',
-    defaultMessage: ''
+    id: "form.field.label.empty",
+    defaultMessage: "",
   },
   validator: [],
+  hideInPreview: true,
+  mapping: {
+    mutation: {
+      operation: "ignoreFieldTransformer",
+    },
+  },
   options: {
-    getOIDPUserInfoUrl,
+    url: mosipAPIUserInfoUrl,
     headers: {
-      'Content-type': 'application/json'
+      "Content-type": "application/json",
     },
     body: {
       clientId: openIdProviderClientId,
-      redirectUri:
-        '${window.location.origin}/drafts/${window.location.pathname.split("/")[2]}/events/${event}/${sectionId}/group/${sectionId}'
+      redirectUri: "${window.location.href}",
     },
 
-    method: 'POST'
-  }
+    method: "POST",
+  },
 });
 
 export const esignetHidden = () => {
   return {
-    name: 'INFORMANT_PSUT_TOKEN',
-    type: 'HIDDEN'
+    name: "INFORMANT_PSUT_TOKEN",
+    type: "HIDDEN",
   };
 };
 
-/**
- *
- * @description QR reader type definition (this field may not be supported in the latest release of OpenCRVS yet)
- *
- */
-
 export const idReader = (
   event: string,
   sectionId: string,
   conditionals: any[],
-  readers: any[]
+  readers: any[],
 ) => {
-  const fieldName: string = 'idReader';
+  const fieldName: string = "idReader";
   const fieldId: string = `${event}.${sectionId}.${sectionId}-view-group.${fieldName}`;
   return {
     name: fieldName,
     customQuestionMappingId: fieldId,
     custom: true,
     required: false,
-    type: 'ID_READER',
+    type: "ID_READER",
     label: {
-      id: 'form.field.label.empty',
-      defaultMessage: ''
+      id: "form.field.label.idReader",
+      defaultMessage: "ID verification",
     },
     hideInPreview: true,
-    initialValue: '',
+    initialValue: "",
     validator: [],
     conditionals,
     dividerLabel: {
-      id: 'views.idReader.label.or',
-      defaultMessage: 'Or'
+      id: "views.idReader.label.or",
+      defaultMessage: "Or",
     },
     manualInputInstructionLabel: {
-      id: 'views.idReader.label.manualInput',
-      defaultMessage: 'Complete fields below'
+      id: "views.idReader.label.manualInput",
+      defaultMessage: "Complete fields below",
+    },
+    mapping: {
+      mutation: {
+        operation: "ignoreFieldTransformer",
+      },
     },
-    readers
+    readers,
   };
 };
 
-export const qr = () => ({
-  type: 'QR'
+type MessageDescriptor = {
+  id: string;
+  defaultMessage: string;
+  description?: string;
+};
+
+interface QRValidation {
+  rule: Record<string, unknown>;
+  errorMessage: MessageDescriptor;
+}
+
+interface QRConfig {
+  validation: QRValidation;
+}
+
+export const qr = ({ validation }: QRConfig) => ({
+  type: "QR",
+  validation,
 });
 
-export const verified = (event: string, sectionId: string) => {
-  const fieldName = 'verified';
+interface ESignetConfig {
+  esignetAuthUrl: string;
+  openIdProviderClientId: string;
+  openIdProviderClaims: string | undefined;
+  fieldName: string;
+  callback: {
+    fieldName: string;
+    mosipAPIUserInfoUrl: string;
+  };
+  loaderFieldName?: string;
+}
+
+export const verified = (
+  event: string,
+  sectionId: string,
+  mapping: any,
+  esignetConfig?: ESignetConfig,
+) => {
+  const fieldName = "verified";
   const fieldId = `${event}.${sectionId}.${sectionId}-view-group.${fieldName}`;
   return {
-    name: 'verified',
+    name: "verified",
     fieldId,
     customQuestionMappingId: fieldId,
-    type: 'HIDDEN',
+    type: "HIDDEN",
     custom: true,
     label: {
-      id: 'messages.empty',
-      defaultMessage: ''
-    },
-    initialValue: {
-      dependsOn: ['idReader'],
-      expression: 'Boolean($form?.idReader)? "pending":""'
+      id: "form.field.label.empty",
+      defaultMessage: "",
     },
-    validator: []
+    initialValue: esignetConfig
+      ? {
+          dependsOn: ["idReader", esignetConfig.callback.fieldName],
+          expression: `Boolean($form?.idReader)? "pending"
+          : Boolean($form?.${esignetConfig.callback.fieldName}?.data)? "authenticated"
+          : Boolean($form?.${esignetConfig.callback.fieldName}?.error)? "failedFetchIdDetails"
+          : ""`,
+        }
+      : {
+          dependsOn: ["idReader"],
+          expression: 'Boolean($form?.idReader)? "pending":""',
+        },
+    validator: [],
+    mapping,
   };
 };
 
-export const idPendingVerificationBanner = (
+function capitalize(str: string) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+type VerificationStatus =
+  | "verified"
+  | "failed"
+  | "authenticated"
+  | "failedFetchIdDetails";
+
+export const idVerificationBanner = (
   event: string,
-  sectionId: string
+  sectionId: string,
+  status: VerificationStatus,
+  conditionals: any[] = [],
 ) => {
-  const fieldName = 'verified';
+  const fieldName = "verified";
   const fieldId = `${event}.${sectionId}.${sectionId}-view-group.${fieldName}`;
   return {
-    name: 'idPending',
-    type: 'ID_VERIFICATION_BANNER',
+    name: `id${capitalize(status)}.`,
+    type: "ID_VERIFICATION_BANNER",
     fieldId,
     hideInPreview: true,
     custom: true,
-    bannerType: 'pending',
-    idFieldName: 'idReader',
+    bannerType: status,
+    idFieldName:
+      status === "authenticated" || "failedFetchIdDetails"
+        ? "esignetCallback"
+        : "idReader",
     label: {
-      id: 'messages.empty',
-      defaultMessage: ''
+      id: "form.field.label.empty",
+      defaultMessage: "",
     },
     validator: [],
-    conditionals: [
+    conditionals: conditionals.concat([
       {
-        action: 'hide',
-        expression: '$form?.verified !== "pending"'
-      }
-    ]
+        action: "hide",
+        expression: `$form?.verified !== "${status}"`,
+      },
+    ]),
   };
 };
 
-export const idVerificationFields = (event: string, sectionId: string) => {
+export function esignetLoaderField({
+  event,
+  section,
+  fieldName,
+  esignetCallbackFieldName,
+}: {
+  event: "birth" | "death";
+  section: "informant" | "mother" | "father" | "spouse" | "deceased";
+  fieldName: string;
+  esignetCallbackFieldName: string;
+}) {
+  const fieldId = `${event}.${section}.${section}-view-group.${fieldName}`;
+  return {
+    name: fieldName,
+    type: "LOADER",
+    fieldId,
+    hideInPreview: true,
+    custom: true,
+    label: {
+      id: "form.field.label.idReader",
+      defaultMessage: "ID verification",
+    },
+    loadingText: {
+      id: "form.field.label.authenticating.nid",
+      defaultMessage: "Fetching the person's data from E-Signet",
+    },
+    conditionals: [
+      {
+        action: "hide",
+        expression: `!$form?.${esignetCallbackFieldName}?.loading`,
+      },
+    ],
+  };
+}
+
+export const getInitialValueFromIDReader = (fieldNameInReader: string) => ({
+  dependsOn: ["idReader", "esignetCallback"],
+  expression: `$form?.idReader?.${fieldNameInReader} || $form?.esignetCallback?.data?.${fieldNameInReader} || ""`,
+});
+
+export const idReaderFields = (
+  event: "birth" | "death",
+  section: "informant" | "mother" | "father" | "spouse" | "deceased",
+  qrConfig: QRConfig,
+  esignetConfig: ESignetConfig | undefined,
+  verifiedCustomFieldMapping: any,
+  conditionals: any[] = [],
+) => {
+  const readers: any[] = [qr(qrConfig)];
+  const fields: any[] = [
+    idReader(
+      event,
+      section,
+      conditionals.concat({
+        action: "hide",
+        expression:
+          "$form?.verified === 'verified' || $form?.verified === 'authenticated' || $form?.verified === 'failed' || $form?.verified === 'failedFetchIdDetails' || !!$form?.esignetCallback?.loading",
+      }),
+      readers,
+    ),
+  ];
+  if (esignetConfig) {
+    readers.push(
+      esignet(
+        esignetConfig.esignetAuthUrl,
+        esignetConfig.openIdProviderClientId,
+        esignetConfig.openIdProviderClaims,
+        esignetConfig.fieldName,
+        esignetConfig.callback.fieldName,
+      ),
+    );
+    fields.push(
+      esignetCallback({
+        fieldName: esignetConfig.callback.fieldName,
+        mosipAPIUserInfoUrl: esignetConfig.callback.mosipAPIUserInfoUrl,
+        openIdProviderClientId: esignetConfig.openIdProviderClientId,
+      }),
+    );
+    if (esignetConfig.loaderFieldName) {
+      fields.push(
+        esignetLoaderField({
+          event,
+          section,
+          fieldName: esignetConfig.loaderFieldName,
+          esignetCallbackFieldName: esignetConfig.callback.fieldName,
+        }),
+      );
+    }
+    return [
+      ...fields,
+      ...idVerificationFields(
+        event,
+        section,
+        verifiedCustomFieldMapping,
+        conditionals,
+        esignetConfig,
+      ),
+    ];
+  }
+  return [
+    ...fields,
+    ...idVerificationFields(
+      event,
+      section,
+      verifiedCustomFieldMapping,
+      conditionals,
+    ),
+  ];
+};
+export const idVerificationFields = (
+  event: string,
+  sectionId: string,
+  mapping: any,
+  conditionals: any[] = [],
+  esignetConfig?: ESignetConfig,
+) => {
   return [
-    verified(event, sectionId),
-    idPendingVerificationBanner(event, sectionId)
+    verified(event, sectionId, mapping, esignetConfig),
+    idVerificationBanner(event, sectionId, "verified", conditionals),
+    idVerificationBanner(event, sectionId, "failed", conditionals),
+    idVerificationBanner(event, sectionId, "authenticated", conditionals),
+    idVerificationBanner(
+      event,
+      sectionId,
+      "failedFetchIdDetails",
+      conditionals,
+    ),
   ];
 };

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from "./forms";
 export * from "./events";
+export * from "./transform";

package/src/transform.ts

@@ -0,0 +1,92 @@
+type IdentityInfo = { value: string; language: string };
+
+export interface MOSIPPayload {
+  compositionId: string;
+  trackingId: string;
+  notification: {
+    recipientFullName: string;
+    recipientEmail: string;
+    recipientPhone: string;
+  };
+  requestFields: {
+    fullName: string;
+    dateOfBirth: string;
+    gender: string;
+    guardianOrParentName: string;
+    nationalIdNumber: string;
+    passportNumber: string;
+    drivingLicenseNumber: string;
+    deceasedStatus: boolean;
+    residenceStatus: string;
+    vid: string;
+    email: string;
+    phone: string;
+    guardianOrParentBirthCertificateNumber: string;
+    birthCertificateNumber: string;
+    addressLine1: string;
+    addressLine2: string;
+    addressLine3: string;
+    district: string;
+    village: string;
+    birthRegistrationCertificate: string;
+    passportId: string;
+    nationalId: string;
+    drivingLicenseId: string;
+    addressProof: string;
+    selectedHandles: string;
+    UIN: string;
+    deathDeclared: string;
+    dateOfDeath: string;
+  };
+  audit: {
+    uuid: string;
+    createdAt: string;
+    eventId: string;
+    eventName: string;
+    eventType: string;
+    hostName: string;
+    hostIp: string;
+    applicationId: string;
+    applicationName: string;
+    sessionUserId: string;
+    sessionUserName: string;
+    id: string;
+    idType: string;
+    createdBy: string;
+    moduleName: string;
+    moduleId: string;
+    description: string;
+    actionTimeStamp: string;
+  };
+}
+
+type Resolver<T> = (bundle: fhir3.Bundle) => T;
+
+type ResolverMap<T> = {
+  [K in keyof T]?: T[K] extends IdentityInfo[] | string | boolean | number
+    ? Resolver<T[K]>
+    : ResolverMap<T[K]>;
+};
+
+export function fhirBundleToMOSIPPayload(
+  bundle: fhir3.Bundle,
+  resolverMap: ResolverMap<MOSIPPayload>,
+): MOSIPPayload {
+  const assignResolvers = <T extends object>(resolvers: ResolverMap<T>): T => {
+    const result = {} as T;
+
+    for (const key in resolvers) {
+      const resolver = resolvers[key];
+
+      if (typeof resolver === "function") {
+        result[key] = resolver(bundle);
+      } else if (resolver && typeof resolver === "object") {
+        result[key] = assignResolvers(resolver) as T[Extract<keyof T, string>];
+      }
+    }
+
+    return result;
+  };
+
+  return assignResolvers(resolverMap);
+}

package/tsconfig.json

@@ -8,4 +8,4 @@
     "declaration": true,
     "outDir": "./build"
   }
-}
+}