@gsriram24/structured-data-validator 1.6.1 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsriram24/structured-data-validator",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "publishConfig": {
     "access": "public"
   },

package/src/types/QAPage.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 QAPageValidator extends BaseValidator {
+  getConditions() {
+    return [
+      this.required('mainEntity', 'object'),
+      this.required('mainEntity.answerCount', 'number'),
+    ].map((c) => c.bind(this));
+  }
+}

package/src/types/Question.js

@@ -15,7 +15,11 @@ export default class QuestionValidator extends BaseValidator {
   getConditions() {
     return [
       this.required('name'),
-      this.required('acceptedAnswer', 'object'),
+      this.or(
+        this.required('acceptedAnswer', 'arrayOrObject'),
+        this.required('suggestedAnswer', 'arrayOrObject'),
+      ),
+      this.recommended('text'),
     ].map((c) => c.bind(this));
   }
 }

package/src/types/schemaOrg.js

@@ -189,6 +189,11 @@ export default class SchemaOrgValidator {
     });
   }
 
+  async validateType(type) {
+    const schema = await this.#loadSchema();
+    return !!schema[type];
+  }
+
   async validate(data) {
     const issues = [];
 
@@ -197,6 +202,22 @@ export default class SchemaOrgValidator {
         return [];
       }
 
+      const typeId = this.#stripSchema(this.type);
+
+      // Check if type exists in schema.org
+      const typeExists = await this.validateType(typeId);
+      if (!typeExists) {
+        issues.push({
+          issueMessage: `Type "${typeId}" is not a valid schema.org type`,
+          severity: 'WARNING',
+          path: this.path,
+          errorType: 'schemaOrg',
+          fieldName: '@type',
+        });
+        // Skip property validation since type is invalid
+        return issues;
+      }
+
       // Get list of properties, any other keys which do not start with @
       const properties = Object.keys(data).filter(
         (key) => !key.startsWith('@'),
@@ -206,7 +227,6 @@ export default class SchemaOrgValidator {
       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) {

package/src/validator.js

@@ -33,6 +33,7 @@ export class Validator {
       Event: [() => import('./types/Event.js')],
       FAQPage: [() => import('./types/FAQPage.js')],
       HowTo: [() => import('./types/HowTo.js')],
+      QAPage: [() => import('./types/QAPage.js')],
       ImageObject: [() => import('./types/ImageObject.js')],
       VideoObject: [() => import('./types/VideoObject.js')],
       Clip: [() => import('./types/Clip.js')],
@@ -178,14 +179,17 @@ export class Validator {
 
           // Find supported handlers (check direct mapping first, then parent types)
           const handlers = await this.#getHandlersForType(type);
-          if (!handlers || handlers.length === 0) {
+          if (handlers.length === 0) {
             this.debug &&
               console.warn(
                 `${spacing}  WARN: No handlers registered for type: ${type}`,
               );
-            return [];
           }
+          // Always run global handlers (e.g., schemaOrg) even if no type-specific handler exists
           handlers.push(...(this.globalHandlers || []));
+          if (handlers.length === 0) {
+            return [];
+          }
 
           const handlerPromises = handlers.map(async (handler) => {
             const handlerClass = (await handler()).default;