@opencrvs/toolkit 1.8.0-rc.f876361 → 1.8.0-rc.f89fbcb

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

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

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

@@ -0,0 +1,3 @@
+import { WorkqueueColumn } from './WorkqueueColumnConfig';
+export declare const defaultWorkqueueColumns: WorkqueueColumn[];
+//# sourceMappingURL=workqueueDefaultColumns.d.ts.map

package/dist/conditionals/index.js

@@ -22,19 +22,48 @@ var conditionals_exports = {};
 __export(conditionals_exports, {
   alwaysTrue: () => alwaysTrue,
   and: () => and,
+  createEventConditionals: () => createEventConditionals,
+  createFieldConditionals: () => createFieldConditionals,
   defineConditional: () => defineConditional,
-  event: () => event,
-  field: () => field,
+  defineFormConditional: () => defineFormConditional,
+  never: () => never,
   not: () => not,
   or: () => or,
   user: () => user
 });
 module.exports = __toCommonJS(conditionals_exports);
 
+// ../commons/src/events/serializers/user/serializer.ts
+var import_zod = require("zod");
+var SerializedUserField = import_zod.z.object({
+  $userField: import_zod.z.enum([
+    "id",
+    "name",
+    "role",
+    "signatureFilename",
+    "primaryOfficeId"
+  ])
+});
+function userSerializer(userField) {
+  return {
+    $userField: userField
+  };
+}
+
 // ../commons/src/conditionals/conditionals.ts
 function defineConditional(schema) {
   return schema;
 }
+function defineFormConditional(schema) {
+  const schemaWithForm = {
+    type: "object",
+    properties: {
+      $form: schema
+    },
+    required: ["$form"]
+  };
+  return defineConditional(schemaWithForm);
+}
 function alwaysTrue() {
   return {};
 }
@@ -59,7 +88,10 @@ function not(condition) {
     required: []
   });
 }
