@ecrvs/opencrvs-toolkit 1.8.1-rc.a7ee8fb

package/dist/conditionals/index.js

@@ -0,0 +1,491 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/conditionals/index.ts
+var conditionals_exports = {};
+__export(conditionals_exports, {
+  alwaysTrue: () => alwaysTrue,
+  and: () => and,
+  createFieldConditionals: () => createFieldConditionals,
+  defineConditional: () => defineConditional,
+  defineFormConditional: () => defineFormConditional,
+  never: () => never,
+  not: () => not,
+  or: () => or,
+  user: () => user
+});
+module.exports = __toCommonJS(conditionals_exports);
+
+// ../commons/src/conditionals/conditionals.ts
+var objectHash = __toESM(require("object-hash"));
+
+// ../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",
+    "signature",
+    "avatar",
+    "primaryOfficeId"
+  ]),
+  $location: import_zod.z.string().optional()
+});
+function userSerializer(userField) {
+  return {
+    $userField: userField,
+    locationLevel(adminLevelId) {
+      return {
+        $userField: this.$userField,
+        $location: adminLevelId
+      };
+    },
+    toJSON() {
+      return {
+        $userField: userField
+      };
+    }
+  };
+}
+
+// ../commons/src/utils.ts
+var z2 = __toESM(require("zod"));
+var FullNameV1 = z2.array(
+  z2.object({
+    use: z2.string(),
+    family: z2.string(),
+    given: z2.array(z2.string())
+  })
+);
+function omitKeyDeep(obj, keyToRemove) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => omitKeyDeep(item, keyToRemove));
+  }
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  const newObj = {};
+  for (const key of Object.keys(obj)) {
+    if (key !== keyToRemove) {
+      newObj[key] = omitKeyDeep(obj[key], keyToRemove);
+    }
+  }
+  return newObj;
+}
+
+// ../commons/src/conditionals/conditionals.ts
+function defineConditional(schema) {
+  const schemaWithooutIDRef = omitKeyDeep(schema, "$id");
+  return {
+    $id: `https://opencrvs.org/conditionals/${objectHash.sha1(schemaWithooutIDRef)}`,
+    ...schemaWithooutIDRef
+  };
+}
+function defineFormConditional(schema) {
+  const schemaWithForm = {
+    type: "object",
+    properties: {
+      $form: schema
+    },
+    required: ["$form"]
+  };
+  return defineConditional(schemaWithForm);
+}
+function alwaysTrue() {
+  return {};
+}
+function and(...conditions) {
+  return defineConditional({
+    type: "object",
+    allOf: conditions,
+    required: []
+  });
+}
+function or(...conditions) {
+  return defineConditional({
+    type: "object",
+    anyOf: conditions,
+    required: []
+  });
+}
+function not(condition) {
+  return defineConditional({
+    type: "object",
+    not: condition,
+    required: []
+  });
+}
+function never() {
+  return not(alwaysTrue());
+}
+function wrapToPath(condition, path) {
+  if (path.length === 0) {
+    return condition;
+  }
+  return path.reduceRight((conditionNow, part) => {
+    return {
+      type: "object",
+      properties: {
+        [part]: conditionNow
+      },
+      required: [part]
+    };
+  }, condition);
+}
+var user = Object.assign(userSerializer, {
+  hasScope: (scope) => defineConditional({
+    type: "object",
+    properties: {
+      $user: {
+        type: "object",
+        required: ["scope"],
+        properties: {
+          scope: {
+            type: "array",
+            contains: {
+              type: "string",
+              const: scope
+            }
+          }
+        }
+      }
+    },
+    required: ["$user"]
+  }),
+  isOnline: () => defineConditional({
+    type: "object",
+    properties: {
+      $online: {
+        type: "boolean",
+        const: true
+      }
+    },
+    required: ["$online"]
+  }),
+  locationLevel: (adminLevelId) => ({
+    $user: {
+      $location: adminLevelId
+    }
+  })
+});
+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 && "$$field" in value;
+}
+function defineComparison(fieldId, value, keyword) {
+  if (isFieldReference(value)) {
+    const comparedFieldId = value.$$field;
+    return defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: ["number"],
+          [keyword]: { $data: `1/${comparedFieldId}` }
+        },
+        [comparedFieldId]: {
+          type: "number"
+        }
+      },
+      required: [fieldId, comparedFieldId]
+    });
+  }
+  return defineFormConditional({
+    type: "object",
+    properties: {
+      [fieldId]: {
+        type: "number",
+        [keyword]: value
+      }
+    },
+    required: [fieldId]
+  });
+}
+function createFieldConditionals(fieldId) {
+  const getDayRange = (days, clause) => ({
+    type: "object",
+    properties: {
+      [fieldId]: {
+        type: "string",
+        format: "date",
+        daysFromNow: {
+          days,
+          clause
+        }
+      }
+    },
+    required: [fieldId]
+  });
+  const getDateRange = (date, clause) => ({
+    type: "object",
+    properties: {
+      [fieldId]: {
+        type: "string",
+        format: "date",
+        [clause]: date
+      }
+    },
+    required: [fieldId]
+  });
+  return {
+    /**
+     * @private Internal property used for field reference tracking.
+     */
+    $$field: fieldId,
+    /**
+     * @private Internal property used for solving a object path within field's value
+     */
+    $$subfield: [],
+    get(fieldPath) {
+      return {
+        ...this,
+        $$subfield: fieldPath.split(".")
+      };
+    },
+    isAfter: () => ({
+      days: (days) => ({
+        inPast: () => defineFormConditional(getDayRange(-days, "after")),
+        inFuture: () => defineFormConditional(getDayRange(days, "after"))
+      }),
+      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: () => defineFormConditional(getDayRange(days, "before")),
+        inFuture: () => defineFormConditional(getDayRange(-days, "before"))
+      }),
+      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"))
+    }),
+    isGreaterThan: (value) => defineComparison(fieldId, value, "exclusiveMinimum"),
+    isLessThan: (value) => defineComparison(fieldId, value, "exclusiveMaximum"),
+    isEqualTo(value) {
+      if (isFieldReference(value)) {
+        const comparedFieldId = value.$$field;
+        return defineFormConditional({
+          type: "object",
+          properties: {
+            [fieldId]: {
+              type: ["string", "boolean"],
+              const: { $data: `/$form/${comparedFieldId}` }
+            },
+            [comparedFieldId]: { type: ["string", "boolean"] }
+          },
+          required: [fieldId, comparedFieldId]
+        });
+      }
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [fieldId]: wrapToPath(
+            {
+              oneOf: [
+                { type: "string", const: value },
+                { type: "boolean", const: value }
+              ],
+              const: value
+            },
+            this.$$subfield
+          )
+        },
+        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))
+     * @returns whether the field is falsy (undefined, false, null, empty string)
+     *
+     * NOTE: For now, this only works with string, boolean, and null types. 0 is still allowed.
+     *
+     */
+    isFalsy() {
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [fieldId]: wrapToPath(
+            {
+              anyOf: [
+                { const: "undefined" },
+                { const: false },
+                { const: null },
+                { const: "" }
+              ]
+            },
+            this.$$subfield
+          )
+        },
+        anyOf: [
+          {
+            required: [fieldId]
+          },
+          {
+            not: {
+              required: [fieldId]
+            }
+          }
+        ]
+      });
+    },
+    isUndefined() {
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [fieldId]: wrapToPath(
+            {
+              type: "string",
+              enum: ["undefined"]
+            },
+            this.$$subfield
+          )
+        },
+        not: {
+          required: [fieldId]
+        }
+      });
+    },
+    inArray: (values) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "string",
+          enum: values
+        }
+      },
+      required: [fieldId]
+    }),
+    isValidEnglishName: () => defineFormConditional({
+      type: "object",
+      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."
+        }
+      }
+    }),
+    isValidAdministrativeLeafLevel: () => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "object",
+          properties: {
+            administrativeArea: {
+              type: "string",
+              isLeafLevelLocation: true
+            }
+          },
+          description: "The provided administrative value should have a value corresponding to the required lowest administrative level"
+        }
+      }
+    }),
+    /**
+     * 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: [fieldId]
+    }),
+    getId: () => ({ fieldId }),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    object: (options) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "object",
+          properties: Object.fromEntries(
+            Object.entries(options).map(([key, value]) => {
+              return [key, value.properties.$form.properties[key]];
+            })
+          ),
+          required: Object.keys(options)
+        }
+      },
+      required: [fieldId]
+    })
+  };
+}

package/dist/events/deduplication.d.ts

@@ -0,0 +1,32 @@
+import { ClauseInput, DateRangeMatcherOptions, FuzzyMatcherOptions, StrictMatcherOptions } from '.';
+export declare function not(clause: ClauseInput): ClauseInput;
+export declare function and(...clauses: ClauseInput[]): ClauseInput;
+export declare function or(...clauses: ClauseInput[]): ClauseInput;
+export declare function field(fieldId: string): {
+    fuzzyMatches: (options?: FuzzyMatcherOptions) => {
+        fieldId: string;
+        type: "fuzzy";
+        options: {
+            boost?: number | undefined;
+            fuzziness?: string | number | undefined;
+        } | undefined;
+    };
+    strictMatches: (options?: StrictMatcherOptions) => {
+        fieldId: string;
+        type: "strict";
+        options: {
+            value?: string | undefined;
+            boost?: number | undefined;
+        } | undefined;
+    };
+    dateRangeMatches: (options: DateRangeMatcherOptions) => {
+        fieldId: string;
+        type: "dateRange";
+        options: {
+            days: number;
+            boost?: number | undefined;
+            pivot?: number | undefined;
+        };
+    };
+};
+//# sourceMappingURL=deduplication.d.ts.map

package/dist/events/deduplication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduplication.d.ts","sourceRoot":"","sources":["../../src/events/deduplication.ts"],"names":[],"mappings":"AAUA,cAAc,wCAAwC,CAAA"}

package/dist/events/deduplication.js

@@ -0,0 +1,67 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/events/deduplication.ts
+var deduplication_exports = {};
+__export(deduplication_exports, {
+  and: () => and,
+  field: () => field,
+  not: () => not,
+  or: () => or
+});
+module.exports = __toCommonJS(deduplication_exports);
+
+// ../commons/src/events/deduplication.ts
+function not(clause) {
+  return {
+    type: "not",
+    clause
+  };
+}
+function and(...clauses) {
+  return {
+    type: "and",
+    clauses
+  };
+}
+function or(...clauses) {
+  return {
+    type: "or",
+    clauses
+  };
+}
+function field(fieldId) {
+  return {
+    fuzzyMatches: (options) => ({
+      fieldId,
+      type: "fuzzy",
+      options
+    }),
+    strictMatches: (options) => ({
+      fieldId,
+      type: "strict",
+      options
+    }),
+    dateRangeMatches: (options) => ({
+      fieldId,
+      type: "dateRange",
+      options
+    })
+  };
+}

package/dist/events/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../commons/events';
+//# sourceMappingURL=index.d.ts.map

package/dist/events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/events/index.ts"],"names":[],"mappings":"AAUA,cAAc,0BAA0B,CAAA"}