@opencrvs/toolkit 1.8.1-rc.008155b → 1.8.1-rc.020858b

package/dist/events/index.js

@@ -134,6 +134,7 @@ __export(events_exports, {
   METADATA_FIELD_PREFIX: () => METADATA_FIELD_PREFIX,
   MarkedAsDuplicateActionInput: () => MarkedAsDuplicateActionInput,
   MimeType: () => MimeType,
+  NameConfig: () => NameConfig,
   NameFieldUpdateValue: () => NameFieldUpdateValue,
   NameFieldValue: () => NameFieldValue,
   NonEmptyTextValue: () => NonEmptyTextValue,
@@ -171,6 +172,7 @@ __export(events_exports, {
   TENNIS_CLUB_MEMBERSHIP: () => TENNIS_CLUB_MEMBERSHIP,
   TEST_SYSTEM_IANA_TIMEZONE: () => TEST_SYSTEM_IANA_TIMEZONE,
   TestUserRole: () => TestUserRole,
+  TextField: () => TextField,
   TextValue: () => TextValue,
   TimeValue: () => TimeValue,
   TranslationConfig: () => TranslationConfig,
@@ -200,6 +202,7 @@ __export(events_exports, {
   annotationActions: () => annotationActions,
   applyDeclarationToEventIndex: () => applyDeclarationToEventIndex,
   applyDraftsToEventIndex: () => applyDraftsToEventIndex,
+  areCertificateConditionsMet: () => areCertificateConditionsMet,
   areConditionsMet: () => areConditionsMet,
   compositeFieldTypes: () => compositeFieldTypes,
   createEmptyDraft: () => createEmptyDraft,
@@ -262,6 +265,7 @@ __export(events_exports, {
   getDeclarationPages: () => getDeclarationPages,
   getEventConfigById: () => getEventConfigById,
   getMixedPath: () => getMixedPath,
+  getOnlyVisibleFormValues: () => getOnlyVisibleFormValues,
   getPrintCertificatePages: () => getPrintCertificatePages,
   getRandomDate: () => getRandomDate,
   getRandomDatetime: () => getRandomDatetime,
@@ -323,6 +327,7 @@ __export(events_exports, {
   or: () => or,
   resolveDateOfEvent: () => resolveDateOfEvent,
   runFieldValidations: () => runFieldValidations,
+  runStructuralValidations: () => runStructuralValidations,
   timePeriodToDateRange: () => timePeriodToDateRange,
   user: () => user,
   validate: () => validate,
@@ -609,13 +614,13 @@ var UrbanAddressUpdateValue = AdminStructure.extend({
   zipCode: import_zod5.z.string().nullish()
 });
 var NameFieldValue = import_zod5.z.object({
-  firstname: import_zod5.z.string().min(1),
-  surname: import_zod5.z.string().min(1),
+  firstname: import_zod5.z.string(),
+  surname: import_zod5.z.string(),
   middlename: import_zod5.z.string().optional()
 });
 var NameFieldUpdateValue = import_zod5.z.object({
-  firstname: import_zod5.z.string().nullish(),
-  surname: import_zod5.z.string().nullish(),
+  firstname: import_zod5.z.string(),
+  surname: import_zod5.z.string(),
   middlename: import_zod5.z.string().nullish()
 }).or(import_zod5.z.null()).or(import_zod5.z.undefined());
 var RuralAddressUpdateValue = AdminStructure.extend({
@@ -912,18 +917,32 @@ var SelectDateRangeField = BaseField.extend({
   defaultValue: SelectDateRangeValue.optional(),
   options: import_zod7.z.array(SelectDateRangeOption).describe("A list of options")
 }).describe("Select input with date range options");
+var NameConfig = import_zod7.z.object({
+  firstname: import_zod7.z.object({ required: import_zod7.z.boolean() }).optional(),
+  middlename: import_zod7.z.object({ required: import_zod7.z.boolean() }).optional(),
+  surname: import_zod7.z.object({ required: import_zod7.z.boolean() }).optional()
+});
 var NameField = BaseField.extend({
   type: import_zod7.z.literal(FieldType.NAME),
   defaultValue: import_zod7.z.object({
-    firstname: NonEmptyTextValue,
-    surname: NonEmptyTextValue
+    firstname: NonEmptyTextValue.optional(),
+    middlename: NonEmptyTextValue.optional(),
+    surname: NonEmptyTextValue.optional()
   }).optional(),
   configuration: import_zod7.z.object({
+    name: NameConfig.default({
+      firstname: { required: true },
+      surname: { required: true }
+    }).optional(),
     maxLength: import_zod7.z.number().optional().describe("Maximum length of the text"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional(),
-    includeMiddlename: import_zod7.z.boolean().default(false).optional().describe("To make middle name visible in Name form field"),
     searchMode: import_zod7.z.boolean().optional()
+  }).default({
+    name: {
+      firstname: { required: true },
+      surname: { required: true }
+    }
   }).optional()
 }).describe("Name input field");
 var PhoneField = BaseField.extend({
@@ -1225,7 +1244,8 @@ var CertificateConfig = import_zod11.z.object({
     delayed: import_zod11.z.number()
   }),
   svgUrl: import_zod11.z.string(),
-  fonts: import_zod11.z.record(FontFamily).optional()
+  fonts: import_zod11.z.record(FontFamily).optional(),
+  conditionals: import_zod11.z.array(ShowConditional).optional()
 });
 var CertificateTemplateConfig = CertificateConfig.extend({
   hash: import_zod11.z.string().optional(),
@@ -2055,7 +2075,7 @@ var ResolvedUser = import_zod19.z.object({
 });
 
 // ../commons/src/conditionals/validate.ts
-var import_ajv = __toESM(require("ajv"));
+var import__ = __toESM(require("ajv/dist/2019"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
 var import_date_fns = require("date-fns");
 
@@ -2269,9 +2289,11 @@ var isNonInteractiveFieldType = (field2) => {
 };
 
 // ../commons/src/conditionals/validate.ts
-var ajv = new import_ajv.default({
+var ajv = new import__.default({
   $data: true,
-  allowUnionTypes: true
+  allowUnionTypes: true,
+  strict: false
+  // Allow minContains and other newer features
 });
 (0, import_ajv_formats.default)(ajv);
 ajv.addKeyword({
@@ -2335,6 +2357,14 @@ function isFieldConditionMet(field2, form, conditionalType) {
 function isFieldVisible(field2, form) {
   return isFieldConditionMet(field2, form, ConditionalType.SHOW);
 }
+function getOnlyVisibleFormValues(field2, form) {
+  return field2.reduce((acc, f) => {
+    if (isFieldVisible(f, form) && form[f.id] !== void 0) {
+      acc[f.id] = form[f.id];
+    }
+    return acc;
+  }, {});
+}
 function isFieldEmptyAndNotRequired(field2, form) {
   const fieldValue = form[field2.id];
   return !field2.required && (fieldValue === void 0 || fieldValue === "");
@@ -2444,6 +2474,23 @@ function validateFieldInput({
   const rawError = zodType.safeParse(value, { errorMap: zodToIntlErrorMap });
   return rawError.error?.issues.map((issue) => issue.message) ?? [];
 }
+function runStructuralValidations({
+  field: field2,
+  values
+}) {
+  if (!isFieldVisible(field2, values) || isFieldEmptyAndNotRequired(field2, values)) {
+    return {
+      errors: []
+    };
+  }
+  const fieldValidationResult = validateFieldInput({
+    field: field2,
+    value: values[field2.id]
+  });
+  return {
+    errors: fieldValidationResult
+  };
+}
 function runFieldValidations({
   field: field2,
   values
@@ -2509,6 +2556,11 @@ function getValidatorsForField(fieldId, validations) {
     };
   }).filter((x) => x !== null);
 }
+function areCertificateConditionsMet(conditions, values) {
+  return conditions.every((condition) => {
+    return ajv.validate(condition.conditional, values);
+  });
+}
 
 // ../commons/src/utils.ts
 function getOrThrow(x, message) {
@@ -3105,6 +3157,7 @@ function createFieldConditionals(fieldId) {
       properties: {
         [fieldId]: {
           type: "string",
+          minLength: 1,
           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."
         }
@@ -3232,32 +3285,107 @@ function eventFn(fieldId) {
 var event = Object.assign(eventFn, {
   /**
    * Checks if the event contains a specific action type.
+   * Can be used directly as a conditional or chained with additional methods.
    * @param action - The action type to check for.
    */
-  hasAction: (action) => defineConditional({
-    type: "object",
-    properties: {
-      $event: {
+  hasAction: (action) => {
+    const basicConditional = defineConditional({
+      type: "object",
+      properties: {
+        $event: {
+          type: "object",
+          properties: {
+            actions: {
+              type: "array",
+              contains: {
+                type: "object",
+                properties: {
+                  type: {
+                    const: action
+                  }
+                },
+                required: ["type"]
+              }
+            }
+          },
+          required: ["actions"]
+        }
+      },
+      required: ["$event"]
+    });
+    const buildActionConstraints = (additionalFields) => {
+      const actionProperties = {
+        type: { const: action }
+      };
+      const requiredFields = ["type"];
+      if (additionalFields) {
+        Object.entries(additionalFields).forEach(([key, value]) => {
+          actionProperties[key] = { const: value };
+          requiredFields.push(key);
+        });
+      }
+      return { actionProperties, requiredFields };
+    };
+    const createCountConditional = (countType, count, additionalFields) => {
+      const { actionProperties, requiredFields } = buildActionConstraints(additionalFields);
+      return defineConditional({
         type: "object",
         properties: {
-          actions: {
-            type: "array",
-            contains: {
-              type: "object",
-              properties: {
-                type: {
-                  const: action
-                }
-              },
-              required: ["type"]
-            }
+          $event: {
+            type: "object",
+            properties: {
+              actions: {
+                type: "array",
+                contains: {
+                  type: "object",
+                  properties: actionProperties,
+                  required: requiredFields
+                },
+                [countType]: count
+              }
+            },
+            required: ["actions"]
           }
         },
-        required: ["actions"]
-      }
-    },
-    required: ["$event"]
-  }),
+        required: ["$event"]
+      });
+    };
+    const withMinMax = (additionalFields) => {
+      return {
+        /**
+         * Creates a conditional that checks if the event contains a specific action type
+         * with a minimum count of occurrences.
+         *
+         * @param minCount - The minimum number of actions required.
+         */
+        minCount: (minCount) => createCountConditional("minContains", minCount, additionalFields),
+        /**
+         * Builds a conditional that sets a maximum count for the number of actions.
+         * This is useful for limiting the number of actions of a specific type in a single event.
+         */
+        maxCount: (maxCount) => createCountConditional("maxContains", maxCount, additionalFields)
+      };
+    };
+    const chainableMethods = {
+      /**
+       * Adds additional field constraints to the action matching.
+       *
+       * @param fields - Object containing additional fields to match on the action.
+       */
+      withFields: (fields) => withMinMax(fields),
+      /**
+       * Adds template ID constraint to the action matching.
+       * This is a convenience method that adds content.templateId to the fields.
+       *
+       * @param id - The template ID to match against.
+       */
+      withTemplate: (id) => withMinMax({
+        content: { templateId: id }
+      }),
+      ...withMinMax()
+    };
+    return { ...basicConditional, ...chainableMethods };
+  },
   field(field2) {
     return {
       $event: field2
@@ -4245,13 +4373,13 @@ function getAssignedUserSignatureFromActions(actions) {
     return signature;
   }, null);
 }
-function aggregateActionDeclarations(actions) {
+function aggregateActionDeclarations(actions, config) {
   const excludedActions = [
     ActionType.REQUEST_CORRECTION,
     ActionType.PRINT_CERTIFICATE,
     ActionType.REJECT_CORRECTION
   ];
-  return actions.reduce((declaration, action) => {
+  const aggregatedDeclaration = actions.reduce((declaration, action) => {
     if (excludedActions.some((excludedAction) => excludedAction === action.type)) {
       return declaration;
     }
@@ -4264,6 +4392,10 @@ function aggregateActionDeclarations(actions) {
     }
     return deepMerge(declaration, action.declaration);
   }, {});
+  return getOnlyVisibleFormValues(
+    config.declaration.pages.flatMap((x) => x.fields),
+    aggregatedDeclaration
+  );
 }
 function deepDropNulls(obj) {
   if (Array.isArray(obj)) {
@@ -4309,7 +4441,7 @@ function getCurrentEventState(event2, config) {
   );
   const requestActionMetadata = getActionUpdateMetadata(event2.actions);
   const acceptedActionMetadata = getActionUpdateMetadata(acceptedActions);
-  const declaration = aggregateActionDeclarations(acceptedActions);
+  const declaration = aggregateActionDeclarations(acceptedActions, config);
   return deepDropNulls({
     id: event2.id,
     type: event2.type,
@@ -5174,7 +5306,27 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
             defaultMessage: "Applicant's name",
             description: "This is the label for the field",
             id: "v2.event.tennis-club-membership.action.declare.form.section.who.field.firstname.label"
-          }
+          },
+          configuration: {
+            name: {
+              firstname: { required: true },
+              middlename: { required: false },
+              surname: { required: true }
+            }
+          },
+          validation: [
+            {
+              validator: field("applicant.name").object({
+                firstname: field("firstname").isValidEnglishName(),
+                surname: field("surname").isValidEnglishName()
+              }),
+              message: {
+                defaultMessage: "Input contains invalid characters. Please use only letters (a-z, A-Z), numbers (0-9), hyphens (-), apostrophes(') and underscores (_)",
+                description: "This is the error message for invalid name",
+                id: "v2.error.invalidName"
+              }
+            }
+          ]
         },
         {
           id: "applicant.email",
@@ -6847,7 +6999,11 @@ function generateActionDocument({
     case ActionType.NOTIFY:
       return { ...actionBase, type: action };
     case ActionType.PRINT_CERTIFICATE:
-      return { ...actionBase, type: action };
+      return {
+        ...actionBase,
+        type: action,
+        content: defaults.content
+      };
     case ActionType.REQUEST_CORRECTION:
       return { ...actionBase, type: action };
     case ActionType.APPROVE_CORRECTION:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencrvs/toolkit",
-  "version": "1.8.1-rc.008155b",
+  "version": "1.8.1-rc.020858b",
   "description": "OpenCRVS toolkit for building country configurations",
   "license": "MPL-2.0",
   "exports": {

package/tsconfig.json

@@ -19,7 +19,7 @@
       "@opencrvs/commons/events": ["../commons/src/events/index.ts"]
     }
   },
-  "references": [{ "path": "../commons" }],
+  "references": [{ "path": "../commons/tsconfig-commonjs.json" }],
   "include": ["src/**/*.ts"],
   "exclude": ["**/node_modules/**", "dist"]
 }

package/dist/commons/conditionals/conditionals.test.d.ts

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

package/dist/commons/conditionals/validate-address.test.d.ts

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

package/dist/commons/conditionals/validate.test.d.ts

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

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

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