@gsriram24/structured-data-validator 1.6.0

package/src/types/Review.js

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+import BaseValidator from './base.js';
+
+export default class ReviewValidator extends BaseValidator {
+  getConditions() {
+    const conditions = [
+      this.required('author'),
+
+      // Documentation states reviewRating as required
+      // Validator allows it to be missing
+      this.required('reviewRating'),
+
+      this.recommended('datePublished', 'date'),
+    ];
+
+    if (this.path.length === 1) {
+      conditions.push(
+        this.required('itemReviewed'),
+        this.required('itemReviewed.name'),
+      );
+    }
+
+    return conditions.map((c) => c.bind(this));
+  }
+}

package/src/types/SeekToAction.js

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+import BaseValidator from './base.js';
+
+export default class SeekToActionValidator extends BaseValidator {
+  getConditions() {
+    const conditions = [
+      this.required('target'),
+      this.required('startOffset-input'),
+    ];
+    return conditions.map((c) => c.bind(this));
+  }
+}

package/src/types/ShippingDeliveryTime.js

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+import BaseValidator from './base.js';
+
+export default class ShippingDeliveryTimeValidator extends BaseValidator {
+  getConditions() {
+    return [
+      this.recommended('handlingTime'),
+      this.recommended('transitTime'),
+    ].map((c) => c.bind(this));
+  }
+}

package/src/types/SizeSpecification.js

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+import BaseValidator from './base.js';
+
+export default class SizeSpecificationValidator extends BaseValidator {
+  getConditions() {
+    return [
+      this.recommended('name'),
+      this.recommended('sizeGroup'),
+      this.recommended('sizeSystem'),
+    ].map((c) => c.bind(this));
+  }
+}

package/src/types/VideoObject.js

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ */
+import BaseValidator from './base.js';
+
+export default class VideoObjectValidator extends BaseValidator {
+  getConditions() {
+    const conditions = [
+      this.required('name', 'string'),
+      this.required('thumbnailUrl'),
+      this.required('uploadDate', 'date'),
+
+      this.recommended('description', 'string'),
+      this.recommended('duration', 'duration'),
+      this.recommended('expires', 'date'),
+      this.recommended('hasPart'),
+      this.recommended('publication'),
+      this.or(
+        this.recommended('contentUrl', 'url'),
+        this.recommended('embedUrl', 'url'),
+      ),
+      this.or(
+        this.recommended('ineligibleRegion'),
+        this.recommended('regionsAllowed'),
+      ),
+      this.or(
+        this.recommended('interactionStatistic'),
+        this.recommended('interactionCount'),
+      ),
+    ];
+    return conditions.map((c) => c.bind(this));
+  }
+}

package/src/types/WebSite.js

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+import BaseValidator from './base.js';
+
+export default class WebSiteValidator extends BaseValidator {
+  getConditions() {
+    return [
+      this.required('name'),
+      this.required('url', 'url'),
+
+      this.recommended('potentialAction', 'arrayOrObject'),
+    ].map((c) => c.bind(this));
+  }
+}

package/src/types/base.js

