@carecard/validate 3.1.17 → 3.1.19

package/lib/validateProperties.js

@@ -58,6 +58,10 @@ function validateProperties(obj = {}) {
             case 'document_type':
             case 'documentType':
             case 'reason':
+            case 'entity_type':
+            case 'entityType':
+            case 'action_type':
+            case 'actionType':
             case 'street':
             case 'city':
             case 'state':
@@ -149,6 +153,12 @@ function validateProperties(obj = {}) {
             case 'userRoleId':
             case 'phone_number_id':
             case 'phoneNumberId':
+            case 'entity_id':
+            case 'entityId':
+            case 'changed_by':
+            case 'changedBy':
+            case 'request_id':
+            case 'requestId':
                 if (isValidUuidString(value)) {
                     returnObj[key] = value;
                 }
@@ -165,6 +175,8 @@ function validateProperties(obj = {}) {
             case 'price':
             case 'from':
             case 'number':
+            case 'limit':
+            case 'offset':
                 if (isValidIntegerString(value)) {
                     returnObj[key] = value;
                 }
@@ -212,6 +224,10 @@ function validateProperties(obj = {}) {
                 break;
             case 'expires_at':
             case 'expiresAt':
+            case 'start_time':
+            case 'startTime':
+            case 'end_time':
+            case 'endTime':
                 if (isValidTimestampzString(value) || isValidTimestampString(value)) {
                     returnObj[key] = value;
                 }

package/lib/validateWhitelistProperties.js

@@ -18,7 +18,53 @@ const MAX_NESTING_DEPTH = 5;
 const MAX_KEYS_PER_CALL = 5000;
 
 /**
- * Splits a dot-notation property path into its segments and validates depth.
+ * Returns true if the segment contains a mix of snake_case (underscore) and
+ * camelCase (uppercase letter), e.g. `my_mixName`. Such names are ambiguous
+ * and are not supported.
+ * @param {string} segment
+ * @returns {boolean}
+ */
+function isMixedCaseSegment(segment) {
+    return /_/.test(segment) && /[A-Z]/.test(segment);
+}
+
+/**
+ * Converts a snake_case identifier to camelCase. Leaves identifiers without
+ * underscores unchanged.
+ * @param {string} s
+ * @returns {string}
+ */
+function snakeToCamel(s) {
+    return s.replace(/_([a-zA-Z0-9])/g, (_, c) => c.toUpperCase());
+}
+
+/**
+ * Converts a camelCase identifier to snake_case. Leaves identifiers without
+ * uppercase letters unchanged.
+ * @param {string} s
+ * @returns {string}
+ */
+function camelToSnake(s) {
+    return s.replace(/[A-Z]/g, c => `_${c.toLowerCase()}`);
+}
+
+/**
+ * Returns the alternate-case form of the segment:
+ *  - snake_case -> camelCase
+ *  - camelCase  -> snake_case
+ *  - otherwise (no `_` and no uppercase) the segment itself.
+ * @param {string} segment
+ * @returns {string}
+ */
+function alternateCase(segment) {
+    if (segment.indexOf('_') !== -1) return snakeToCamel(segment);
+    if (/[A-Z]/.test(segment)) return camelToSnake(segment);
+    return segment;
+}
+
+/**
+ * Splits a dot-notation property path into its segments and validates depth
+ * and per-segment casing (mixed snake/camel segments are rejected).
  * @param {string} path
  * @returns {string[]}
  */
@@ -29,6 +75,13 @@ function splitPath(path) {
             userMessage: `Property path "${path}" exceeds maximum nesting depth of ${MAX_NESTING_DEPTH}`,
         });
     }
+    for (const seg of segments) {
+        if (isMixedCaseSegment(seg)) {
+            throwBadInputError({
+                userMessage: `Property path "${path}" has a segment "${seg}" mixing snake_case and camelCase`,
+            });
+        }
+    }
     return segments;
 }
 
@@ -42,16 +95,27 @@ function splitPath(path) {
  * @returns {{ found: boolean, value: any }}
  */
 function readLeaf(obj, segments) {
+    // Resolve a segment against the current node, trying its as-written form
+    // first and then its alternate snake/camel form. Returns the actual key
+    // present in the node, or undefined if neither form exists.
+    function resolveKey(node, seg) {
+        if (Object.prototype.hasOwnProperty.call(node, seg)) return seg;
+        const alt = alternateCase(seg);
+        if (alt !== seg && Object.prototype.hasOwnProperty.call(node, alt)) return alt;
+        return undefined;
+    }
+
     let current = obj;
     for (let i = 0; i < segments.length - 1; i++) {
         if (current === null || typeof current !== 'object') return { found: false, value: undefined };
-        if (!Object.prototype.hasOwnProperty.call(current, segments[i])) return { found: false, value: undefined };
-        current = current[segments[i]];
+        const key = resolveKey(current, segments[i]);
+        if (key === undefined) return { found: false, value: undefined };
+        current = current[key];
     }
     if (current === null || typeof current !== 'object') return { found: false, value: undefined };
-    const leaf = segments[segments.length - 1];
-    if (!Object.prototype.hasOwnProperty.call(current, leaf)) return { found: false, value: undefined };
-    return { found: true, value: current[leaf] };
+    const leafKey = resolveKey(current, segments[segments.length - 1]);
+    if (leafKey === undefined) return { found: false, value: undefined };
+    return { found: true, value: current[leafKey] };
 }
 
 /**
@@ -146,7 +210,7 @@ function validateWhitelistProperties(
         });
     }
 
-    const requiredPaths = requiredProperties.map(p => ({ raw: p, segments: splitPath(p) }));
+    const requiredPaths = (requiredProperties || []).map(p => ({ raw: p, segments: splitPath(p) }));
     const optionalPaths = optionalProperties.map(p => ({ raw: p, segments: splitPath(p) }));
 
     let validatedObject = {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@carecard/validate",
-    "version": "3.1.17",
+    "version": "3.1.19",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/CareCard-ca/pkg-validate.git"