@opencrvs/toolkit 1.8.0-rc.fca3e39 → 1.8.0-rc.fcf46fc

package/dist/commons/events/utils.d.ts

@@ -1,93 +1,49 @@
-import { TranslationConfig } from './TranslationConfig';
-import { ActionType } from './ActionType';
+import { ActionType, DeclarationActionType } from './ActionType';
 import { EventConfig } from './EventConfig';
-import { EventConfigInput } from './EventConfigInput';
-import { EventMetadataKeys } from './EventMetadata';
 import { FieldConfig } from './FieldConfig';
 import { WorkqueueConfig } from './WorkqueueConfig';
-import { EventState } from './ActionDocument';
-import { FormConfig } from './FormConfig';
+import { Action, ActionUpdate, EventState } from './ActionDocument';
+import { PageConfig, VerificationPageConfig } from './PageConfig';
 import { Draft } from './Draft';
 import { EventDocument } from './EventDocument';
-/**
- * @returns All the fields in the event configuration input.
- */
-export declare const findInputPageFields: (config: EventConfigInput) => {
-    id: string;
-    label: TranslationConfig;
-}[];
-/**
- * @returns All the fields in the event configuration.
- */
-export declare const findPageFields: (config: EventConfig) => FieldConfig[];
-/**
- *
- * @param pageFields - All the fields in the event configuration
- * @param refFields - The fields referencing values within the event configuration (e.g. summary fields) or within system provided metadata fields (e.g. createdAt, updatedBy)
- * @returns referenced fields with populated labels
- */
-export declare const resolveLabelsFromKnownFields: ({ pageFields, refFields }: {
-    pageFields: {
-        id: string;
-        label: TranslationConfig;
-    }[];
-    refFields: {
-        id: EventMetadataKeys | string;
-        label?: TranslationConfig;
-    }[];
-}) => {
-    id: EventMetadataKeys | string;
-    label?: TranslationConfig;
-}[];
-export declare function getAllFields(configuration: EventConfig): import("./FieldConfig").Inferred[];
-export declare function getAllPages(configuration: EventConfig): {
+import { ActionConfig } from './ActionConfig';
+import { FormConfig } from './FormConfig';
+export declare function getDeclarationFields(configuration: EventConfig): FieldConfig[];
+export declare function getDeclarationPages(configuration: EventConfig): {
+    type: "FORM";
     id: string;
-    title: TranslationConfig;
+    title: import("./TranslationConfig").TranslationConfig;
     fields: import("./FieldConfig").Inferred[];
+    conditional?: import(".").JSONSchema | undefined;
 }[];
-export declare function validateWorkqueueConfig(workqueueConfigs: WorkqueueConfig[]): void;
-export declare const findActiveActionForm: (configuration: EventConfig, action: ActionType) => {
-    active: boolean;
-    version: {
-        id: string;
-        label: TranslationConfig;
-    };
-    label: TranslationConfig;
+export declare function getDeclaration(configuration: EventConfig): {
+    label: import("./TranslationConfig").TranslationConfig;
     pages: {
+        type: "FORM";
         id: string;
-        title: TranslationConfig;
+        title: import("./TranslationConfig").TranslationConfig;
         fields: import("./FieldConfig").Inferred[];
+        conditional?: import(".").JSONSchema | undefined;
     }[];
-    review: {
-        title: TranslationConfig;
-        fields: import("./FieldConfig").Inferred[];
-    };
-} | undefined;
-export declare const findActiveActionFormPages: (configuration: EventConfig, action: ActionType) => {
-    id: string;
-    title: TranslationConfig;
-    fields: import("./FieldConfig").Inferred[];
-}[] | undefined;
-export declare const getFormFields: (formConfig: FormConfig) => import("./FieldConfig").Inferred[];
+};
+export declare const getActionAnnotationFields: (actionConfig: ActionConfig) => import("./FieldConfig").Inferred[];
+export declare const getAllAnnotationFields: (config: EventConfig) => FieldConfig[];
 /**
- * Returns only form fields for the action type, if any, excluding review fields.
+ * @returns All the fields in the event configuration.
  */
-export declare const findActiveActionFormFields: (configuration: EventConfig, action: ActionType) => FieldConfig[] | undefined;
+export declare const findAllFields: (config: EventConfig) => FieldConfig[];
 /**
- * Returns all fields for the action type, including review fields, if any.
+ * @TODO: Request correction should have same format as print certificate
  */
-export declare const findActiveActionFields: (configuration: EventConfig, action: ActionType) => FieldConfig[] | undefined;
-export declare const getActiveActionFormPages: (configuration: EventConfig, action: ActionType) => {
-    id: string;
-    title: TranslationConfig;
+export declare const findRecordActionPages: (config: EventConfig, actionType: ActionType) => PageConfig[];
+export declare function getActionReview(configuration: EventConfig, actionType: ActionType): {
+    title: import("./TranslationConfig").TranslationConfig;
     fields: import("./FieldConfig").Inferred[];
-}[];
-/**
- * Returns all fields for the action type, including review fields, or throws
- */
-export declare function getActiveActionFields(configuration: EventConfig, action: ActionType): FieldConfig[];
-export declare function getEventConfiguration(eventConfigurations: EventConfig[], type: string): EventConfig;
-export declare function stripHiddenFields(fields: FieldConfig[], data: EventState): import("lodash").Dictionary<string | number | boolean | {
+};
+export declare function getActionReviewFields(configuration: EventConfig, actionType: DeclarationActionType): import("./FieldConfig").Inferred[];
+export declare function validateWorkqueueConfig(workqueueConfigs: WorkqueueConfig[]): void;
+export declare function isPageVisible(page: PageConfig, formValues: ActionUpdate): boolean;
+export declare function omitHiddenFields(fields: FieldConfig[], values: EventState): import("lodash").Dictionary<string | number | boolean | {
     type: string;
     filename: string;
     originalFilename: string;
@@ -124,15 +80,56 @@ export declare function stripHiddenFields(fields: FieldConfig[], data: EventStat
     option: string;
     filename: string;
     originalFilename: string;
-}[]>;
+}[] | undefined>;
+export declare function omitHiddenPaginatedFields(formConfig: FormConfig, declaration: EventState): import("lodash").Dictionary<string | number | boolean | {
+    type: string;
+    filename: string;
+    originalFilename: string;
+} | {
+    country: string;
+    district: string;
+    addressType: "DOMESTIC";
+    province: string;
+    urbanOrRural: "URBAN";
+    number?: string | undefined;
+    town?: string | undefined;
+    residentialArea?: string | undefined;
+    street?: string | undefined;
+    zipCode?: string | undefined;
+} | {
+    country: string;
+    district: string;
+    addressType: "DOMESTIC";
+    province: string;
+    urbanOrRural: "RURAL";
+    village?: string | undefined;
+} | {
+    country: string;
+    state: string;
+    addressType: "INTERNATIONAL";
+    district2: string;
+    cityOrTown?: string | undefined;
+    addressLine1?: string | undefined;
+    addressLine2?: string | undefined;
+    addressLine3?: string | undefined;
+    postcodeOrZip?: string | undefined;
+} | {
+    type: string;
+    option: string;
+    filename: string;
+    originalFilename: string;
+}[] | undefined>;
 export declare function findActiveDrafts(event: EventDocument, drafts: Draft[]): {
     id: string;
     createdAt: string;
     eventId: string;
     transactionId: string;
     action: {
-        type: ActionType;
-        data: Record<string, string | number | boolean | {
+        type: "DECLARE" | "REGISTER" | "VALIDATE" | "DELETE" | "CREATE" | "NOTIFY" | "DETECT_DUPLICATE" | "REJECT" | "MARKED_AS_DUPLICATE" | "ARCHIVE" | "PRINT_CERTIFICATE" | "REQUEST_CORRECTION" | "REJECT_CORRECTION" | "APPROVE_CORRECTION" | "READ" | "ASSIGN" | "UNASSIGN";
+        status: "Rejected" | "Requested" | "Accepted";
+        createdAt: string;
+        createdBy: string;
+        declaration: Record<string, string | number | boolean | {
             type: string;
             filename: string;
             originalFilename: string;
@@ -169,11 +166,9 @@ export declare function findActiveDrafts(event: EventDocument, drafts: Draft[]):
             option: string;
             filename: string;
             originalFilename: string;
-        }[]>;
-        createdAt: string;
-        createdBy: string;
+        }[] | undefined>;
         createdAtLocation: string;
-        metadata?: Record<string, string | number | boolean | {
+        annotation?: Record<string, string | number | boolean | {
             type: string;
             filename: string;
             originalFilename: string;
@@ -210,7 +205,8 @@ export declare function findActiveDrafts(event: EventDocument, drafts: Draft[]):
             option: string;
             filename: string;
             originalFilename: string;
-        }[]> | undefined;
+        }[] | undefined> | undefined;
+        originalActionId?: string | undefined;
     };
 }[];
 export declare function createEmptyDraft(eventId: string, draftId: string, actionType: ActionType): {
@@ -220,11 +216,21 @@ export declare function createEmptyDraft(eventId: string, draftId: string, actio
     transactionId: import("../uuid").UUID;
     action: {
         type: ActionType;
-        data: {};
-        metadata: {};
+        declaration: {};
+        annotation: {};
         createdAt: string;
         createdBy: string;
         createdAtLocation: string;
     };
 };
+export declare function isVerificationPage(page: PageConfig): page is VerificationPageConfig;
+export declare function deepMerge<T extends Record<string, unknown>>(currentDocument: T, actionDocument: T): T;
+export declare function findLastAssignmentAction(actions: Action[]): Action | undefined;
+/** Tell compiler that accessing record with arbitrary key might result to undefined
+ * Use when you **cannot guarantee**  that key exists in the record
+ */
+export type IndexMap<T> = {
+    [id: string]: T | undefined;
+};
+export declare function isWriteAction(actionType: ActionType): boolean;
 //# sourceMappingURL=utils.d.ts.map

package/dist/commons/events/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/conditionals/index.js

@@ -23,8 +23,10 @@ __export(conditionals_exports, {
   alwaysTrue: () => alwaysTrue,
   and: () => and,
   defineConditional: () => defineConditional,
+  defineFormConditional: () => defineFormConditional,
   event: () => event,
   field: () => field,
+  never: () => never,
   not: () => not,
   or: () => or,
   user: () => user
@@ -35,6 +37,16 @@ module.exports = __toCommonJS(conditionals_exports);
 function defineConditional(schema) {
   return schema;
 }
+function defineFormConditional(schema) {
+  const schemaWithForm = {
+    type: "object",
+    properties: {
+      $form: schema
+    },
+    required: ["$form"]
+  };
+  return defineConditional(schemaWithForm);
+}
 function alwaysTrue() {
   return {};
 }
@@ -59,6 +71,9 @@ function not(condition) {
     required: []
   });
 }
+function never() {
+  return not(alwaysTrue());
+}
 var user = {
   hasScope: (scope) => defineConditional({
     type: "object",
@@ -106,69 +121,120 @@ var event = {
     required: ["$event"]
   })
 };
+function getDateFromNow(days) {
+  return new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
+}
+function getDateRangeToFieldReference(fieldId, comparedFieldId, clause) {
+  return {
+    type: "object",
+    properties: {
+      [fieldId]: {
+        type: "string",
+        format: "date",
+        [clause]: { $data: `1/${comparedFieldId}` }
+      },
+      [comparedFieldId]: { type: "string", format: "date" }
+    },
+    required: [fieldId]
+  };
+}
+function isFieldReference(value) {
+  return typeof value === "object" && value !== null && "_fieldId" in value;
+}
 function field(fieldId) {
-  const getDateFromNow = (days) => new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
   const getDateRange = (date, clause) => ({
     type: "object",
     properties: {
-      $form: {
-        type: "object",
-        properties: {
-          [fieldId]: {
-            type: "string",
-            format: "date",
-            [clause]: date
-          }
-        },
-        required: [fieldId]
+      [fieldId]: {
+        type: "string",
+        format: "date",
+        [clause]: date
       }
     },
-    required: ["$form"]
+    required: [fieldId]
   });
   return {
+    /**
+     * @private Internal property used for field reference tracking.
+     */
+    _fieldId: fieldId,
     isAfter: () => ({
       days: (days) => ({
-        inPast: () => defineConditional(
+        inPast: () => defineFormConditional(
           getDateRange(getDateFromNow(days), "formatMinimum")
         ),
-        inFuture: () => defineConditional(
+        inFuture: () => defineFormConditional(
           getDateRange(getDateFromNow(-days), "formatMinimum")
         )
       }),
-      date: (date) => defineConditional(getDateRange(date, "formatMinimum")),
-      now: () => defineConditional(getDateRange(getDateFromNow(0), "formatMinimum"))
+      date: (date) => {
+        if (isFieldReference(date)) {
+          const comparedFieldId = date._fieldId;
+          return defineFormConditional(
+            getDateRangeToFieldReference(
+              fieldId,
+              comparedFieldId,
+              "formatMinimum"
+            )
+          );
+        }
+        return defineFormConditional(getDateRange(date, "formatMinimum"));
+      },
+      now: () => defineFormConditional(getDateRange(getDateFromNow(0), "formatMinimum"))
     }),
     isBefore: () => ({
       days: (days) => ({
-        inPast: () => defineConditional(
+        inPast: () => defineFormConditional(
           getDateRange(getDateFromNow(days), "formatMaximum")
         ),
-        inFuture: () => defineConditional(
+        inFuture: () => defineFormConditional(
           getDateRange(getDateFromNow(-days), "formatMaximum")
         )
       }),
-      date: (date) => defineConditional(getDateRange(date, "formatMaximum")),
-      now: () => defineConditional(getDateRange(getDateFromNow(0), "formatMaximum"))
+      date: (date) => {
+        if (isFieldReference(date)) {
+          const comparedFieldId = date._fieldId;
+          return defineFormConditional(
+            getDateRangeToFieldReference(
+              fieldId,
+              comparedFieldId,
+              "formatMaximum"
+            )
+          );
+        }
+        return defineFormConditional(getDateRange(date, "formatMaximum"));
+      },
+      now: () => defineFormConditional(getDateRange(getDateFromNow(0), "formatMaximum"))
     }),
-    isEqualTo: (value) => defineConditional({
-      type: "object",
-      properties: {
-        $form: {
+    isEqualTo: (value) => {
+      if (isFieldReference(value)) {
+        const comparedFieldId = value._fieldId;
+        return defineFormConditional({
           type: "object",
           properties: {
             [fieldId]: {
-              oneOf: [
-                { type: "string", const: value },
-                { type: "boolean", const: value }
-              ],
-              const: value
-            }
+              type: ["string", "boolean"],
+              const: { $data: `1/${comparedFieldId}` }
+            },
+            [comparedFieldId]: { type: ["string", "boolean"] }
           },
-          required: [fieldId]
-        }
-      },
-      required: ["$form"]
-    }),
+          required: [fieldId, comparedFieldId]
+        });
+      }
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [fieldId]: {
+            oneOf: [
+              { type: "string", const: value },
+              { type: "boolean", const: value }
+            ],
+            const: value
+          }
+        },
+        required: [fieldId]
+      });
+    },
     /**
      * Use case: Some fields are rendered when selection is not made, or boolean false is explicitly selected.
      * @example field('recommender.none').isFalsy() vs not(field('recommender.none').isEqualTo(true))
@@ -177,85 +243,87 @@ function field(fieldId) {
      * NOTE: For now, this only works with string, boolean, and null types. 0 is still allowed.
      *
      */
-    isFalsy: () => defineConditional({
+    isFalsy: () => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              anyOf: [
-                { const: "undefined" },
-                { const: false },
-                { const: null },
-                { const: "" }
-              ]
-            }
-          },
+        [fieldId]: {
           anyOf: [
-            {
-              required: [fieldId]
-            },
-            {
-              not: {
-                required: [fieldId]
-              }
-            }
+            { const: "undefined" },
+            { const: false },
+            { const: null },
+            { const: "" }
           ]
         }
       },
-      required: ["$form"]
-    }),
-    isUndefined: () => defineConditional({
-      type: "object",
-      properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              enum: ["undefined"]
-            }
-          },
+      anyOf: [
+        {
+          required: [fieldId]
+        },
+        {
           not: {
             required: [fieldId]
           }
         }
+      ]
+    }),
+    isUndefined: () => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "string",
+          enum: ["undefined"]
+        }
       },
-      required: ["$form"]
+      not: {
+        required: [fieldId]
+      }
     }),
-    inArray: (values) => defineConditional({
+    inArray: (values) => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              enum: values
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          enum: values
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     }),
-    isValidEnglishName: () => defineConditional({
+    isValidEnglishName: () => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              pattern: "^[\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*( [\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*)*$",
-              description: "Name must contain only letters, numbers, and allowed special characters ('._-). No double spaces."
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          pattern: "^[\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*( [\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*)*$",
+          description: "Name must contain only letters, numbers, and allowed special characters ('._-). No double spaces."
+        }
+      },
+      required: [fieldId]
+    }),
+    /**
+     * Checks if the field value matches a given regular expression pattern.
+     * @param pattern - The regular expression pattern to match the field value against.
+     * @returns A JSONSchema conditional that validates the field value against the pattern.
+     */
+    matches: (pattern) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "string",
+          pattern
+        }
+      },
+      required: [fieldId]
+    }),
+    isBetween: (min, max) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "number",
+          minimum: min,
+          maximum: max
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     })
   };
 }