@@ -0,0 +1,201 @@
+/**
+ * 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.
+ */
+import { isObject } from '../utils.js';
+
+export default class BaseValidator {
+  constructor({ dataFormat, path }) {
+    this.dataFormat = dataFormat;
+    this.path = path;
+  }
+
+  getConditions() {
+    return [];
+  }
+
+  validate(data) {
+    const issues = [];
+
+    for (const condition of this.getConditions(data)) {
+      const issue = condition(data);
+      if (Array.isArray(issue)) {
+        issues.push(...issue);
+      } else if (issue) {
+        issues.push(issue);
+      }
+    }
+
+    return issues;
+  }
+
+  #valueByPath(data, path) {
+    const parts = path.split('.');
+    let value = data;
+
+    for (const part of parts) {
+      if (value === undefined || typeof value !== 'object') {
+        return undefined;
+      }
+      value = value[part];
+    }
+
+    return value;
+  }
+
+  required(name, type, ...opts) {
+    return (data) => {
+      const value = this.#valueByPath(data, name);
+      if (value === undefined || value === null || value === '') {
+        return {
+          issueMessage: `Required attribute "${name}" is missing`,
+          severity: 'ERROR',
+          path: this.path,
+          fieldName: name,
+        };
+      }
+      if (type && !this.checkType(value, type, ...opts)) {
+        return {
+          issueMessage: `Invalid type for attribute "${name}"`,
+          severity: 'ERROR',
+          path: this.path,
+          fieldName: name,
+        };
+      }
+      return null;
+    };
+  }
+
+  or(...conditions) {
+    return (element, index, data) => {
+      const issues = conditions.map((c) => c(element, index, data));
+      const pass = issues.some(
+        (i) => i === null || (Array.isArray(i) && i.length === 0),
+      );
+      if (pass) {
+        return null;
+      }
+
+      // Use highest severity of the issues
+      const severity = issues.reduce((max, i) => {
+        if (i && i.severity === 'ERROR') {
+          return 'ERROR';
+        }
+        return max;
+      }, 'WARNING');
+
+      // Collect all field names from the conditions
+      const fieldNames = issues
+        .flat()
+        .filter((i) => i && i.fieldName)
+        .map((i) => i.fieldName);
+
+      return {
+        issueMessage: `One of the following conditions needs to be met: ${issues
+          .flat()
+          .map((c) => c.issueMessage)
+          .join(' or ')}`,
+        severity,
+        path: this.path,
+        fieldName: fieldNames[0] || null,
+        fieldNames: fieldNames.length > 0 ? fieldNames : undefined,
+      };
+    };
+  }
+
+  recommended(name, type, ...opts) {
+    return (data) => {
+      const value = this.#valueByPath(data, name);
+      if (value === undefined || value === null || value === '') {
+        return {
+          issueMessage: `Missing field "${name}" (optional)`,
+          severity: 'WARNING',
+          path: this.path,
+          fieldName: name,
+        };
+      }
+      if (type && !this.checkType(value, type, ...opts)) {
+        return {
+          issueMessage: `Invalid type for attribute "${name}"`,
+          severity: 'WARNING',
+          path: this.path,
+          fieldName: name,
+        };
+      }
+      return null;
+    };
+  }
+
+  checkType(data, type, ...value) {
+    // TODO: Write tests for all type checks
+    if (type === 'string' && typeof data !== 'string') {
+      return false;
+    } else if (type === 'arrayOrObject') {
+      return isObject(data) || Array.isArray(data);
+    } else if (type === 'array' && !Array.isArray(data)) {
+      return false;
+    } else if (type === 'object') {
+      return isObject(data);
+    } else if (type === 'number') {
+      if (typeof data === 'number') {
+        return true;
+      }
+      if (typeof data === 'string') {
+        const num = Number(data);
+        return !isNaN(num);
+      }
+      return false;
+    } else if (type === 'date') {
+      const date = new Date(data);
+      return !isNaN(date.getTime());
+    } else if (type === 'url') {
+      // Absolute or relative URL, but no data: URLs
+      let urlValues = Array.isArray(data) ? data : [data];
+      for (const url of urlValues) {
+        if (url.startsWith('data:')) {
+          return false;
+        }
+        try {
+          new URL(url, 'https://example.com');
+        } catch (e) {
+          return false;
+        }
+      }
+    } else if (type === 'currency') {
+      return typeof data === 'string' && /^[A-Z]{3}$/.test(data);
+    } else if (type === 'enum' && !value.includes(data)) {
+      return false;
+    } else if (type === 'regex' && !value.test(data)) {
+      return false;
+    } else if (type === 'duration' && !this.validDurationFormat(data)) {
+      return false;
+    }
+    return true;
+  }
+
+  inType(type) {
+    return (
+      this.path.length > 1 && this.path[this.path.length - 2].type === type
+    );
+  }
+
+  inProperty(property) {
+    return (
+      this.path.length > 1 &&
+      this.path[this.path.length - 1].property === property
+    );
+  }
+
+  validDurationFormat(time) {
+    const durationRegex =
+      /^P(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(\d+H)?(\d+M)?(\d+S)?)?$/;
+    return durationRegex.test(time);
+  }
+}

package/src/types/schemaOrg.js

