core(jsonld): Structured data validation updates

lighthouse-core/lib/sd-validation/json-linter.js

@@ -9,21 +9,21 @@ const jsonlint = require('jsonlint-mod');
 
 /**
  * @param {string} input
- * @returns {{message: string, lineNumber: string|null}|null}
+ * @returns {{message: string, lineNumber: number|null}|null}
  */
 module.exports = function parseJSON(input) {
   try {
     jsonlint.parse(input);
   } catch (error) {
-    /** @type {string|null} */
+    /** @type {number|null} */
     let line = error.at;
 
     // extract line number from message
     if (!line) {
       const regexLineResult = error.message.match(/Parse error on line (\d+)/);
 
       if (regexLineResult) {
-        line = regexLineResult[1];
+        line = parseFloat(regexLineResult[1]);
       }
     }
 

lighthouse-core/lib/sd-validation/jsonld-keyword-validator.js

@@ -41,7 +41,7 @@ module.exports = function validateJsonLD(json) {
     if (name.startsWith('@') && !VALID_KEYWORDS.has(name)) {
       errors.push({
         path: path.join('/'),
-        message: 'Unknown keyword',
+        message: 'Unknown keyword ' + name,
       });
     }
   });

lighthouse-core/lib/sd-validation/schema-validator.js

@@ -49,7 +49,7 @@ function findType(type) {
  *
  * @param {string|Array<string>} typeOrTypes
  * @param {Array<string>} keys
- * @returns {Array<string>}
+ * @returns {Array<{message: string, key?: string, invalidTypes?: Array<string>, path?: string}>}
  */
 function validateObjectKeys(typeOrTypes, keys) {
   /** @type {Array<string>} */
@@ -60,17 +60,22 @@ function validateObjectKeys(typeOrTypes, keys) {
   } else if (Array.isArray(typeOrTypes)) {
     types = typeOrTypes;
     const invalidIndex = typeOrTypes.findIndex(s => typeof s !== 'string');
-    if (invalidIndex >= 0) return [`Unknown value type at index ${invalidIndex}`];
+    if (invalidIndex >= 0) {
+      return [{message: `Unknown value type at index ${invalidIndex}`}];
+    }
   } else {
-    return ['Unknown value type'];
+    return [{message: 'Unknown value type'}];
   }
 
   const unknownTypes = types.filter(t => !findType(t));
 
   if (unknownTypes.length) {
     return unknownTypes
       .filter(type => SCHEMA_ORG_URL_REGEX.test(type))
-      .map(type => `Unrecognized schema.org type ${type}`);
+      .map(type => ({
+        message: `Unrecognized schema.org type ${type}`,
+        key: '@type',
+      }));
   }
 
   /** @type {Set<string>} */
@@ -91,15 +96,19 @@ function validateObjectKeys(typeOrTypes, keys) {
     // remove Schema.org input/output constraints http://schema.org/docs/actions.html#part-4
     .map(key => key.replace(/-(input|output)$/, ''))
     .filter(key => !allKnownProps.has(key))
-    .map(key => `Unexpected property "${key}"`);
+    .map(key => ({
+      message: `Unexpected property "${key}"`,
+      key,
+      invalidTypes: types,
+    }));
 }
 
 /**
  * @param {LH.StructuredData.ExpandedSchemaRepresentation|null} expandedObj Valid JSON-LD object in expanded form
- * @return {Array<{path: string, message: string}>}
+ * @return {Array<{path?: string, message: string, invalidTypes?: Array<string>}>}
  */
 module.exports = function validateSchemaOrg(expandedObj) {
-  /** @type {Array<{path: string, message: string}>} */
+  /** @type {Array<{path?: string, message: string, invalidTypes?: Array<string>}>} */
   const errors = [];
 
   if (expandedObj === null) {
@@ -114,20 +123,22 @@ module.exports = function validateSchemaOrg(expandedObj) {
 
   walkObject(expandedObj, (name, value, path, obj) => {
     if (name === TYPE_KEYWORD) {
-      const keyErrorMessages = validateObjectKeys(value, Object.keys(obj));
+      const keyErrors = validateObjectKeys(value, Object.keys(obj));
 
-      keyErrorMessages.forEach(message =>
+      keyErrors.forEach(error => {
         errors.push({
+          invalidTypes: error.invalidTypes,
+          message: error.message,
           // get rid of the first chunk (/@type) as it's the same for all errors
           path:
             '/' +
             path
               .slice(0, -1)
+              .concat(error.key || [])
               .map(cleanName)
               .join('/'),
-          message,
-        })
-      );
+        });
+      });
     }
   });
 

lighthouse-core/lib/sd-validation/sd-validation.js

@@ -10,22 +10,20 @@ const validateJsonLD = require('./jsonld-keyword-validator.js');
 const expandAsync = require('./json-expander.js');
 const validateSchemaOrg = require('./schema-validator.js');
 
-/** @typedef {'json'|'json-ld'|'json-ld-expand'|'schema-org'} ValidatorType */
-
 /**
  * Validates JSON-LD input. Returns array of error objects.
  *
  * @param {string} textInput
- * @returns {Promise<Array<{path: ?string, validator: ValidatorType, message: string}>>}
+ * @returns {Promise<Array<LH.StructuredData.ValidationError>>}
  */
 module.exports = async function validate(textInput) {
   // STEP 1: VALIDATE JSON
   const parseError = parseJSON(textInput);
 
   if (parseError) {
     return [{
-      validator: 'json',
-      path: parseError.lineNumber,
+      validator: /** @type {LH.StructuredData.ValidatorType} */ ('json'),
+      lineNumber: parseError.lineNumber,
       message: parseError.message,
     }];
   }
@@ -38,9 +36,10 @@ module.exports = async function validate(textInput) {
   if (jsonLdErrors.length) {
     return jsonLdErrors.map(error => {
       return {
-        validator: /** @type {ValidatorType} */ ('json-ld'),
+        validator: /** @type {LH.StructuredData.ValidatorType} */ ('json-ld'),
         path: error.path,
         message: error.message,
+        lineNumber: getLineNumberFromJsonLDPath(inputObject, error.path),
       };
     });
   }
@@ -52,8 +51,7 @@ module.exports = async function validate(textInput) {
     expandedObj = await expandAsync(inputObject);
   } catch (error) {
     return [{
-      validator: 'json-ld-expand',
-      path: null,
+      validator: /** @type {LH.StructuredData.ValidatorType} */ ('json-ld-expand'),
       message: error.message,
     }];
   }
@@ -64,12 +62,73 @@ module.exports = async function validate(textInput) {
   if (schemaOrgErrors.length) {
     return schemaOrgErrors.map(error => {
       return {
-        validator: /** @type {ValidatorType} */ ('schema-org'),
+        validator: /** @type {LH.StructuredData.ValidatorType} */ ('schema-org'),
         path: error.path,
         message: error.message,
+        lineNumber: error.path ? getLineNumberFromJsonLDPath(inputObject, error.path) : null,
+        invalidTypes: error.invalidTypes,
       };
     });
   }
 
   return [];
 };
+
+/**
+ * @param {*} obj
+ * @param {string} path
+ * @returns null | number - line number of the path value in the prettified JSON
+ */
+function getLineNumberFromJsonLDPath(obj, path) {
+  // To avoid having an extra dependency on a JSON parser we set a unique key in the
+  // object and then use that to identify the correct line
+  const searchKey = Math.random().toString();
+  obj = JSON.parse(JSON.stringify(obj));
+
+  setValueAtJsonLDPath(obj, path, searchKey);
+  const jsonLines = JSON.stringify(obj, null, 2).split('\n');
+  const lineIndex = jsonLines.findIndex(line => line.includes(searchKey));
+
+  return lineIndex === -1 ? null : lineIndex + 1;
+}
+
+/**
+ * @param {*} obj
+ * @param {string} path
+ * @param {*} value
+ */
+function setValueAtJsonLDPath(obj, path, value) {
+  const pathParts = path.split('/').filter(p => !!p);
+  let currentObj = obj;
+  pathParts.forEach((pathPart, i) => {
+    if (pathPart === '0' && !Array.isArray(currentObj)) {
+      // jsonld expansion turns single values into arrays
+      return;
+    }
+
+    const isLastPart = pathParts.length - 1 === i;
+    let keyFound = false;
+    for (const key of Object.keys(currentObj)) {
+      // The actual key in JSON might be an absolute IRI like "http://schema.org/author"
+      // but key provided by validator is "author"
+      const keyParts = key.split('/');
+      const relativeKey = keyParts[keyParts.length - 1];
+      if (relativeKey === pathPart && currentObj[key] !== undefined) {
+        // If we've arrived at the end of the provided path set the value, otherwise
+        // continue iterating with the object at the key location
+        if (isLastPart) {
+          currentObj[key] = value;
+        } else {
+          currentObj = currentObj[key];
+        }
+        keyFound = true;
+        return;
+      }
+    }
+
+    if (!keyFound) {
+      // Couldn't find the key we got from validation in the original object
+      throw Error('Key not found: ' + pathPart);
+    }
+  });
+}

lighthouse-core/test/lib/sd-validation-test.js

@@ -17,7 +17,7 @@ describe('JSON validation', () => {
     `);
 
     assert.equal(errors.length, 1);
-    assert.equal(errors[0].path, 2);
+    assert.equal(errors[0].lineNumber, 2);
     assert.ok(errors[0].message.indexOf(`Expecting '}'`) === 0);
   });
 
@@ -28,7 +28,7 @@ describe('JSON validation', () => {
     }`);
 
     assert.equal(errors.length, 1);
-    assert.equal(errors[0].path, 2);
+    assert.equal(errors[0].lineNumber, 2);
     assert.ok(errors[0].message.indexOf(`Expecting 'EOF', '}', ':', ',', ']'`) === 0);
   });
 
@@ -70,8 +70,9 @@ describe('JSON-LD validation', () => {
     }`);
 
     assert.equal(errors.length, 1);
-    assert.equal(errors[0].message, 'Unknown keyword');
+    assert.equal(errors[0].message, 'Unknown keyword @test');
     assert.equal(errors[0].path, '@test');
+    assert.equal(errors[0].lineNumber, 4);
   });
 
   it('reports invalid context', async () => {
@@ -125,6 +126,7 @@ describe('schema.org validation', () => {
 
     assert.equal(errors.length, 1);
     assert.equal(errors[0].message, 'Unrecognized schema.org type http://schema.org/Cat');
+    assert.equal(errors[0].lineNumber, 3);
   });
 
   it('handles arrays of json schemas', async () => {
@@ -169,7 +171,9 @@ describe('schema.org validation', () => {
     }`);
 
     assert.equal(errors.length, 1);
+    assert.equal(errors[0].invalidTypes[0], 'http://schema.org/Article');
     assert.equal(errors[0].message, 'Unexpected property "controversial"');
+    assert.equal(errors[0].lineNumber, 11);
   });
 
   it('passes if non-schema.org context', async () => {
@@ -206,4 +210,34 @@ describe('schema.org validation', () => {
 
     assert.equal(errors.length, 0);
   });
+
+  it('passes if valid json-ld uses absolute IRIs as keys', async () => {
+    const errors = await validateJSONLD(`{
+      "@type": "http://schema.org/Article",
+      "http://schema.org/author": {
+        "@type": "Person",
+        "http://schema.org/name": "Cat"
+      },
+      "http://schema.org/datePublished": "Oct 29th 2017",
+      "http://schema.org/dateModified": "Oct 29th 2017"
+    }`);
+
+    assert.equal(errors.length, 0);
+  });
+
+  it('fails if invalid json-ld uses absolute IRIs as keys', async () => {
+    const errors = await validateJSONLD(`{
+      "@type": "http://schema.org/Article",
+      "http://schema.org/author": {
+        "@type": "http://schema.org/Person",
+        "http://schema.org/invalidProperty": "",
+        "http://schema.org/name": "Cat"
+      },
+      "http://schema.org/datePublished": "Oct 29th 2017",
+      "http://schema.org/dateModified": "Oct 29th 2017"
+    }`);
+
+    assert.equal(errors.length, 1);
+    assert.equal(errors[0].lineNumber, 5);
+  });
 });

types/structured-data.d.ts

@@ -7,6 +7,21 @@
 declare global {
   module LH {
     module StructuredData {
+
+      export type ValidatorType =
+        | "json"
+        | "json-ld"
+        | "json-ld-expand"
+        | "schema-org";
+
+      export interface ValidationError {
+        message: string;
+        path?: string;
+        validator: ValidatorType;
+        lineNumber?: number | null;
+        invalidTypes?: Array<string>;
+      }
+
       export interface ExpandedSchemaRepresentationItem {
         [schemaRef: string]: Array<
             string |