@gsriram24/structured-data-validator 1.6.0

package/src/validator.js

@@ -0,0 +1,323 @@
+/**
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+export class Validator {
+  constructor(schemaOrgJson) {
+    this.schemaOrgJson = schemaOrgJson;
+    if (this.schemaOrgJson) {
+      // Only add schema.org validation handler if schema is provided
+      this.globalHandlers = [() => import('./types/schemaOrg.js')];
+    }
+
+    this.debug = false;
+
+    this.registeredHandlers = {
+      '3DModel': [() => import('./types/3DModel.js')],
+      AggregateOffer: [() => import('./types/AggregateOffer.js')],
+      AggregateRating: [() => import('./types/AggregateRating.js')],
+      Answer: [() => import('./types/Answer.js')],
+      Article: [() => import('./types/Article.js')],
+      BlogPosting: [() => import('./types/Article.js')],
+      Brand: [() => import('./types/Brand.js')],
+      BreadcrumbList: [() => import('./types/BreadcrumbList.js')],
+      Certification: [() => import('./types/Certification.js')],
+      DefinedRegion: [() => import('./types/DefinedRegion.js')],
+      Event: [() => import('./types/Event.js')],
+      FAQPage: [() => import('./types/FAQPage.js')],
+      HowTo: [() => import('./types/HowTo.js')],
+      ImageObject: [() => import('./types/ImageObject.js')],
+      VideoObject: [() => import('./types/VideoObject.js')],
+      Clip: [() => import('./types/Clip.js')],
+      BroadcastEvent: [() => import('./types/BroadcastEvent.js')],
+      SeekToAction: [() => import('./types/SeekToAction.js')],
+      ListItem: [() => import('./types/ListItem.js')],
+      LocalBusiness: [() => import('./types/LocalBusiness.js')],
+      MerchantReturnPolicy: [() => import('./types/MerchantReturnPolicy.js')],
+      NewsArticle: [() => import('./types/Article.js')],
+      Offer: [() => import('./types/Offer.js')],
+      OfferShippingDetails: [() => import('./types/OfferShippingDetails.js')],
+      Organization: [() => import('./types/Organization.js')],
+      PeopleAudience: [() => import('./types/PeopleAudience.js')],
+      Person: [() => import('./types/Person.js')],
+      PriceSpecification: [() => import('./types/PriceSpecification.js')],
+      Product: [
+        () => import('./types/Product.js'),
+        () => import('./types/ProductMerchant.js'),
+      ],
+      QuantitativeValue: [() => import('./types/QuantitativeValue.js')],
+      Question: [() => import('./types/Question.js')],
+      Rating: [() => import('./types/Rating.js')],
+      Review: [() => import('./types/Review.js')],
+      ShippingDeliveryTime: [() => import('./types/ShippingDeliveryTime.js')],
+      SizeSpecification: [() => import('./types/SizeSpecification.js')],
+      UnitPriceSpecification: [() => import('./types/PriceSpecification.js')],
+      JobPosting: [() => import('./types/JobPosting.js')],
+      Recipe: [() => import('./types/Recipe.js')],
+      HowToStep: [() => import('./types/HowToStep.js')],
+      HowToSection: [() => import('./types/HowToSection.js')],
+      HowToDirection: [() => import('./types/HowToDirection.js')],
+      HowToTip: [() => import('./types/HowToTip.js')],
+      WebSite: [() => import('./types/WebSite.js')],
+    };
+  }
+
+  // Get parent types from schema.org JSON-LD
+  #getParentTypes(type) {
+    if (!this.schemaOrgJson) return [];
+
+    const graph = this.schemaOrgJson['@graph'];
+    if (!graph) return [];
+
+    const typeEntry = graph.find(
+      (e) =>
+        e['@type'] === 'rdfs:Class' &&
+        (e['@id'] === type ||
+          e['@id'] === `schema:${type}` ||
+          e['@id'] === `https://schema.org/${type}`),
+    );
+
+    if (!typeEntry || !typeEntry['rdfs:subClassOf']) return [];
+
+    const parents = Array.isArray(typeEntry['rdfs:subClassOf'])
+      ? typeEntry['rdfs:subClassOf']
+      : [typeEntry['rdfs:subClassOf']];
+
+    return parents.map((p) => {
+      const id = p['@id'] || p;
+      return id
+        .replace('schema:', '')
+        .replace('https://schema.org/', '')
+        .replace('http://schema.org/', '');
+    });
+  }
+
+  // Get handlers for type, falling back to parent types if needed
+  async #getHandlersForType(type) {
+    // 1. Check direct mapping first (priority)
+    if (this.registeredHandlers[type]) {
+      return [...this.registeredHandlers[type]];
+    }
+
+    // 2. If schemaOrgJson available, check parent types
+    if (this.schemaOrgJson) {
+      const visited = new Set();
+      const queue = [type];
+
+      while (queue.length > 0) {
+        const current = queue.shift();
+        if (visited.has(current)) continue;
+        visited.add(current);
+
+        // Check if parent has handlers
+        if (current !== type && this.registeredHandlers[current]) {
+          this.debug &&
+            console.debug(`  Using ${current} handler for subtype ${type}`);
+          return [...this.registeredHandlers[current]];
+        }
+
+        // Add parent types to queue
+        const parents = this.#getParentTypes(current);
+        queue.push(...parents);
+      }
+    }
+
+    return [];
+  }
+
+  async #validateSubtree(data, rootData, dataFormat, path = []) {
+    const spacing = '  ' + '  '.repeat(path.length);
+
+    if (Array.isArray(data)) {
+      const results = await Promise.all(
+        data.map(async (item, index) => {
+          let last = path[path.length - 1];
+          last = { ...last, index, length: data.length };
+          if (item['@type']) {
+            last.type = item['@type'];
+          }
+          return this.#validateSubtree(item, rootData, dataFormat, [
+            ...path.slice(0, -1),
+            last,
+          ]);
+        }),
+      );
+      return results.flat();
+    }
+
+    if (typeof data === 'object' && data !== null) {
+      if (!data['@type']) {
+        this.debug && console.warn(`${spacing}  WARN: No type found for item`);
+        // TODO: Should return a validation error as type is missing,
+        //       WAE is already returning an error
+        return [];
+      }
+
+      let types = [];
+      if (Array.isArray(data['@type'])) {
+        types = data['@type'];
+      } else {
+        types = [data['@type']];
+      }
+
+      const typeIssues = await Promise.all(
+        types.map(async (type) => {
+          this.debug &&
+            console.debug(
+              `${spacing}VALIDATE TYPE:`,
+              type,
+              JSON.stringify(path),
+            );
+
+          // Find supported handlers (check direct mapping first, then parent types)
+          const handlers = await this.#getHandlersForType(type);
+          if (!handlers || handlers.length === 0) {
+            this.debug &&
+              console.warn(
+                `${spacing}  WARN: No handlers registered for type: ${type}`,
+              );
+            return [];
+          }
+          handlers.push(...(this.globalHandlers || []));
+
+          const handlerPromises = handlers.map(async (handler) => {
+            const handlerClass = (await handler()).default;
+            const handlerInstance = new handlerClass({
+              dataFormat,
+              path,
+              // If an object has multiple types, we need to pass the current type for any global handlers
+              type,
+              schemaOrgJson: this.schemaOrgJson,
+            });
+            return handlerInstance.validate(data);
+          });
+
+          // Wait for all handlers to complete
+          const handlerResults = (await Promise.all(handlerPromises)).flat();
+
+          for (const issue of handlerResults) {
+            this.debug && console.debug(`${spacing}  ISSUE:`, issue);
+          }
+
+          return handlerResults;
+        }),
+      );
+
+      // Check properties for subtypes
+      const properties = Object.keys(data).filter(
+        (key) =>
+          // Ignore LD-JSON properties
+          !key.startsWith('@') &&
+          data[key] !== null &&
+          data[key] !== undefined &&
+          // Array of objects
+          // Array of objects
+          ((Array.isArray(data[key]) &&
+            data[key].length > 0 &&
+            typeof data[key][0] === 'object') ||
+            // Object
+            (!Array.isArray(data[key]) && typeof data[key] === 'object')),
+      );
+      if (this.debug && properties.length > 0) {
+        console.debug(`${spacing}PROPERTIES:`, properties);
+      }
+
+      const propertyIssues = await Promise.all(
+        properties.map((property) => {
+          const newPathElem = { property };
+          if (data[property]?.['@type']) {
+            newPathElem.type = data[property]['@type'];
+          }
+          return this.#validateSubtree(data[property], rootData, dataFormat, [
+            ...path,
+            newPathElem,
+          ]);
+        }),
+      );
+
+      return [...typeIssues.flat(), ...propertyIssues.flat()];
+    }
+
+    return [];
+  }
+
+  /**
+   * Validates structured data
+   * @param {object} waeData Data as parsed from Web Auto Extractor
+   * @returns {object[]} Array of validation issues
+   */
+  async validate(waeData) {
+    const dataFormats = ['jsonld', 'microdata', 'rdfa'];
+
+    const results = [];
+
+    for (const dataFormat of dataFormats) {
+      if (
+        !waeData[dataFormat] ||
+        Object.keys(waeData[dataFormat]).length === 0
+      ) {
+        continue;
+      }
+      this.debug && console.debug('DATA FORMAT:', dataFormat);
+      const rootTypes = Object.keys(waeData[dataFormat]);
+
+      // Validate root type items
+      for (const rootType of rootTypes) {
+        this.debug && console.debug('  ROOT TYPE:', rootType);
+        const rootTypeItems = waeData[dataFormat][rootType];
+
+        // Validate each root type item
+        for (const [index, item] of rootTypeItems.entries()) {
+          const location = item['@location'];
+          delete item['@location'];
+
+          const issues = await this.#validateSubtree(item, item, dataFormat, [
+            { type: rootType, index },
+          ]);
+          issues.forEach((issue) => {
+            let source = item['@source'];
+            if (!source && dataFormat === 'jsonld') {
+              source = JSON.stringify(item);
+            }
+            results.push({
+              rootType,
+              dataFormat,
+              location,
+              source,
+              ...issue,
+            });
+          });
+        }
+      }
+    }
+
+    // Expose WAE errors, filter out metadata errors
+    const errors = waeData.errors?.filter((e) =>
+      dataFormats.includes(e.format),
+    );
+    for (const error of errors || []) {
+      const result = {
+        dataFormat: error.format,
+        issueMessage: error.message,
+        rootType: error.format,
+        severity: 'ERROR',
+      };
+      if (error.sourceCodeLocation) {
+        result.location = `${error.sourceCodeLocation.startOffset},${error.sourceCodeLocation.endOffset}`;
+      }
+      if (error.source) {
+        result.source = error.source;
+      }
+      results.push(result);
+    }
+
+    return results;
+  }
+}