@lionweb/validation 0.6.13-beta.7 → 0.7.0-beta.0

package/src/validators/LionWebChunkDefinitions.ts

@@ -1,10 +1,5 @@
-import {
-    validateId,
-    validateKey,
-    validateSerializationFormatVersion,
-    validateVersion
-} from "./ValidationFunctions.js"
-import { MAY_BE_NULL, PropertyDef, PropertyDefinition } from "./generic/ValidationTypes.js"
+import { MAY_BE_NULL, PrimitiveDef, PropertyDef, TypeDefinition } from "./generic/ValidationTypes.js"
+import { validateId, validateKey, validateSerializationFormatVersion, validateVersion } from "./ValidationFunctions.js"
 
 /**
  * The structure below defines the structure of a LionWeb Chunk by defining all the properties.
@@ -12,13 +7,13 @@ import { MAY_BE_NULL, PropertyDef, PropertyDefinition } from "./generic/Validati
  *   - be fed to the SyntaxValidator to validate an object sat runtime.
  *   - used to generate all the types for a LionWebChunk.
  */
-export const expectedTypes: Map<string, PropertyDefinition[]> = new Map([
+export const expectedTypes: Map<string, TypeDefinition> = new Map<string, TypeDefinition>([
     [
         "LionWebMetaPointer",
         [
-            PropertyDef({ property: "key", expectedType: "string", validate: validateKey }),
-            PropertyDef({ property: "version", expectedType: "string", validate: validateVersion }),
-            PropertyDef({ property: "language", expectedType: "string", validate: validateKey })
+            PropertyDef({ property: "key", expectedType: "LionWebKey" }),
+            PropertyDef({ property: "version", expectedType: "LionWebVersion" }),
+            PropertyDef({ property: "language", expectedType: "LionWebKey" })
         ]
     ],
     [
@@ -26,13 +21,13 @@ export const expectedTypes: Map<string, PropertyDefinition[]> = new Map([
         [
             PropertyDef({ property: "kind", expectedType: "string" }),
             PropertyDef({ property: "message", expectedType: "string" }),
-            PropertyDef({ property: "data", expectedType: "object", mayBeNull: true })
+            PropertyDef({ property: "data", expectedType: "object", mayBeNull: true, isOptional: true })
         ]
     ],
     [
         "LionWebChunk",
         [
-            PropertyDef({ property: "serializationFormatVersion", expectedType: "string", validate: validateSerializationFormatVersion }),
+            PropertyDef({ property: "serializationFormatVersion", expectedType: "LionWebSerializationFormatVersion" }),
             PropertyDef({ property: "languages", expectedType: "LionWebUsedLanguage", isList: true }),
             PropertyDef({ property: "nodes", expectedType: "LionWebNode", isList: true })
         ]
@@ -40,20 +35,20 @@ export const expectedTypes: Map<string, PropertyDefinition[]> = new Map([
     [
         "LionWebUsedLanguage",
         [
-            PropertyDef({ property: "key", expectedType: "string", validate: validateKey }),
-            PropertyDef({ property: "version", expectedType: "string", validate: validateVersion })
+            PropertyDef({ property: "key", expectedType: "LionWebKey" }),
+            PropertyDef({ property: "version", expectedType: "LionWebVersion" })
         ]
     ],
     [
         "LionWebNode",
         [
-            PropertyDef({ property: "id", expectedType: "string", validate: validateId }),
+            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: "string", isList: true, validate: validateId }),
-            PropertyDef({ property: "parent", expectedType: "string", mayBeNull: MAY_BE_NULL, validate: validateId }),
+            PropertyDef({ property: "annotations", expectedType: "LionWebId", isList: true }),
+            PropertyDef({ property: "parent", expectedType: "LionWebId", mayBeNull: MAY_BE_NULL }),
         ]
     ],
     [
@@ -67,7 +62,7 @@ export const expectedTypes: Map<string, PropertyDefinition[]> = new Map([
         "LionWebContainment",
         [
             PropertyDef({ property: "containment", expectedType: "LionWebMetaPointer" }),
-            PropertyDef({ property: "children", expectedType: "string", isList: true, validate: validateId }),
+            PropertyDef({ property: "children", expectedType: "LionWebId", isList: true }),
         ]
     ],
     [
@@ -81,24 +76,37 @@ export const expectedTypes: Map<string, PropertyDefinition[]> = new Map([
         "LionWebReferenceTarget",
         [
             PropertyDef({ property: "resolveInfo", expectedType: "string", mayBeNull: MAY_BE_NULL }),
-            PropertyDef({ property: "reference", expectedType: "string", mayBeNull: MAY_BE_NULL, validate: validateId }),
+            PropertyDef({ property: "reference", expectedType: "LionWebId", mayBeNull: MAY_BE_NULL }),
         ]
     ],
     /**
-     * Elements without properties are assumed to be JSON/JS primitive values, and tested using `typeof`.
+     * Elements without properties are assumed to be JSON/JS primitive values, and tested using `typeof`
+     * and the (optional) validate function.
      */
     [
-        "string",
-        []
+        "LionWebId",
+        PrimitiveDef({ primitiveType: "string", validate: validateId }),
+    ],
+    [
+        "LionWebKey",
+        PrimitiveDef({ primitiveType: "string", validate: validateKey }),
     ],
     [
-        "number",
-        []
+        "LionWebVersion",
+        PrimitiveDef({ primitiveType: "string", validate: validateVersion }),
     ],
     [
-        "boolean",
-        []
+        "LionWebSerializationFormatVersion",
+        PrimitiveDef({ primitiveType: "string", validate: validateSerializationFormatVersion }),
     ],
+    [
+        "string",
+        PrimitiveDef({ primitiveType: "string" }),
+    ],
+    [
+        "object",
+        PrimitiveDef({ primitiveType: "object" }),
+    ]
 ])
 
 

package/src/validators/LionWebLanguageReferenceValidator.ts

@@ -1,37 +1,35 @@
+import { isEqualMetaPointer, LionWebJsonContainment, LionWebJsonNode, LionWebJsonProperty, LionWebJsonReference } from "@lionweb/json"
+import {
+    JsonContext,
+    LION_CORE_BUILTINS_INAMED_NAME,
+    LIONWEB_BOOLEAN_TYPE, LIONWEB_INTEGER_TYPE, LIONWEB_JSON_TYPE, LIONWEB_STRING_TYPE,
+    LionWebJsonChunkWrapper,
+    M3_Keys,
+    MetaPointers,
+    NodeUtils
+} from "@lionweb/json-utils"
 import {
     Language_ContainmentMetaPointerNotInClass_Issue,
-    Language_IncorrectPropertyMetaPointer_Issue, Language_PropertyMetaPointerNotInClass_Issue,
-    Language_PropertyValue_Issue, Language_ReferenceMetaPointerNotInClass_Issue,
+    Language_IncorrectPropertyMetaPointer_Issue,
+    Language_PropertyMetaPointerNotInClass_Issue,
+    Language_PropertyValue_Issue,
+    Language_ReferenceMetaPointerNotInClass_Issue,
     Language_UnknownConcept_Issue
 } from "../issues/index.js"
 import {
     Language_IncorrectContainmentMetaPointer_Issue,
     Language_IncorrectReferenceMetaPointer_Issue,
-    Language_UnknownContainment_Issue, Language_UnknownProperty_Issue,
+    Language_UnknownContainment_Issue,
+    Language_UnknownProperty_Issue,
     Language_UnknownReference_Issue
 } from "../issues/LanguageIssues.js"
-import { isEqualMetaPointer, LionWebJsonNode, MetaPointers, NodeUtils } from "../json/index.js"
-import { JsonContext } from "../json/JsonContext.js"
-import {
-    LionWebJsonContainment,
-    LionWebJsonProperty,
-    LionWebJsonReference,
-} from "../json/LionWebJson.js"
-import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
 // import {
 //     KnownLanguages, LanguageRegistry
 // } from "../languages/LanguageRegistry.js"
-import {
-    LION_CORE_BUILTINS_INAMED_NAME,
-    LIONWEB_BOOLEAN_TYPE,
-    LIONWEB_INTEGER_TYPE,
-    LIONWEB_JSON_TYPE,
-    LIONWEB_STRING_TYPE,
-    M3_Keys
-} from "../json/M3definitions.js"
 import { LanguageRegistry } from "../languages/index.js"
-import { validateBoolean, validateInteger, validateJSON } from "./ValidationFunctions.js"
 import { ValidationResult } from "./generic/ValidationResult.js"
+import { validateBoolean, validateInteger, validateJSON } from "./ValidationFunctions.js"
+
 
 /**
  * Check against the language definition

package/src/validators/LionWebLanguageValidator.ts

@@ -1,9 +1,7 @@
+import { isEqualMetaPointer, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
+import { isLionWebM3Language, JsonContext, LionWebJsonChunkWrapper, MetaPointers } from "@lionweb/json-utils"
 import { GenericIssue } from "../issues/index.js"
 import { MissingM3Language_Issue } from "../issues/LanguageIssues.js"
-import { isEqualMetaPointer, LionWebJsonNode, MetaPointers } from "../json/index.js"
-import { JsonContext } from "../json/JsonContext.js"
-import { isLionWebM3Language, LionWebJsonChunk } from "../json/LionWebJson.js"
-import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
 import { isConcept, LanguageRegistry } from "../languages/index.js"
 import { ValidationResult } from "./generic/ValidationResult.js"
 

package/src/validators/LionWebReferenceValidator.ts

@@ -1,21 +1,13 @@
+import { LionWebId, LionWebJsonChunk, LionWebJsonContainment, LionWebJsonMetaPointer, LionWebJsonNode, LionWebJsonUsedLanguage } from "@lionweb/json"
+import { ChunkUtils, JsonContext, LionWebJsonChunkWrapper } from "@lionweb/json-utils"
 import {
     Duplicates_Issue,
     Reference_ChildMissingInParent_Issue,
     Reference_CirculairParent_Issue,
     Reference_DuplicateNodeId_Issue,
     Reference_LanguageUnknown_Issue,
-    Reference_ParentMissingInChild_Issue,
+    Reference_ParentMissingInChild_Issue
 } from "../issues/ReferenceIssues.js"
-import { JsonContext } from "../json/JsonContext.js"
-import { ChunkUtils } from "../json/ChunkUtils.js"
-import {
-    LionWebJsonContainment,
-    LionWebJsonChunk,
-    LionWebJsonMetaPointer,
-    LionWebJsonNode,
-    LwJsonUsedLanguage,
-} from "../json/LionWebJson.js"
-import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
 import { ValidationResult } from "./generic/ValidationResult.js"
 
 /**
@@ -136,7 +128,7 @@ export class LionWebReferenceValidator {
      * @param usedLanguages
      * @param context
      */
-    checkDuplicateUsedLanguage(usedLanguages: LwJsonUsedLanguage[], context: JsonContext) {
+    checkDuplicateUsedLanguage(usedLanguages: LionWebJsonUsedLanguage[], context: JsonContext) {
         if (usedLanguages === null || usedLanguages === undefined) {
             return
         }
@@ -197,7 +189,7 @@ export class LionWebReferenceValidator {
 
     validateChildrenHaveCorrectParent(node: LionWebJsonNode, context: JsonContext) {
         node.containments.forEach((child: LionWebJsonContainment) => {
-            child.children.forEach((childId: string, index: number) => {
+            child.children.forEach((childId: LionWebId, index: number) => {
                 const childNode = this.nodesIdMap.get(childId)
                 if (childNode !== undefined) {
                     if (childNode.parent !== node.id) {
@@ -211,7 +203,7 @@ export class LionWebReferenceValidator {
                 }
             })
         })
-        node.annotations.forEach((annotationId: string, annotationIndex: number) => {
+        node.annotations.forEach((annotationId: LionWebId, annotationIndex: number) => {
             const childNode = this.nodesIdMap.get(annotationId)
             if (childNode !== undefined) {
                 if (childNode.parent === null || childNode.parent === undefined) {

package/src/validators/LionWebSyntaxValidator.ts

@@ -1,6 +1,6 @@
-import { expectedTypes } from "./LionWebChunkDefinitions.js"
 import { SyntaxValidator } from "./generic/SyntaxValidator.js"
 import { ValidationResult } from "./generic/ValidationResult.js"
+import { expectedTypes } from "./LionWebChunkDefinitions.js"
 
 /**
  * LionWebSyntaxValidator can check whether objects are structurally LionWeb objects.

package/src/validators/LionWebValidator.ts

@@ -1,10 +1,10 @@
-import { LionWebJsonChunk } from "../json/LionWebJson.js"
-import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
+import { LionWebJsonChunk } from "@lionweb/json"
+import { LionWebJsonChunkWrapper } from "@lionweb/json-utils"
 import { LanguageRegistry } from "../languages/index.js"
+import { ValidationResult } from "./generic/ValidationResult.js"
 import { LionWebLanguageReferenceValidator } from "./LionWebLanguageReferenceValidator.js"
 import { LionWebReferenceValidator } from "./LionWebReferenceValidator.js"
 import { LionWebSyntaxValidator } from "./LionWebSyntaxValidator.js"
-import { ValidationResult } from "./generic/ValidationResult.js"
 
 /**
  * Combined validator that calls all available validators.

package/src/validators/ValidationFunctions.ts

@@ -2,6 +2,7 @@
  * A list of functions that are used to validate primitive fields for LionWeb conformance.
  * Used in the LionWebSyntaxValidator.
  */
+import { JsonContext } from "@lionweb/json-utils"
 import { Language_PropertyValue_Issue } from "../issues/LanguageIssues.js"
 import {
     Syntax_IdFormat_Issue,
@@ -10,7 +11,6 @@ import {
     Syntax_SerializationFormatVersion_Issue,
     Syntax_VersionFormat_Issue
 } from "../issues/SyntaxIssues.js"
-import { JsonContext } from "../json/JsonContext.js"
 import { ValidationResult } from "./generic/ValidationResult.js"
 import { PropertyDefinition } from "./generic/ValidationTypes.js"
 

package/src/validators/generic/SyntaxValidator.ts

@@ -1,3 +1,4 @@
+import { JsonContext } from "@lionweb/json-utils"
 import {
     Syntax_ArrayContainsNull_Issue,
     Syntax_PropertyMissingIssue,
@@ -5,21 +6,27 @@ import {
     Syntax_PropertyTypeIssue,
     Syntax_PropertyUnknownIssue
 } from "../../issues/index.js"
-import { JsonContext } from "../../json/JsonContext.js"
 import { ValidationResult } from "./ValidationResult.js"
-import { PropertyDefinition, UnknownObjectType } from "./ValidationTypes.js"
+import {
+    isObjectDefinition,
+    isPrimitiveDefinition,
+    ObjectDefinition,
+    PrimitiveDefinition,
+    TypeDefinition,
+    UnknownObjectType
+} from "./ValidationTypes.js"
 
 /**
  * Syntax Validator can check whether objects are structurally conforming to the
- * definitions given in `expectedTypes`.
+ * definitions given in `typeDefinitions`.
  */
 export class SyntaxValidator {
     validationResult: ValidationResult
-    expectedTypes: Map<string, PropertyDefinition[]>
+    typeDefinitions: Map<string, TypeDefinition>
 
-    constructor(validationResult: ValidationResult, expectedTypes: Map<string, PropertyDefinition[]>) {
+    constructor(validationResult: ValidationResult, expectedTypes: Map<string, TypeDefinition>) {
         this.validationResult = validationResult
-        this.expectedTypes = expectedTypes
+        this.typeDefinitions = expectedTypes
     }
 
     /**
@@ -29,115 +36,119 @@ export class SyntaxValidator {
      * @param expectedType  The expected type of the object.
      */
     validate(obj: unknown, expectedType: string) {
-        if (typeof obj !== "object") {
-            throw new Error(`SyntaxValidator.validate: 'obj' is not an object, expected a '${expectedType}'`)
-        }
         const object = obj as UnknownObjectType
-        const defs = this.expectedTypes.get(expectedType)
-        if (defs === undefined) {
+        const typeDef = this.typeDefinitions.get(expectedType)
+        if (typeDef === undefined) {
             throw new Error(`SyntaxValidator.validate: cannot find definition for ${expectedType}`)
-        } else {
-            this.validateObjectProperties(expectedType, defs, object, new JsonContext(null, ["$"]))
+        } else if (isObjectDefinition(typeDef)){
+            this.validateObjectProperties(expectedType, typeDef, object, new JsonContext(null, ["$"]))
+        } else if( isPrimitiveDefinition(typeDef)) {
+            this.validatePrimitiveValue("$", typeDef, object, new JsonContext(null, ["$"]))
         }
     }
 
     /**
      * Validate whether `object` is structured conform the properties in `propertyDef`
      * @param originalProperty  The property of which `object` it the value
-     * @param propertyDef       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
      */
-    private validateObjectProperties(originalProperty: string, propertyDef: PropertyDefinition[], object: UnknownObjectType, jsonContext: JsonContext) {
-        if (propertyDef.length === 0) {
-            return
-        }
-        if ((typeof object) !== "object") {
-            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, originalProperty, "object", typeof object))
+    validateObjectProperties(originalProperty: string, typeDef: ObjectDefinition, object: UnknownObjectType, jsonContext: JsonContext) {
+        if (typeDef === null || typeDef === undefined) {
             return
         }
-        for (const pdef of propertyDef) {
-            const expectedPropertyDefs = this.expectedTypes.get(pdef.expectedType)
-            const validator = pdef.validate!
-            const propertyValue = object[pdef.property]
-            if (propertyValue === undefined) {
-                this.validationResult.issue(new Syntax_PropertyMissingIssue(jsonContext, pdef.property + `{ ${typeof object}}{${originalProperty}}`))
-                continue
-            }
-            if (!pdef.mayBeNull && propertyValue === null) {
-                this.validationResult.issue(new Syntax_PropertyNullIssue(jsonContext, pdef.property))
-                continue
-            }
-            if (pdef.mayBeNull && propertyValue === null) {
-                // Ok, stop checking, continue with next property def
-                continue
+            if ((typeof object) !== "object") {
+                this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, originalProperty, "object", typeof object))
+                return
             }
-            if (pdef.isList) {
-                // Check whether value is an array
-                if (!Array.isArray(propertyValue)) {
-                    const newContext = jsonContext.concat(pdef.property)
-                    this.validationResult.issue(new Syntax_PropertyTypeIssue(newContext, pdef.property, "array", typeof propertyValue))
-                    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 an array, validate every item in the array
-                (propertyValue as UnknownObjectType[]).forEach( (item, index) => {
-                    const newContext = jsonContext.concat(pdef.property, index)
-                    if (item === null) {
-                        this.validationResult.issue(new Syntax_ArrayContainsNull_Issue(newContext, pdef.property,index ))
-                    } else {
-                        if (expectedPropertyDefs !== undefined) {
-                            if (expectedPropertyDefs.length === 0) {
-                                // propertyValue should be a primitive as it has no property definitions
-                                if (this.validatePrimitiveValue(pdef, item, jsonContext)) {
-                                    validator.apply(null, [item, this.validationResult, newContext, pdef])
+                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
+                }
+                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)
+                                    validator.apply(null, [item, this.validationResult, newContext, propertyDef])
                                 }
                             } else {
-                                // propertyValue should be an object, validate its properties
-                                this.validateObjectProperties(pdef.property, expectedPropertyDefs, item as UnknownObjectType, newContext)
-                                validator.apply(null, [item, this.validationResult, newContext, pdef])
+                                throw new Error(`Expected type '${propertyDef.expectedType} has neither property defs, nor a validator.`)
                             }
-                        } else {
-                            throw new Error(`Expected type '${pdef.expectedType} 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
                     }
-                }) 
-            } else {
-                const newContext = jsonContext.concat(pdef.property)
-                if (Array.isArray(propertyValue)) {
-                    this.validationResult.issue(new Syntax_PropertyTypeIssue(newContext, pdef.property, pdef.expectedType, "array"))
-                    return
-                }
-                // Single valued property, validate it
-                if (expectedPropertyDefs !== undefined) {
-                    if (expectedPropertyDefs.length === 0) {
-                        // propertyValue should be a primitive as it has no property definitions
-                        if (this.validatePrimitiveValue(pdef, propertyValue, jsonContext)) {
-                            validator.apply(null, [propertyValue, this.validationResult, newContext, pdef])
+                    // 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)
+                            validator.apply(null, [propertyValue, this.validationResult, newContext, propertyDef])
+                        } else {
+                            throw new Error("EXPECTING ObjectDefinition or PrimitiveDefinition, but got something else")
                         }
                     } else {
-                        // propertyValue should be an object, validate its properties
-                        this.validateObjectProperties(pdef.property, expectedPropertyDefs, propertyValue as UnknownObjectType, newContext)
-                        validator.apply(null, [propertyValue, this.validationResult, newContext, pdef])
+                        throw new Error(`Expected single type '${propertyDef.expectedType}' for '${propertyDef.property}'  at ${newContext.toString()} has neither property defs, nor a validator.`)
                     }
-                } else {
-                    throw new Error(`Expected single type '${pdef.expectedType}' for '${pdef.property}'  at ${newContext.toString()} has neither property defs, nor a validator.`)
                 }
             }
-        }
-        this.checkStrayProperties(object, propertyDef.map(pdef => pdef.property ), jsonContext)
+            this.checkStrayProperties(object, typeDef, jsonContext)
     }
     
-    validatePrimitiveValue(propDef: PropertyDefinition, 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 (!propDef.mayBeNull && (object === null || object === undefined)) {
+        //     this.validationResult.issue(new Syntax_PropertyNullIssue(jsonContext, propDef.property))
+        //     return false
+        // }
 
-        if (typeof object !== propDef.expectedType) {
-            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, propDef.property, propDef.expectedType,typeof object))
+        if (typeof object !== propDef.primitiveType) {
+            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, propertyName, propDef.primitiveType,typeof object))
             return false
         }
+        propDef.validate!(object, this.validationResult, jsonContext)
         return true
     }
 
@@ -147,17 +158,13 @@ export class SyntaxValidator {
      * @param properties    The names of the expected properties
      * @param context       Location in JSON
      */
-    checkStrayProperties(obj: UnknownObjectType, properties: string[], context: JsonContext) {
+    checkStrayProperties(obj: UnknownObjectType, def: ObjectDefinition, context: JsonContext) {
         const own = Object.getOwnPropertyNames(obj)
+        const defined = def.map(pdef => pdef.property)
         own.forEach((ownProp) => {
-            if (!properties.includes(ownProp)) {
+            if (!defined.includes(ownProp)) {
                 this.validationResult.issue(new Syntax_PropertyUnknownIssue(context, ownProp))
             }
         })
-        properties.forEach((prop) => {
-            if (!own.includes(prop)) {
-                this.validationResult.issue(new Syntax_PropertyMissingIssue(context, prop))
-            }
-        })
     }
 }

package/src/validators/generic/ValidationTypes.ts

@@ -1,11 +1,11 @@
-import { JsonContext } from "../../json/index.js"
+import { JsonContext } from "@lionweb/json-utils"
 import { ValidationResult } from "./ValidationResult.js"
 
 export type UnknownObjectType = { [key: string]: unknown }
 
 /**
  * Definition of a property, used by the SyntaxValidator to validate objects.
- * 
+ *
  * **Note** that some of the properties are defined as optional.
  * They should not be empty ever!! But being optional allows to leave them out in the `PropertyDef` function.
  * The `PropertyDef` function sets default values for all optional fields.
@@ -28,6 +28,10 @@ export type PropertyDefinition = {
      * IS this a list property?
      */
     isList?: boolean,
+    /**
+     * Is this property optional?
+     */
+    isOptional?: boolean,
     /**
      * Additional validation function
      */
@@ -44,7 +48,7 @@ export type ValidatorFunction = <T>(obj: T, result: ValidationResult, ctx: JsonC
  * @param pdef
  */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-function emptyValidation<T>(object: T, result: ValidationResult, ctx: JsonContext,  pdef?: PropertyDefinition): void {}
+function emptyValidation<T>(object: T, result: ValidationResult, ctx: JsonContext, pdef?: PropertyDefinition): void {}
 
 // Make boolean argument more readable.
 export const MAY_BE_NULL = true
@@ -55,13 +59,46 @@ export const MAY_BE_NULL = true
  * @constructor
  */
 export function PropertyDef(propDef: PropertyDefinition): PropertyDefinition {
-    const { property, expectedType, mayBeNull = false, isList = false, validate = emptyValidation } = propDef
+    const { property, expectedType, mayBeNull = false, isList = false, isOptional = false, validate = emptyValidation } = propDef
     return {
         property: property,
         expectedType: expectedType,
         isList: isList,
         mayBeNull: mayBeNull,
+        isOptional: isOptional,
         validate: validate
     }
 }
 
+export type PrimitiveDefinition = {
+    /**
+     * The expected type of the property value
+     */
+    primitiveType: string
+    /**
+     * Additional validation function
+     */
+    validate?: ValidatorFunction
+}
+/**
+ * Easy way to create a PropertyDefinition typed object with default values.
+ * @param propDef
+ * @constructor
+ */
+export function PrimitiveDef(propDef: PrimitiveDefinition): PrimitiveDefinition {
+    const { primitiveType, validate = emptyValidation } = propDef
+    return {
+        primitiveType: primitiveType,
+        validate: validate
+    }
+}
+export type ObjectDefinition = PropertyDefinition[]
+export type TypeDefinition = ObjectDefinition | PrimitiveDefinition
+
+export function isObjectDefinition(def: TypeDefinition): def is ObjectDefinition {
+    return Array.isArray(def)
+}
+
+export function isPrimitiveDefinition(def: TypeDefinition): def is PrimitiveDefinition {
+    return (def as PrimitiveDefinition)?.primitiveType !== undefined
+}

package/src/validators/generic/index.ts

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

package/src/validators/index.ts

@@ -1,5 +1,4 @@
 export * from "./generic/index.js"
-export * from "./generic/ValidationResult.js"
 export * from "./LionWebSyntaxValidator.js"
 export * from "./LionWebReferenceValidator.js"
 export * from "./LionWebLanguageValidator.js"