@lionweb/validation 0.7.0-beta.7 → 0.7.0-beta.9

package/src/validators/LionWebChunkDefinitions.ts

@@ -1,112 +1,102 @@
-import { MAY_BE_NULL, PrimitiveDef, PropertyDef, TypeDefinition } from "./generic/ValidationTypes.js"
+import { DefinitionSchema,  MAY_BE_NULL, PropertyDef, PrimitiveDef } from "./generic/index.js"
 import { validateId, validateKey, validateSerializationFormatVersion, validateVersion } from "./ValidationFunctions.js"
 
 /**
  * The structure below defines the structure of a LionWeb Chunk by defining all the properties.
  * It can
- *   - be fed to the SyntaxValidator to validate an object sat runtime.
- *   - used to generate all the types for a LionWebChunk.
+ *   - be used by the SyntaxValidator to validate an object sat runtime.
+ *   - used to generate all the TypeScript types for a LionWebChunk.
  */
-export const expectedTypes: Map<string, TypeDefinition> = new Map<string, TypeDefinition>([
-    [
-        "LionWebMetaPointer",
-        [
-            PropertyDef({ property: "key", expectedType: "LionWebKey" }),
-            PropertyDef({ property: "version", expectedType: "LionWebVersion" }),
-            PropertyDef({ property: "language", expectedType: "LionWebKey" })
+export const LionWebSchema: DefinitionSchema = new DefinitionSchema([], [
+    {
+        name: "LionWebJsonMetaPointer",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" }),
+            PropertyDef({ name: "language", type: "LionWebKey" })
         ]
-    ],
-    [
-        "ResponseMessage",
-        [
-            PropertyDef({ property: "kind", expectedType: "string" }),
-            PropertyDef({ property: "message", expectedType: "string" }),
-            PropertyDef({ property: "data", expectedType: "object", mayBeNull: true, isOptional: true })
+    },
+    {
+        name: "LionWebJsonMetaPointer",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" }),
+            PropertyDef({ name: "language", type: "LionWebKey" }),
         ]
-    ],
-    [
-        "LionWebChunk",
-        [
-            PropertyDef({ property: "serializationFormatVersion", expectedType: "LionWebSerializationFormatVersion" }),
-            PropertyDef({ property: "languages", expectedType: "LionWebUsedLanguage", isList: true }),
-            PropertyDef({ property: "nodes", expectedType: "LionWebNode", isList: true })
+    },
+    {
+        name: "ResponseMessage",
+        properties: [
+            PropertyDef({ name: "kind", type: "JSstring" }),
+            PropertyDef({ name: "message", type: "JSstring" }),
+            PropertyDef({ name: "data", type: "JSobject", mayBeNull: true, isOptional: true })
         ]
-    ],
-    [
-        "LionWebUsedLanguage",
-        [
-            PropertyDef({ property: "key", expectedType: "LionWebKey" }),
-            PropertyDef({ property: "version", expectedType: "LionWebVersion" })
+    },
+    {
+        name: "LionWebJsonChunk",
+        properties: [
+            PropertyDef({ name: "serializationFormatVersion", type: "LionWebSerializationFormatVersion" }),
+            PropertyDef({ name: "languages", type: "LionWebJsonUsedLanguage", isList: true }),
+            PropertyDef({ name: "nodes", type: "LionWebJsonNode", isList: true })
         ]
-    ],
-    [
-        "LionWebNode",
-        [
-            PropertyDef({ property: "id", expectedType: "LionWebId" }),
-            PropertyDef({ property: "classifier", expectedType: "LionWebMetaPointer" }),
-            PropertyDef({ property: "properties", expectedType: "LionWebProperty", isList: true }),
-            PropertyDef({ property: "containments", expectedType: "LionWebContainment", isList: true }),
-            PropertyDef({ property: "references", expectedType: "LionWebReference", isList: true }),
-            PropertyDef({ property: "annotations", expectedType: "LionWebId", isList: true }),
-            PropertyDef({ property: "parent", expectedType: "LionWebId", mayBeNull: MAY_BE_NULL }),
+    },
+    {
+        name: "LionWebJsonUsedLanguage",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" })
         ]
-    ],
-    [
-        "LionWebProperty",
-        [
-            PropertyDef({ property: "property", expectedType: "LionWebMetaPointer" }),
-            PropertyDef({ property: "value", expectedType: "string", mayBeNull: MAY_BE_NULL }),
+    },
+    {
+        name: "LionWebJsonNode",
+        properties: [
+            PropertyDef({ name: "id", type: "LionWebId" }),
+            PropertyDef({ name: "classifier", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "properties", type: "LionWebJsonProperty", isList: true }),
+            PropertyDef({ name: "containments", type: "LionWebJsonContainment", isList: true }),
+            PropertyDef({ name: "references", type: "LionWebJsonReference", isList: true }),
+            PropertyDef({ name: "annotations", type: "LionWebId", isList: true }),
+            PropertyDef({ name: "parent", type: "LionWebId", mayBeNull: MAY_BE_NULL }),
         ]
-    ],
-    [
-        "LionWebContainment",
-        [
-            PropertyDef({ property: "containment", expectedType: "LionWebMetaPointer" }),
-            PropertyDef({ property: "children", expectedType: "LionWebId", isList: true }),
+    },
+    {
+        name: "LionWebJsonProperty",
+        properties: [
+            PropertyDef({ name: "property", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "value", type: "JSstring", mayBeNull: MAY_BE_NULL }),
         ]
-    ],
-    [
-        "LionWebReference",
-        [
-            PropertyDef({ property: "reference", expectedType: "LionWebMetaPointer"}),
-            PropertyDef({ property: "targets", expectedType: "LionWebReferenceTarget", isList: true}),
+    },
+    {
+        name: "LionWebJsonContainment",
+        properties: [
+            PropertyDef({ name: "containment", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "children", type: "LionWebId", isList: true }),
         ]
-    ],
-    [
-        "LionWebReferenceTarget",
-        [
-            PropertyDef({ property: "resolveInfo", expectedType: "string", mayBeNull: MAY_BE_NULL }),
-            PropertyDef({ property: "reference", expectedType: "LionWebId", mayBeNull: MAY_BE_NULL }),
+    },
+    {
+        name: "LionWebJsonReference",
+        properties: [
+            PropertyDef({ name: "reference", type: "LionWebJsonMetaPointer"}),
+            PropertyDef({ name: "targets", type: "LionWebJsonReferenceTarget", isList: true}),
         ]
-    ],
+    },
+    {
+        name: "LionWebJsonReferenceTarget",
+        properties: [
+            PropertyDef({ name: "resolveInfo", type: "JSstring", mayBeNull: MAY_BE_NULL }),
+            PropertyDef({ name: "reference", type: "LionWebId", mayBeNull: MAY_BE_NULL }),
+        ]
+    },
     /**
      * Elements without properties are assumed to be JSON/JS primitive values, and tested using `typeof`
      * and the (optional) validate function.
      */
-    [
-        "LionWebId",
-        PrimitiveDef({ primitiveType: "string", validate: validateId }),
-    ],
-    [
-        "LionWebKey",
-        PrimitiveDef({ primitiveType: "string", validate: validateKey }),
-    ],
-    [
-        "LionWebVersion",
-        PrimitiveDef({ primitiveType: "string", validate: validateVersion }),
-    ],
-    [
-        "LionWebSerializationFormatVersion",
-        PrimitiveDef({ primitiveType: "string", validate: validateSerializationFormatVersion }),
-    ],
-    [
-        "string",
-        PrimitiveDef({ primitiveType: "string" }),
-    ],
-    [
-        "object",
-        PrimitiveDef({ primitiveType: "object" }),
-    ]
+    PrimitiveDef({ name: "LionWebId", primitiveType: "string", validate: validateId }),
+    PrimitiveDef({ name: "LionWebKey", primitiveType: "string", validate: validateKey }),
+    PrimitiveDef({ name: "LionWebVersion",primitiveType: "string", validate: validateVersion }),
+    PrimitiveDef({ name: "LionWebSerializationFormatVersion",primitiveType: "string", validate: validateSerializationFormatVersion }),
+    PrimitiveDef({ name: "JSstring", primitiveType: "string" }),
+    PrimitiveDef({ name: "JSobject",primitiveType: "object" }),
 ])
 
 

package/src/validators/LionWebSyntaxValidator.ts

@@ -1,6 +1,6 @@
 import { SyntaxValidator } from "./generic/SyntaxValidator.js"
 import { ValidationResult } from "./generic/ValidationResult.js"
-import { expectedTypes } from "./LionWebChunkDefinitions.js"
+import { LionWebSchema } from "./LionWebChunkDefinitions.js"
 
 /**
  * LionWebSyntaxValidator can check whether objects are structurally LionWeb objects.
@@ -8,7 +8,7 @@ import { expectedTypes } from "./LionWebChunkDefinitions.js"
 export class LionWebSyntaxValidator extends SyntaxValidator {
 
     constructor(validationResult: ValidationResult) {
-        super(validationResult, expectedTypes)
+        super(validationResult, LionWebSchema)
     }
 }
 

package/src/validators/LionWebValidator.ts

@@ -34,7 +34,7 @@ export class LionWebValidator {
     }
 
     validateSyntax() {
-        this.syntaxValidator.validate(this.object, "LionWebChunk")
+        this.syntaxValidator.validate(this.object, "LionWebJsonChunk")
         this.syntaxCorrect = !this.validationResult.hasErrors()
         if (this.syntaxCorrect) {
             this.chunk = new LionWebJsonChunkWrapper(this.object as LionWebJsonChunk)

package/src/validators/ValidationFunctions.ts

@@ -12,7 +12,7 @@ import {
     Syntax_VersionFormat_Issue
 } from "../issues/SyntaxIssues.js"
 import { ValidationResult } from "./generic/ValidationResult.js"
-import { PropertyDefinition } from "./generic/ValidationTypes.js"
+import { PropertyDefinition } from "./generic/schema/ValidationTypes.js"
 
 /**
  * Check whether `id` is a valid LionWeb id.
@@ -72,7 +72,7 @@ export function validateBoolean<String>(value: String, result: ValidationResult,
         result.issue(
             new Language_PropertyValue_Issue(
                 context,
-                propDef ? propDef.property : "unknown",
+                propDef ? propDef.name : "unknown",
                 valueAsPrimitive,
                 "boolean " + JSON.stringify(value)
             )
@@ -92,7 +92,7 @@ export function validateInteger<String>(value: String, result: ValidationResult,
     const valueAsPrimitive = "" + value
     const regexp = /^[+-]?(0|[1-9][0-9]*)$/
     if (valueAsPrimitive === null || !regexp.test(valueAsPrimitive)) {
-        result.issue(new Language_PropertyValue_Issue(context, propDef ? propDef.property : "unknown", valueAsPrimitive, "integer"))
+        result.issue(new Language_PropertyValue_Issue(context, propDef ? propDef.name : "unknown", valueAsPrimitive, "integer"))
     }
 }
 
@@ -107,12 +107,12 @@ export function validateInteger<String>(value: String, result: ValidationResult,
 export function validateJSON<String>(value: String, result: ValidationResult, context: JsonContext, propDef?: PropertyDefinition): void {
     const valueAsPrimitive = "" + value
     if (value === null) {
-        result.issue(new Syntax_PropertyNullIssue(context, propDef!.property!))
+        result.issue(new Syntax_PropertyNullIssue(context, propDef!.name!))
     }
     try {
         JSON.parse(valueAsPrimitive)
     } catch (e) {
-        result.issue(new Language_PropertyValue_Issue(context, propDef ? propDef.property : "unknown", valueAsPrimitive, "JSON"))
+        result.issue(new Language_PropertyValue_Issue(context, propDef ? propDef.name : "unknown", valueAsPrimitive, "JSON"))
     }
 }
 

package/src/validators/generic/SyntaxValidator.ts

@@ -1,5 +1,6 @@
 import { JsonContext } from "@lionweb/json-utils"
 import {
+    GenericIssue,
     Syntax_ArrayContainsNull_Issue,
     Syntax_PropertyMissingIssue,
     Syntax_PropertyNullIssue,
@@ -9,40 +10,38 @@ import {
 import { ValidationResult } from "./ValidationResult.js"
 import {
     isObjectDefinition,
-    isPrimitiveDefinition,
-    ObjectDefinition,
-    PrimitiveDefinition,
-    TypeDefinition,
-    UnknownObjectType
-} from "./ValidationTypes.js"
+    isPrimitiveDefinition, ObjectDefinition, PrimitiveDefinition, DefinitionSchema,
+    UnknownObjectType, PropertyDefinition
+} from "./schema/index.js"
 
 /**
- * Syntax Validator can check whether objects are structurally conforming to the
- * definitions given in `typeDefinitions`.
+ * Syntax Validator checks whether objects are structurally conforming to the
+ * definitions given in `schema`.
  */
 export class SyntaxValidator {
     validationResult: ValidationResult
-    typeDefinitions: Map<string, TypeDefinition>
+    schema: DefinitionSchema
 
-    constructor(validationResult: ValidationResult, expectedTypes: Map<string, TypeDefinition>) {
+    constructor(validationResult: ValidationResult, schema: DefinitionSchema) {
         this.validationResult = validationResult
-        this.typeDefinitions = expectedTypes
+        this.schema = schema
     }
 
     /**
      * Check whether `obj` is a JSON object that conforms to the definition of `expectedType`.
-     * All errors found will be pushed into the `errors` array, if its length is not 0, the check has failed.
+     * All errors found will be added to the `validationResult` object.
      * @param obj           The object to validate.
      * @param expectedType  The expected type of the object.
      */
     validate(obj: unknown, expectedType: string) {
         const object = obj as UnknownObjectType
-        const typeDef = this.typeDefinitions.get(expectedType)
+        const typeDef = this.schema.getDefinition(expectedType)
+
         if (typeDef === undefined) {
             throw new Error(`SyntaxValidator.validate: cannot find definition for ${expectedType}`)
-        } else if (isObjectDefinition(typeDef)){
+        } else if (isObjectDefinition(typeDef)) {
             this.validateObjectProperties(expectedType, typeDef, object, new JsonContext(null, ["$"]))
-        } else if( isPrimitiveDefinition(typeDef)) {
+        } else if (isPrimitiveDefinition(typeDef)) {
             this.validatePrimitiveValue("$", typeDef, object, new JsonContext(null, ["$"]))
         }
     }
@@ -50,7 +49,7 @@ export class SyntaxValidator {
     /**
      * Validate whether `object` is structured conform the properties in `propertyDef`
      * @param originalProperty  The property of which `object` it the value
-     * @param typeDef       The property definitions that are being validated
+     * @param typeDef           The property definitions that are being validated
      * @param object            The object being validated
      * @param jsonContext       The location in the JSON
      * @private
@@ -59,99 +58,147 @@ export class SyntaxValidator {
         if (typeDef === null || typeDef === undefined) {
             return
         }
-            if ((typeof object) !== "object") {
-                this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, originalProperty, "object", typeof object))
-                return
+        if (typeof object !== "object") {
+            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, originalProperty, "object", typeof object))
+            return
+        }
+        for (const propertyDef of typeDef.properties) {
+            const taggedUnion = this.schema.getTaggedUnionDefinition(propertyDef.type)
+            if (taggedUnion !== undefined) {
+                this.validateTaggedUnion(propertyDef, typeDef, object, jsonContext.concat(propertyDef.name))
+                continue
             }
-            for (const propertyDef of typeDef) {
-                const expectedTypeDef = this.typeDefinitions.get(propertyDef.expectedType)
-                const validator = propertyDef.validate!
-                const propertyValue = object[propertyDef.property]
-                if (propertyValue === undefined) {
-                    if (!propertyDef.isOptional) {
-                        this.validationResult.issue(new Syntax_PropertyMissingIssue(jsonContext, propertyDef.property))
-                    }
-                    continue
+            const expectedTypeDef = this.schema.getDefinition(propertyDef.type)
+            const validator = propertyDef.validate!
+            const propertyValue = object[propertyDef.name]
+            if (propertyValue === undefined) {
+                if (!propertyDef.isOptional) {
+                    this.validationResult.issue(new Syntax_PropertyMissingIssue(jsonContext, propertyDef.name))
                 }
-                if (!propertyDef.mayBeNull && propertyValue === null) {
-                    this.validationResult.issue(new Syntax_PropertyNullIssue(jsonContext, propertyDef.property))
-                    continue
-                }
-                if (propertyDef.mayBeNull && propertyValue === null) {
-                    // Ok, stop checking, continue with next property def
-                    continue
+                continue
+            }
+            if (!propertyDef.mayBeNull && propertyValue === null) {
+                this.validationResult.issue(new Syntax_PropertyNullIssue(jsonContext, propertyDef.name))
+                continue
+            }
+            if (propertyDef.mayBeNull && propertyValue === null) {
+                // Ok, stop checking, continue with next property def
+                continue
+            }
+            if (propertyDef.isList) {
+                // Check whether value is an array
+                if (!Array.isArray(propertyValue)) {
+                    const newContext = jsonContext.concat(propertyDef.name)
+                    this.validationResult.issue(new Syntax_PropertyTypeIssue(newContext, propertyDef.name, "array", typeof propertyValue))
+                    return
                 }
-                if (propertyDef.isList) {
-                    // Check whether value is an array
-                    if (!Array.isArray(propertyValue)) {
-                        const newContext = jsonContext.concat(propertyDef.property)
-                        this.validationResult.issue(new Syntax_PropertyTypeIssue(newContext, propertyDef.property, "array", typeof propertyValue))
-                        return
-                    }
-                    // If an array, validate every item in the array
-                    (propertyValue as UnknownObjectType[]).forEach((item, index) => {
-                        const newContext = jsonContext.concat(propertyDef.property, index)
-                        if (item === null) {
-                            this.validationResult.issue(new Syntax_ArrayContainsNull_Issue(newContext, propertyDef.property, index))
-                        } else {
-                            if (expectedTypeDef !== undefined) {
-                                if (isPrimitiveDefinition(expectedTypeDef)) {
-                                    // propertyValue should be a primitive as it has no property definitions
-                                    if (this.validatePrimitiveValue(propertyDef.property, expectedTypeDef, item, jsonContext)) {
-                                        validator.apply(null, [item, this.validationResult, newContext, propertyDef])
-                                    }
-                                } else {
-                                    // propertyValue should be an object, validate its properties
-                                    this.validateObjectProperties(propertyDef.property, expectedTypeDef, item as UnknownObjectType, newContext)
+                // If an array, validate every item in the array
+                (propertyValue as UnknownObjectType[]).forEach((item, index) => {
+                    const newContext = jsonContext.concat(propertyDef.name, index)
+                    if (item === null) {
+                        this.validationResult.issue(new Syntax_ArrayContainsNull_Issue(newContext, propertyDef.name, index))
+                    } else {
+                        if (expectedTypeDef !== undefined) {
+                            if (isPrimitiveDefinition(expectedTypeDef)) {
+                                if (this.validatePrimitiveValue(propertyDef.name, expectedTypeDef, item, jsonContext)) {
                                     validator.apply(null, [item, this.validationResult, newContext, propertyDef])
                                 }
                             } else {
-                                throw new Error(`Expected type '${propertyDef.expectedType} has neither property defs, nor a validator.`)
+                                // propertyValue should be an object, validate its properties
+                                this.validateObjectProperties(propertyDef.name, expectedTypeDef, item as UnknownObjectType, newContext)
+                                validator.apply(null, [item, this.validationResult, newContext, propertyDef])
                             }
+                        } else {
+                            throw new Error(`Expected type '${propertyDef.type} has neither property defs, nor a validator.`)
                         }
-                    })
-                } else {
-                    const newContext = jsonContext.concat(propertyDef.property)
-                    if (Array.isArray(propertyValue)) {
-                        this.validationResult.issue(new Syntax_PropertyTypeIssue(newContext, propertyDef.property, propertyDef.expectedType, "array"))
-                        return
                     }
-                    // Single valued property, validate it
-                    if (expectedTypeDef !== undefined) {
-                        if (isPrimitiveDefinition(expectedTypeDef)) {
-                            // propertyValue should be a primitive as it has no property definitions
-                            if (this.validatePrimitiveValue(propertyDef.property, expectedTypeDef, propertyValue, jsonContext)) {
-                                validator.apply(null, [propertyValue, this.validationResult, newContext, propertyDef])
-                            }
-                        } else if (isObjectDefinition(expectedTypeDef)) {
-                            // propertyValue should be an object, validate its properties
-                            this.validateObjectProperties(propertyDef.property, expectedTypeDef, propertyValue as UnknownObjectType, newContext)
+                })
+            } else {
+                const newContext = jsonContext.concat(propertyDef.name)
+                if (Array.isArray(propertyValue)) {
+                    this.validationResult.issue(new Syntax_PropertyTypeIssue(newContext, propertyDef.name, propertyDef.type, "array"))
+                    return
+                }
+                // Single valued property, validate it
+                if (expectedTypeDef !== undefined) {
+                    if (isPrimitiveDefinition(expectedTypeDef)) {
+                        // propertyValue should be a primitive as it has no property definitions
+                        if (this.validatePrimitiveValue(propertyDef.name, expectedTypeDef, propertyValue, jsonContext)) {
                             validator.apply(null, [propertyValue, this.validationResult, newContext, propertyDef])
-                        } else {
-                            throw new Error("EXPECTING ObjectDefinition or PrimitiveDefinition, but got something else")
                         }
+                    } else if (isObjectDefinition(expectedTypeDef)) {
+                        // propertyValue should be an object, validate its properties
+                        this.validateObjectProperties(propertyDef.name, expectedTypeDef, propertyValue as UnknownObjectType, newContext)
+                        validator.apply(null, [propertyValue, this.validationResult, newContext, propertyDef])
                     } else {
-                        throw new Error(`Expected single type '${propertyDef.expectedType}' for '${propertyDef.property}'  at ${newContext.toString()} has neither property defs, nor a validator.`)
+                        throw new Error("EXPECTING ObjectDefinition or PrimitiveDefinition, but got something else")
                     }
+                } else {
+                    throw new Error(
+                        `Expected single type '${propertyDef.type}' for '${propertyDef.name}'  at ${newContext.toString()} has neither property defs, nor a validator.`
+                    )
                 }
             }
-            this.checkStrayProperties(object, typeDef, jsonContext)
+        }
+        this.checkStrayProperties(object, typeDef, jsonContext)
     }
-    
-    validatePrimitiveValue(propertyName: string, propDef: PrimitiveDefinition, object: unknown, jsonContext: JsonContext): boolean {
-        // if (!propDef.mayBeNull && (object === null || object === undefined)) {
-        //     this.validationResult.issue(new Syntax_PropertyNullIssue(jsonContext, propDef.property))
-        //     return false
-        // }
 
+    validatePrimitiveValue(propertyName: string, propDef: PrimitiveDefinition, object: unknown, jsonContext: JsonContext): boolean {
         if (typeof object !== propDef.primitiveType) {
-            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, propertyName, propDef.primitiveType,typeof object))
+            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, propertyName, propDef.primitiveType, typeof object))
             return false
         }
         propDef.validate!(object, this.validationResult, jsonContext)
         return true
     }
 
+    /**
+     *
+     * @param propertyDef the definition of the property that has the TaggedUnionType as its type
+     * @param typeDef The object definition containing the `propertyDef`
+     * @param object The object of type `typeDef` that should have the property described by `propertyDef`
+     * @param jsonContext
+     */
+    validateTaggedUnion(
+        propertyDef: PropertyDefinition,
+        typeDef: ObjectDefinition,
+        object: UnknownObjectType,
+        jsonContext: JsonContext
+    ): void {
+        // console.log(`validateTaggedUnion ${JSON.stringify(propertyDef)}, typedef ${typeDef.name}  object: ${JSON.stringify(object, null, 3)}`)
+        const taggedObject = object[propertyDef.name]
+        if (propertyDef.isList) {
+            if (!Array.isArray(taggedObject)) {
+                this.validationResult.issue(new GenericIssue(jsonContext, `Property value '${propertyDef.name}' expects an array, found '${typeof taggedObject}'`))
+            } else {
+                taggedObject.forEach((taggedObjectSingle, index) => {
+                    this.validateTaggedObject(taggedObjectSingle, jsonContext.concat(index))
+                })
+            }
+        } else {
+            if (!(typeof taggedObject === "object")) {
+                this.validationResult.issue(new GenericIssue(jsonContext, `Property value '${propertyDef.name}' expects an object, found '${typeof taggedObject}'`))
+            } else {
+                this.validateTaggedObject(taggedObject as UnknownObjectType, jsonContext)
+            }
+        }
+    }
+
+    /**
+     * Validate a single tagged object
+     * @param taggedObject
+     * @param jsonContext
+     */
+    validateTaggedObject(taggedObject: UnknownObjectType, jsonContext: JsonContext): void {
+        const actualTypeName = taggedObject["messageKind"] as string
+        const actualType = this.schema.getDefinition(actualTypeName)
+        if (actualType === undefined || !isObjectDefinition(actualType)) {
+            this.validationResult.issue(new GenericIssue(jsonContext, `Expected object type is ${typeof taggedObject}, should be object`))
+        } else {
+            this.validateObjectProperties(actualTypeName, actualType, taggedObject, jsonContext)
+        }
+    }
+
     /**
      * Check whether there are extra properties that should not be there.
      * @param obj           Object to be validated
@@ -160,8 +207,8 @@ export class SyntaxValidator {
      */
     checkStrayProperties(obj: UnknownObjectType, def: ObjectDefinition, context: JsonContext) {
         const own = Object.getOwnPropertyNames(obj)
-        const defined = def.map(pdef => pdef.property)
-        own.forEach((ownProp) => {
+        const defined = def.properties.map(pdef => pdef.name)
+        own.forEach(ownProp => {
             if (!defined.includes(ownProp)) {
                 this.validationResult.issue(new Syntax_PropertyUnknownIssue(context, ownProp))
             }

package/src/validators/generic/index.ts

@@ -1,3 +1,3 @@
-export * from "./ValidationTypes.js"
+export * from "./schema/index.js"
 export * from "./ValidationResult.js"
 export * from "./SyntaxValidator.js"