@@ -0,0 +1,227 @@
+/**
+ * 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 default class SchemaOrgValidator {
+  // Cache schema globally to improve performance
+  static schemaCache = null;
+
+  constructor({ dataFormat, path, type, schemaOrgJson }) {
+    this.dataFormat = dataFormat;
+    this.path = path;
+    this.type = type;
+    this.schemaOrgJson = schemaOrgJson;
+  }
+
+  #stripSchema(name) {
+    if (name.startsWith('schema:')) {
+      return name.replace('schema:', '');
+    }
+
+    if (name.startsWith('http://schema.org/')) {
+      return name.replace('http://schema.org/', '');
+    }
+
+    if (name.startsWith('https://schema.org/')) {
+      return name.replace('https://schema.org/', '');
+    }
+
+    return name;
+  }
+
+  async #loadSchema() {
+    if (SchemaOrgValidator.schemaCache instanceof Promise) {
+      return SchemaOrgValidator.schemaCache;
+    }
+
+    SchemaOrgValidator.schemaCache = new Promise((resolve) => {
+      const schema = {};
+
+      // Get all types
+      const entites = this.schemaOrgJson['@graph'];
+      entites
+        .filter((entity) => entity['@type'] === 'rdfs:Class')
+        .forEach((type) => {
+          const name = this.#stripSchema(type['@id']);
+          schema[name] = {
+            properties: [],
+            propertiesFromParent: {},
+          };
+          if (Array.isArray(type['rdfs:subClassOf'])) {
+            schema[name].parents = type['rdfs:subClassOf'].map((parent) =>
+              this.#stripSchema(parent['@id']),
+            );
+          } else if (type['rdfs:subClassOf']) {
+            schema[name].parents = [
+              this.#stripSchema(type['rdfs:subClassOf']['@id']),
+            ];
+          }
+        });
+
+      // Add all properties to types
+      entites
+        .filter((entity) => entity['@type'] === 'rdf:Property')
+        .forEach((property) => {
+          const domainIncludes = property['schema:domainIncludes'];
+          const types = Array.isArray(domainIncludes)
+            ? domainIncludes.map((domain) => this.#stripSchema(domain['@id']))
+            : domainIncludes
+              ? [this.#stripSchema(domainIncludes['@id'])]
+              : [];
+          types.forEach((type) => {
+            if (schema[type]) {
+              schema[type].properties.push(this.#stripSchema(property['@id']));
+            }
+          });
+        });
+
+      // TODO: Add property types for validation
+
+      // Sort properties for each type alphabetically
+      Object.keys(schema).forEach((type) => {
+        schema[type].properties.sort();
+      });
+
+      // Add inherited properties
+      const processOrder = this.#getTopologicalOrder(schema);
+      this.#addInheritedProperties(schema, processOrder);
+
+      resolve(schema);
+    });
+
+    return SchemaOrgValidator.schemaCache;
+  }
+
+  #getTopologicalOrder(schema) {
+    const visited = new Set();
+    const temp = new Set(); // For cycle detection
+    const order = [];
+
+    // Helper function for DFS
+    const visit = (typeId) => {
+      if (temp.has(typeId)) {
+        throw new Error('Cyclic inheritance detected');
+      }
+      if (visited.has(typeId)) {
+        return;
+      }
+
+      temp.add(typeId);
+
+      const type = schema[typeId];
+      if (type && type.parents) {
+        // Visit all parents before this type
+        for (const parentId of type.parents) {
+          if (schema[parentId]) {
+            visit(parentId);
+          }
+        }
+      }
+
+      temp.delete(typeId);
+      visited.add(typeId);
+      order.push(typeId);
+    };
+
+    // Process all types
+    Object.keys(schema).forEach((typeId) => {
+      if (!visited.has(typeId)) {
+        visit(typeId);
+      }
+    });
+
+    return order;
+  }
+
+  #addInheritedProperties(schema, processOrder) {
+    processOrder.forEach((typeId) => {
+      const type = schema[typeId];
+      if (type.parents && type.parents.length > 0) {
+        // Process each parent
+        for (const parentId of type.parents) {
+          if (schema[parentId]) {
+            // Add direct properties from this parent
+            type.propertiesFromParent[parentId] = [
+              ...schema[parentId].properties,
+            ];
+
+            // Add inherited properties from this parent's ancestors
+            Object.keys(schema[parentId].propertiesFromParent).forEach(
+              (ancestorId) => {
+                if (
+                  !type.propertiesFromParent[ancestorId] &&
+                  schema[parentId].propertiesFromParent[ancestorId].length > 0
+                ) {
+                  type.propertiesFromParent[ancestorId] =
+                    schema[parentId].propertiesFromParent[ancestorId];
+                }
+              },
+            );
+          }
+        }
+      }
+    });
+  }
+
+  async validateProperty(type, property) {
+    const schema = await this.#loadSchema();
+
+    // Check if type exists
+    if (!schema[type]) {
+      return false;
+    }
+
+    // Check if property is directly supported
+    if (schema[type].properties.includes(property)) {
+      return true;
+    }
+
+    // Check if property is supported through inheritance
+    return Object.keys(schema[type].propertiesFromParent).some((parent) => {
+      return schema[type].propertiesFromParent[parent].includes(property);
+    });
+  }
+
+  async validate(data) {
+    const issues = [];
+
+    if (typeof data === 'object' && data !== null) {
+      if (!this.type) {
+        return [];
+      }
+
+      // Get list of properties, any other keys which do not start with @
+      const properties = Object.keys(data).filter(
+        (key) => !key.startsWith('@'),
+      );
+
+      // Check in schema.org schema if all properties are supported within the given type
+      await Promise.all(
+        properties.map(async (property) => {
+          const propertyId = this.#stripSchema(property);
+          const typeId = this.#stripSchema(this.type);
+
+          const isValid = await this.validateProperty(typeId, propertyId);
+          if (!isValid) {
+            issues.push({
+              issueMessage: `Property "${propertyId}" for type "${typeId}" is not supported by the schema.org specification`,
+              severity: 'WARNING',
+              path: this.path,
+              errorType: 'schemaOrg',
+              fieldName: propertyId,
+            });
+          }
+        }),
+      );
+    }
+
+    return issues;
+  }
+}

package/src/utils.js

@@ -0,0 +1,15 @@
+/**
+ * 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 function isObject(obj) {
+  return obj !== null && typeof obj === 'object' && !Array.isArray(obj);
+}