@lionweb/validation 0.7.0-beta.0 → 0.7.0-beta.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lionweb/validation",
-  "version": "0.7.0-beta.0",
+  "version": "0.7.0-beta.10",
   "license": "Apache 2.0",
   "description": "LionWeb Serialization validation",
   "author": "jos.warmer@openmodeling.nl",
@@ -14,14 +14,15 @@
     "testing"
   ],
   "scripts": {
-    "clean": "rm -rf dist/ node_modules/ lionweb-validation-*.tgz",
+    "clean": "npx rimraf dist node_modules -g lionweb-validation-*.tgz",
     "build": "tsc && npm run copyM3 && npm run copyBuiltins",
     "copyM3": "node -e \"const fs = require('fs'); fs.copyFileSync('./src/languages/LionCore-M3.json', './dist/languages/LionCore-M3.json');\"",
     "copyBuiltins": "node -e \"const fs = require('fs'); fs.copyFileSync('./src/languages/LionCore-builtins.json', './dist/languages/LionCore-builtins.json');\"",
     "lint": "eslint src",
     "test-here": "cd ../test && find dist/validation -type d | sed '1!G;h;$!d' | xargs npx mocha",
-    "release": "npm publish --registry https://registry.npmjs.org",
+    "release-alpha": "npm publish --registry https://registry.npmjs.org --tag alpha",
     "release-beta": "npm publish --registry https://registry.npmjs.org --tag beta",
+    "release": "npm publish --registry https://registry.npmjs.org",
     "testValid": "node dist/runners/RunCheckFolder.js ../test/testset/valid",
     "testInvalid": "node dist/runners/RunCheckFolder.js ../test/testset/invalid",
     "testInvalidWithLanguage": "node dist/runners/RunCheckFolderWithLanguage.js ../test/testset/withLanguage/invalid/ ../test/testset/withLanguage/myLang.language.json",
@@ -31,8 +32,8 @@
     "republish-local": "yarn unpublish-local && yarn publish-local"
   },
   "dependencies": {
-    "@lionweb/json": "0.7.0-beta.0",
-    "@lionweb/ts-utils": "0.7.0-beta.0",
-    "@lionweb/json-utils": "0.7.0-beta.0"
+    "@lionweb/json": "0.7.0-beta.10",
+    "@lionweb/ts-utils": "0.7.0-beta.10",
+    "@lionweb/json-utils": "0.7.0-beta.10"
   }
 }

package/src/issues/ValidationIssue.ts

@@ -2,16 +2,16 @@ import { JsonContext } from "@lionweb/json-utils"
 
 export abstract class ValidationIssue {
     abstract readonly issueType: string
-    context: JsonContext
+    context: JsonContext | null
 
-    constructor(context: JsonContext) {
+    constructor(context: JsonContext | null) {
         this.context = context
     }
 
     protected abstract msg(): string
 
     public errorMsg(): string {
-        return `${this.issueType}: ${this.msg()} at ${this.context.toString()} `
+        return `${this.issueType}: ${this.msg()} at ${this.context?.toString()} `
     }
 }
 
@@ -19,7 +19,7 @@ export class GenericIssue extends ValidationIssue {
     readonly issueType = "GenericIssue"
 
     constructor(
-        context: JsonContext,
+        context: JsonContext | null,
         public text: string
     ) {
         super(context)

package/src/runners/Utils.ts

@@ -48,7 +48,7 @@ export function printIssues(result: ValidationResult, file?: string): void {
 }
 
 export function issuestoString(vresult: ValidationResult, file?: string): string {
-    let result = ""
-    vresult.issues.forEach(issue => (result += (file == undefined ? "" : `File ${file}: `) + issue.errorMsg() + "\n"))
+    let result = "ISSUES: "
+    vresult.issues.forEach(issue => (result += (file === undefined ? "NOFILE" : `File ${file}: `) + issue.errorMsg() + "\n"))
     return result
 }

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

@@ -9,40 +9,38 @@ import {
 import { ValidationResult } from "./ValidationResult.js"
 import {
     isObjectDefinition,
-    isPrimitiveDefinition,
-    ObjectDefinition,
-    PrimitiveDefinition,
-    TypeDefinition,
+    isPrimitiveDefinition, ObjectDefinition, PrimitiveDefinition, DefinitionSchema,
     UnknownObjectType
-} from "./ValidationTypes.js"
+} 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 +48,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 +57,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
-            }
-            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
-                }
-                if (!propertyDef.mayBeNull && propertyValue === null) {
-                    this.validationResult.issue(new Syntax_PropertyNullIssue(jsonContext, propertyDef.property))
-                    continue
+        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
+            // }
+            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) {
-                    // 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 +206,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))
             }