@becollective/utils 2.0.16 → 2.0.17

package/lib/forms.d.ts

@@ -188,7 +188,7 @@ export declare const validator: {
                             minItems: number;
                             items: {
                                 type: string;
-                            }[];
+                            };
                         };
                     };
                 };

package/lib/forms.js

@@ -59,6 +59,34 @@ const isValidYear = (value) => {
     const year = new Date(value).getFullYear();
     return year < 9999 && year > 999;
 };
+// Form multi-choice widgets (dropdown / tickbox / radio / skills) store options as:
+//   items: { type: 'string', anyOf: [ { enum: ['Yes'] }, { enum: ['No'] } ] }
+//
+// The old validators passed `items: schema.items.anyOf` into AJV. In JSON Schema,
+// `items` as an array is a positional *tuple* (index 0 matches schema 0, …), not
+// "each value may match any of these options". AJV 8 strictTuples then logs/throws:
+//   strict mode: "items" is N-tuple, but minItems or maxItems/additionalItems
+//   are not specified or different at path "#"
+// That started when @becollective/forms (AJV 6, no strictTuples) was replaced by
+// @becollective/utils (AJV 8). AJV 6 silently accepted the illegal shape.
+//
+// Compile a single item schema instead. If a stored form still has a raw array on
+// `items`, treat it as anyOf (the intended "one of these choices" meaning).
+const itemSchemaForArray = (items) => {
+    if (Array.isArray(items)) {
+        return { anyOf: items };
+    }
+    return items;
+};
+const isValidArrayOfItems = (data, schema) => {
+    if (!schema || !schema.items)
+        return false;
+    return ajv.validate({
+        type: 'array',
+        items: itemSchemaForArray(schema.items),
+        minItems: 1,
+    }, data) === true;
+};
 const validateType = async (params) => {
     const { type, data, schema, error } = params;
     if (exports.validator.dataTypeIsValid[type](data, schema)) {
@@ -448,7 +476,9 @@ exports.validator = {
                         enum: {
                             type: 'array',
                             minItems: 1,
-                            items: [{ type: 'string' }],
+                            // Homogeneous string list — not `items: [{ type: 'string' }]`,
+                            // which AJV 8 reads as a 1-tuple (same strictTuples error).
+                            items: { type: 'string' },
                         },
                     },
                 },
@@ -576,52 +606,10 @@ exports.validator = {
         phone: (data) => {
             return phoneNumber.isValidNumber(data || '');
         },
-        skills: (data, schema) => {
-            if (!schema || !schema.items)
-                return false;
-            let hasAnyOf = false;
-            try {
-                hasAnyOf =
-                    ajv.validate({
-                        type: 'array',
-                        items: schema.items.anyOf,
-                        minItems: 1,
-                    }, data) === true;
-            }
-            catch (e) { }
-            return hasAnyOf;
-        },
-        qualifications: (data, schema) => {
-            if (!schema || !schema.items)
-                return false;
-            return (ajv.validate({
-                type: 'array',
-                items: schema.items,
-                minItems: 1,
-            }, data) === true);
-        },
-        array: (data, schema) => {
-            if (!schema || !schema.items)
-                return false;
-            let hasAnyOf = false;
-            let hasItems = false;
-            try {
-                hasAnyOf =
-                    ajv.validate({
-                        type: 'array',
-                        items: schema.items.anyOf,
-                        minItems: 1,
-                    }, data) === true;
-                hasItems =
-                    ajv.validate({
-                        type: 'array',
-                        items: schema.items,
-                        minItems: 1,
-                    }, data) === true;
-            }
-            catch (e) { }
-            return hasItems || hasAnyOf;
-        },
+        // Do not pass `schema.items.anyOf` as AJV `items` (tuple). See itemSchemaForArray.
+        skills: (data, schema) => isValidArrayOfItems(data, schema),
+        qualifications: (data, schema) => isValidArrayOfItems(data, schema),
+        array: (data, schema) => isValidArrayOfItems(data, schema),
         heading: () => true,
         spacer: () => true,
         location: (data) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@becollective/utils",
-  "version": "2.0.16",
+  "version": "2.0.17",
   "description": "Common utilities",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/forms.ts

@@ -71,6 +71,38 @@ const isValidYear = (value) => {
   return year < 9999 && year > 999;
 };
 
+// Form multi-choice widgets (dropdown / tickbox / radio / skills) store options as:
+//   items: { type: 'string', anyOf: [ { enum: ['Yes'] }, { enum: ['No'] } ] }
+//
+// The old validators passed `items: schema.items.anyOf` into AJV. In JSON Schema,
+// `items` as an array is a positional *tuple* (index 0 matches schema 0, …), not
+// "each value may match any of these options". AJV 8 strictTuples then logs/throws:
+//   strict mode: "items" is N-tuple, but minItems or maxItems/additionalItems
+//   are not specified or different at path "#"
+// That started when @becollective/forms (AJV 6, no strictTuples) was replaced by
+// @becollective/utils (AJV 8). AJV 6 silently accepted the illegal shape.
+//
+// Compile a single item schema instead. If a stored form still has a raw array on
+// `items`, treat it as anyOf (the intended "one of these choices" meaning).
+const itemSchemaForArray = (items) => {
+  if (Array.isArray(items)) {
+    return { anyOf: items };
+  }
+  return items;
+};
+
+const isValidArrayOfItems = (data, schema) => {
+  if (!schema || !schema.items) return false;
+  return ajv.validate(
+    {
+      type: 'array',
+      items: itemSchemaForArray(schema.items),
+      minItems: 1,
+    },
+    data
+  ) === true;
+};
+
 const validateType = async (params: { type: string, data: any, schema?: any, error?: string }) => {
   const { type, data, schema, error } = params;
   if (validator.dataTypeIsValid[type](data, schema)) {
@@ -496,7 +528,9 @@ export const validator = {
             enum: {
               type: 'array',
               minItems: 1,
-              items: [{ type: 'string' }],
+              // Homogeneous string list — not `items: [{ type: 'string' }]`,
+              // which AJV 8 reads as a 1-tuple (same strictTuples error).
+              items: { type: 'string' },
             },
           },
         },
@@ -628,67 +662,10 @@ export const validator = {
     phone: (data) => {
       return phoneNumber.isValidNumber(data || '');
     },
-    skills: (data, schema) => {
-      if (!schema || !schema.items) return false;
-
-      let hasAnyOf = false;
-      try {
-        hasAnyOf =
-          ajv.validate(
-            {
-              type: 'array',
-              items: schema.items.anyOf,
-              minItems: 1,
-            },
-            data
-          ) === true;
-      }
-      catch (e) {}
-      return hasAnyOf;
-    },
-    qualifications: (data, schema) => {
-      if (!schema || !schema.items) return false;
-
-      return (
-        ajv.validate(
-          {
-            type: 'array',
-            items: schema.items,
-            minItems: 1,
-          },
-          data
-        ) === true
-      );
-    },
-    array: (data, schema) => {
-      if (!schema || !schema.items) return false;
-      let hasAnyOf = false;
-      let hasItems = false;
-      try {
-        hasAnyOf =
-          ajv.validate(
-            {
-              type: 'array',
-              items: schema.items.anyOf,
-              minItems: 1,
-            },
-            data
-          ) === true;
-
-        hasItems =
-          ajv.validate(
-            {
-              type: 'array',
-              items: schema.items,
-              minItems: 1,
-            },
-            data
-          ) === true;
-      }
-      catch (e) {}
-
-      return hasItems || hasAnyOf;
-    },
+    // Do not pass `schema.items.anyOf` as AJV `items` (tuple). See itemSchemaForArray.
+    skills: (data, schema) => isValidArrayOfItems(data, schema),
+    qualifications: (data, schema) => isValidArrayOfItems(data, schema),
+    array: (data, schema) => isValidArrayOfItems(data, schema),
     heading: () => true,
     spacer: () => true,
     location: (data) => {

package/tests/forms.test.ts

@@ -638,6 +638,18 @@ describe('dataTypeIsValid', () => {
       expect(isValid.array(['Soccer'], sport.schema)).toBe(true);
     });
 
+    test('should not emit AJV strict-tuple errors for items.anyOf choice fields', () => {
+      const warn = jest.spyOn(console, 'warn').mockImplementation();
+      const error = jest.spyOn(console, 'error').mockImplementation();
+
+      expect(isValid.array(['Soccer'], sport.schema)).toBe(true);
+
+      const messages = [...warn.mock.calls, ...error.mock.calls].flat().join(' ');
+      expect(messages).not.toMatch(/strict mode: "items" is \d+-tuple/);
+      warn.mockRestore();
+      error.mockRestore();
+    });
+
     test('should return false when schema is an empty object', () => {
       expect(isValid.array(['Soccer'], {})).toBe(false);
     });