fix: building indices on arrays using prefixItems

lib/dataContract/validation/validateDataContractFactory.js

@@ -190,7 +190,15 @@ module.exports = function validateDataContractFactory(
             if (propertyType === 'array' && !isByteArray) {
               const { items, prefixItems } = propertyDefinition;
 
-              if (prefixItems || items.type === 'object' || items.type === 'array') {
+              const isInvalidPrefixItems = prefixItems
+                && (
+                  prefixItems.some((prefixItem) => prefixItem.type === 'object' || prefixItem.type === 'array')
+                  || !prefixItems.every((prefixItem) => prefixItem.type === prefixItems[0].type)
+                );
+
+              const isInvalidItemTypes = items.type === 'object' || items.type === 'array';
+
+              if (isInvalidPrefixItems || isInvalidItemTypes) {
                 invalidPropertyType = 'array';
               }
             }

lib/test/fixtures/getDataContractFixture.js

@@ -82,6 +82,30 @@ module.exports = function getDataContractFixture(ownerId = randomOwnerId) {
       required: ['firstName', '$createdAt', '$updatedAt', 'lastName'],
       additionalProperties: false,
     },
+    indexedArray: {
+      type: 'object',
+      indices: [
+        {
+          properties: [
+            { mentions: 'asc' },
+          ],
+        },
+      ],
+      properties: {
+        mentions: {
+          type: 'array',
+          prefixItems: [
+            {
+              type: 'string',
+            },
+          ],
+          minItems: 1,
+          maxItems: 5,
+          items: false,
+        },
+      },
+      additionalProperties: false,
+    },
     noTimeDocument: {
       type: 'object',
       properties: {

test/integration/dataContract/validation/validateDataContractFactory.spec.js

@@ -62,7 +62,7 @@ describe('validateDataContractFactory', function main() {
     it('should be present', async () => {
       rawDataContract = {
         documents: {
-          zalupa: {
+          someDocument: {
             type: 'object',
           },
         },
@@ -1555,6 +1555,86 @@ describe('validateDataContractFactory', function main() {
         expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
       });
 
+      it('should return invalid result if index property is an array of different types', async () => {
+        const indexedDocumentDefinition = rawDataContract.documents.indexedArray;
+
+        const indexDefinition = indexedDocumentDefinition.indices[0];
+
+        rawDataContract.documents.indexedArray.properties.mentions.prefixItems = [
+          {
+            type: 'string',
+          },
+          {
+            type: 'number',
+          },
+        ];
+
+        rawDataContract.documents.indexedArray.properties.mentions.minItems = 2;
+
+        const result = await validateDataContract(rawDataContract);
+        expectValidationError(result, InvalidIndexPropertyTypeError);
+
+        const [error] = result.getErrors();
+        expect(error.getPropertyName()).to.equal('mentions');
+        expect(error.getPropertyType()).to.equal('array');
+        expect(error.getRawDataContract()).to.deep.equal(rawDataContract);
+        expect(error.getDocumentType()).to.deep.equal('indexedArray');
+        expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
+      });
+
+      it('should return invalid result if index property contained prefixItems array of arrays', async () => {
+        const indexedDocumentDefinition = rawDataContract.documents.indexedArray;
+
+        const indexDefinition = indexedDocumentDefinition.indices[0];
+
+        rawDataContract.documents.indexedArray.properties.mentions.prefixItems = [
+          {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+          },
+        ];
+
+        const result = await validateDataContract(rawDataContract);
+        expectValidationError(result, InvalidIndexPropertyTypeError);
+
+        const [error] = result.getErrors();
+        expect(error.getPropertyName()).to.equal('mentions');
+        expect(error.getPropertyType()).to.equal('array');
+        expect(error.getRawDataContract()).to.deep.equal(rawDataContract);
+        expect(error.getDocumentType()).to.deep.equal('indexedArray');
+        expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
+      });
+
+      it('should return invalid result if index property contained prefixItems array of objects', async () => {
+        const indexedDocumentDefinition = rawDataContract.documents.indexedArray;
+
+        const indexDefinition = indexedDocumentDefinition.indices[0];
+
+        rawDataContract.documents.indexedArray.properties.mentions.prefixItems = [
+          {
+            type: 'object',
+            properties: {
+              something: {
+                type: 'string',
+              },
+            },
+            additionalProperties: false,
+          },
+        ];
+
+        const result = await validateDataContract(rawDataContract);
+        expectValidationError(result, InvalidIndexPropertyTypeError);
+
+        const [error] = result.getErrors();
+        expect(error.getPropertyName()).to.equal('mentions');
+        expect(error.getPropertyType()).to.equal('array');
+        expect(error.getRawDataContract()).to.deep.equal(rawDataContract);
+        expect(error.getDocumentType()).to.deep.equal('indexedArray');
+        expect(error.getIndexDefinition()).to.deep.equal(indexDefinition);
+      });
+
       it('should return invalid result if index property is array of arrays', async () => {
         const indexedDocumentDefinition = rawDataContract.documents.indexedDocument;