-var user = {
+function never() {
+  return not(alwaysTrue());
+}
+var user = Object.assign(userSerializer, {
   hasScope: (scope) => defineConditional({
     type: "object",
     properties: {
@@ -79,127 +111,154 @@ var user = {
     },
     required: ["$user"]
   })
-};
-var event = {
-  hasAction: (action) => defineConditional({
+});
+function createEventConditionals() {
+  return {
+    /**
+     * Checks if the event contains a specific action type.
+     * @param action - The action type to check for.
+     */
+    hasAction: (action) => defineConditional({
+      type: "object",
+      properties: {
+        $event: {
+          type: "object",
+          properties: {
+            actions: {
+              type: "array",
+              contains: {
+                type: "object",
+                properties: {
+                  type: {
+                    const: action
+                  }
+                },
+                required: ["type"]
+              }
+            }
+          },
+          required: ["actions"]
+        }
+      },
+      required: ["$event"]
+    })
+  };
+}
+function getDateRangeToFieldReference(fieldId, comparedFieldId, clause) {
+  return {
     type: "object",
     properties: {
-      $event: {
-        type: "object",
-        properties: {
-          actions: {
-            type: "array",
-            contains: {
-              type: "object",
-              properties: {
-                type: {
-                  const: action
-                }
-              },
-              required: ["type"]
-            }
-          }
-        },
-        required: ["actions"]
+      [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 && "$$field" in value;
+}
+function createFieldConditionals(fieldId) {
+  const getDayRange = (days, clause) => ({
+    type: "object",
+    properties: {
+      [fieldId]: {
+        type: "string",
+        format: "date",
+        daysFromNow: {
+          days,
+          clause
+        }
       }
     },
-    required: ["$event"]
-  })
-};
-function field(fieldId) {
-  const getDateFromNow = (days) => new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
+    required: [fieldId]
+  });
   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.
      */
-    _returning: fieldId,
+    $$field: fieldId,
     isAfter: () => ({
       days: (days) => ({
-        inPast: () => defineConditional(
-          getDateRange(getDateFromNow(days), "formatMinimum")
-        ),
-        inFuture: () => defineConditional(
-          getDateRange(getDateFromNow(-days), "formatMinimum")
-        )
+        inPast: () => defineFormConditional(getDayRange(-days, "after")),
+        inFuture: () => defineFormConditional(getDayRange(days, "after"))
       }),
-      date: (date) => defineConditional(getDateRange(date, "formatMinimum")),
-      now: () => defineConditional(getDateRange(getDateFromNow(0), "formatMinimum"))
+      date: (date) => {
+        if (isFieldReference(date)) {
+          const comparedFieldId = date.$$field;
+          return defineFormConditional(
+            getDateRangeToFieldReference(
+              fieldId,
+              comparedFieldId,
+              "formatMinimum"
+            )
+          );
+        }
+        return defineFormConditional(getDateRange(date, "formatMinimum"));
+      },
+      now: () => defineFormConditional(getDateRange({ $data: "/$now" }, "formatMinimum"))
     }),
     isBefore: () => ({
       days: (days) => ({
-        inPast: () => defineConditional(
-          getDateRange(getDateFromNow(days), "formatMaximum")
-        ),
-        inFuture: () => defineConditional(
-          getDateRange(getDateFromNow(-days), "formatMaximum")
-        )
+        inPast: () => defineFormConditional(getDayRange(days, "before")),
+        inFuture: () => defineFormConditional(getDayRange(-days, "before"))
       }),
-      date: (date) => defineConditional(getDateRange(date, "formatMaximum")),
-      now: () => defineConditional(getDateRange(getDateFromNow(0), "formatMaximum"))
+      date: (date) => {
+        if (isFieldReference(date)) {
+          const comparedFieldId = date.$$field;
+          return defineFormConditional(
+            getDateRangeToFieldReference(
+              fieldId,
+              comparedFieldId,
+              "formatMaximum"
+            )
+          );
+        }
+        return defineFormConditional(getDateRange(date, "formatMaximum"));
+      },
+      now: () => defineFormConditional(getDateRange({ $data: "/$now" }, "formatMaximum"))
     }),
-    // TODO CIHAN: typing
     isEqualTo: (value) => {
-      if (typeof value === "object" && value._returning) {
-        const comparedFieldId = value._returning;
-        return defineConditional({
+      if (isFieldReference(value)) {
+        const comparedFieldId = value.$$field;
+        return defineFormConditional({
           type: "object",
           properties: {
-            $form: {
-              type: "object",
-              properties: {
-                [fieldId]: { type: ["string", "boolean"] },
-                [comparedFieldId]: { type: ["string", "boolean"] }
-              },
-              required: [fieldId, comparedFieldId],
-              allOf: [
-                {
-                  properties: {
-                    [fieldId]: {
-                      const: { $data: `1/${comparedFieldId}` }
-                    }
-                  }
-                }
-              ]
-            }
+            [fieldId]: {
+              type: ["string", "boolean"],
+              const: { $data: `/$form/${comparedFieldId}` }
+            },
+            [comparedFieldId]: { type: ["string", "boolean"] }
           },
-          required: ["$form"]
+          required: [fieldId, comparedFieldId]
         });
       }
-      return defineConditional({
+      return defineFormConditional({
         type: "object",
         properties: {
-          $form: {
-            type: "object",
-            properties: {
-              [fieldId]: {
-                oneOf: [
-                  { type: "string", const: value },
-                  { type: "boolean", const: value }
-                ],
-                const: value
-              }
-            },
-            required: [fieldId]
+          [fieldId]: {
+            oneOf: [
+              { type: "string", const: value },
+              { type: "boolean", const: value }
+            ],
+            const: value
           }
         },
-        required: ["$form"]
+        required: [fieldId]
       });
     },
     /**
@@ -210,140 +269,104 @@ 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]
           }
         }
-      },
-      required: ["$form"]
+      ]
     }),
-    inArray: (values) => defineConditional({
+    isUndefined: () => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              enum: values
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          enum: ["undefined"]
         }
       },
-      required: ["$form"]
+      not: {
+        required: [fieldId]
+      }
     }),
-    isValidEnglishName: () => defineConditional({
+    inArray: (values) => 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",
+          enum: values
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     }),
-    isValidNationalId: () => defineConditional({
+    isValidEnglishName: () => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              pattern: "^[0-9]{9}$",
-              description: "The National ID can only be numeric and must be 9 digits long."
-            }
-          },
-          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: ["$form"]
+      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) => defineConditional({
+    matches: (pattern) => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              pattern
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          pattern
+        }
+      },
+      required: [fieldId]
+    }),
+    isBetween: (min, max) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "number",
+          minimum: min,
+          maximum: max
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     }),
-    isBetween: (min, max) => defineConditional({
+    getId: () => ({ fieldId }),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    object: (options) => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
+        [fieldId]: {
           type: "object",
-          properties: {
-            [fieldId]: {
-              type: "number",
-              minimum: min,
-              maximum: max
-            }
-          },
-          required: [fieldId]
+          properties: Object.fromEntries(
+            Object.entries(options).map(([key, value]) => {
+              return [key, value.properties.$form.properties[key]];
+            })
+          ),
+          required: Object.keys(options)
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     })
   };
 }