@lionweb/validation 0.7.0-beta.18 → 0.7.0-beta.19

package/src/validators/LionWebReferenceValidator.ts

@@ -0,0 +1,225 @@
+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
+} from "../issues/ReferenceIssues.js"
+import { ValidationResult } from "./generic/ValidationResult.js"
+
+/**
+ * Assuming that the syntax is correct, check whether all LionWeb references are correct,
+ * as far as they do not need the used language definition.
+ */
+export class LionWebReferenceValidator {
+    validationResult: ValidationResult
+    nodesIdMap: Map<string, LionWebJsonNode> = new Map<string, LionWebJsonNode>()
+
+    constructor(validationResult: ValidationResult) {
+        this.validationResult = validationResult
+    }
+
+    validateNodeIds(obj: LionWebJsonChunk, ctx: JsonContext): void {
+        // put all nodes in a map, validate that there are no two nodes with the same id.
+        obj.nodes.forEach((node, index) => {
+            // this.validationResult.check(this.nodesIdMap.get(node.id) === undefined, `Node number ${index} has duplicate id "${node.id}"`);
+            if (!(this.nodesIdMap.get(node.id) === undefined)) {
+                this.validationResult.issue(new Reference_DuplicateNodeId_Issue(ctx.concat("nodes", index), node.id))
+            }
+            this.nodesIdMap.set(node.id, node)
+        })
+    }
+
+    validate(obj: LionWebJsonChunkWrapper): void {
+        const rootCtx = new JsonContext(null, ["$"])
+        this.checkDuplicateUsedLanguage(obj.jsonChunk.languages, rootCtx)
+        this.validateNodeIds(obj.jsonChunk, rootCtx)
+        obj.jsonChunk.nodes.forEach((node, nodeIndex) => {
+            const context = rootCtx.concat(`node`, nodeIndex)
+            const parentNode = node.parent
+            if (parentNode !== null) {
+                this.validateExistsAsChild(context, this.nodesIdMap.get(parentNode), node)
+            }
+            this.validateLanguageReference(obj, node.classifier, context)
+            this.checkParentCircular(node, context)
+            this.checkDuplicate(node.annotations, rootCtx.concat("node", nodeIndex, "annotations"))
+            this.validateChildrenHaveCorrectParent(node, rootCtx.concat("node", nodeIndex))
+            node.properties.forEach((prop, propertyIndex) => {
+                this.validateLanguageReference(obj, prop.property, rootCtx.concat("node", nodeIndex, "property", propertyIndex))
+            })
+            node.containments.forEach((containment, childIndex) => {
+                this.validateLanguageReference(obj, containment.containment, rootCtx.concat("node", nodeIndex, "containments", childIndex))
+                this.checkDuplicate(containment.children, rootCtx.concat("node", nodeIndex, "containments", childIndex))
+                containment.children.forEach(childId => {
+                    const childNode = this.nodesIdMap.get(childId)
+                    if (childNode !== undefined) {
+                        if (childNode.parent !== null && childNode.parent !== undefined && childNode.parent !== node.id) {
+                            this.validationResult.issue(new Reference_ParentMissingInChild_Issue(context, node, childNode))
+                            // TODO this.validationResult.error(`Child "${childId}" with parent "${childNode.parent}" is defined as child in node "${node.id}"`);
+                        }
+                        if (childNode.parent === null || childNode.parent === undefined) {
+                            // TODO this.validationResult.error(`Child "${childId}" of node "${node.id}" has different parent "${childNode.parent}"`);
+                        }
+                    }
+                })
+            })
+            node.annotations.forEach(annotationId => {
+                const annotation = this.nodesIdMap.get(annotationId)
+                if (annotation !== undefined) {
+                    if (annotation.parent !== null && annotation.parent !== undefined && annotation.parent !== node.id) {
+                        this.validationResult.issue(new Reference_ParentMissingInChild_Issue(context, node, annotation))
+                        // TODO this.validationResult.error(`Child "${annotationId}" with parent "${childNode.parent}" is defined as child in node "${node.id}"`);
+                    }
+                    if (annotation.parent === null || annotation.parent === undefined) {
+                        // TODO this.validationResult.error(`Child "${annotationId}" of node "${node.id}" has different parent "${childNode.parent}"`);
+                    }
+                }
+            })
+            node.references.forEach((ref, refIndex) => {
+                this.validateLanguageReference(obj, ref.reference, rootCtx.concat("node", nodeIndex, "references", refIndex))
+                // TODO Check for duplicate targets?
+                // If so, what to check because there can be either or both a `resolveInfo` and a `reference`
+            })
+        })
+    }
+
+    /**
+     * Check whether the metapointer refers to a language defined in the usedLanguages of chunk.
+     * @param chunk
+     * @param metaPointer
+     * @param context
+     */
+    validateLanguageReference(chunk: LionWebJsonChunkWrapper, metaPointer: LionWebJsonMetaPointer, context: JsonContext) {
+        const lang = ChunkUtils.findLwUsedLanguageWithVersion(chunk.jsonChunk, metaPointer.language, metaPointer.version)
+        if (lang === undefined || lang === null) {
+            this.validationResult.issue(new Reference_LanguageUnknown_Issue(context, metaPointer))
+        } else {
+            if (lang.version !== metaPointer.version) {
+                this.validationResult.issue(new Reference_LanguageUnknown_Issue(context, metaPointer))
+            }
+        }
+    }
+
+    /**
+     * Check whether there are duplicate values in `strings`.
+     * @param strings
+     * @param context
+     */
+    checkDuplicate(strings: string[], context: JsonContext) {
+        if (strings === null || strings === undefined) {
+            return
+        }
+        const alreadySeen: Record<string, boolean> = {}
+        strings.forEach(str => {
+            if (alreadySeen[str]) {
+                this.validationResult.issue(new Duplicates_Issue(context, str))
+            } else {
+                alreadySeen[str] = true
+            }
+        })
+    }
+
+    /**
+     * Checks whether there are duplicate usedLanguages in `usedLanguages`.
+     * usedLanguages are considered equal when bith their `key` and `version` are identical.
+     * @param usedLanguages
+     * @param context
+     */
+    checkDuplicateUsedLanguage(usedLanguages: LionWebJsonUsedLanguage[], context: JsonContext) {
+        if (usedLanguages === null || usedLanguages === undefined) {
+            return
+        }
+        const alreadySeen = new Map<string, string[]>()
+        usedLanguages.forEach((usedLanguage, index) => {
+            const seenKeys = alreadySeen.get(usedLanguage.key)
+            if (seenKeys !== null && seenKeys !== undefined) {
+                if (seenKeys.includes(usedLanguage.version)) {
+                    this.validationResult.issue(new Duplicates_Issue(context.concat("language", index, "version"), usedLanguage.version))
+                }
+            } else {
+                alreadySeen.set(usedLanguage.key, [usedLanguage.version])
+            }
+        })
+    }
+
+    /**
+     * Checks whether the parent of node recursively points to `node` itself.
+     * @param node    The noide being checked
+     * @param context The location in the JSON
+     */
+    checkParentCircular(node: LionWebJsonNode, context: JsonContext) {
+        if (node === null || node === undefined) {
+            return
+        }
+        if (node.parent === null || node.parent === undefined) {
+            return
+        }
+        let current: LionWebJsonNode | undefined = node
+        const seenParents = [node.id]
+        while (current !== null && current !== undefined && current.parent !== null && current.parent !== undefined) {
+            const nextParent = current.parent
+            if (nextParent !== null && nextParent !== undefined && seenParents.includes(nextParent)) {
+                this.validationResult.issue(
+                    new Reference_CirculairParent_Issue(context.concat("???"), this.nodesIdMap.get(nextParent), seenParents),
+                )
+                return
+            }
+            seenParents.push(nextParent)
+            current = this.nodesIdMap.get(nextParent)
+        }
+    }
+
+    validateExistsAsChild(context: JsonContext, parent: LionWebJsonNode | undefined, child: LionWebJsonNode) {
+        if (parent === undefined || parent === null) {
+            return
+        }
+        for (const containment of parent.containments) {
+            if (containment.children.includes(child.id)) {
+                return
+            }
+        }
+        if (parent.annotations.includes(child.id)) {
+            return
+        }
+        this.validationResult.issue(new Reference_ChildMissingInParent_Issue(context, child, parent))
+    }
+
+    validateChildrenHaveCorrectParent(node: LionWebJsonNode, context: JsonContext) {
+        node.containments.forEach((child: LionWebJsonContainment) => {
+            child.children.forEach((childId: LionWebId, index: number) => {
+                const childNode = this.nodesIdMap.get(childId)
+                if (childNode !== undefined) {
+                    if (childNode.parent !== node.id) {
+                        // TODO Check that this is already tested from the child in vaidateExistsAsChild().
+                    }
+                    if (childNode.parent === null || childNode.parent === undefined) {
+                        this.validationResult.issue(
+                            new Reference_ParentMissingInChild_Issue(context.concat("child", "containment", "key", index), node, childNode),
+                        )
+                    }
+                }
+            })
+        })
+        node.annotations.forEach((annotationId: LionWebId, annotationIndex: number) => {
+            const childNode = this.nodesIdMap.get(annotationId)
+            if (childNode !== undefined) {
+                if (childNode.parent === null || childNode.parent === undefined) {
+                    this.validationResult.issue(
+                        new Reference_ParentMissingInChild_Issue(context.concat("annotations", annotationIndex), node, childNode),
+                    )
+                }
+            }
+        })
+        // for (const childId of NodeUtils.allChildren(node)) {
+        //     const childNode = this.nodesIdMap.get(childId);
+        //     if (childNode !== undefined) {
+        //         if (childNode.parent !== node.id) {
+        //             this.validationResult.error(`QQ Parent of child "${childId}" is "${childNode.parent}", but should be "${node.id}" in ${context}`);
+        //         }
+        //     }
+        // }
+    }
+}

package/src/validators/LionWebSyntaxValidator.ts

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

package/src/validators/LionWebValidator.ts

@@ -0,0 +1,71 @@
+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"
+
+/**
+ * Combined validator that calls all available validators.
+ * Will stop when one validator fails.
+ */
+export class LionWebValidator {
+    object: unknown
+
+    chunk: unknown
+    validationResult: ValidationResult
+    syntaxValidator: LionWebSyntaxValidator
+    referenceValidator: LionWebReferenceValidator
+    syntaxCorrect: boolean = false
+    referencesCorrect: boolean = false
+
+    constructor(json: unknown, private registry: LanguageRegistry) {
+        this.object = json
+        this.validationResult = new ValidationResult()
+        this.syntaxValidator = new LionWebSyntaxValidator(this.validationResult)
+        this.referenceValidator = new LionWebReferenceValidator(this.validationResult)
+    }
+
+    validateAll() {
+        this.validateSyntax()
+        this.validateReferences()
+        this.validateForLanguage()
+    }
+
+    validateSyntax() {
+        this.syntaxValidator.validate(this.object, "LionWebJsonChunk")
+        this.syntaxCorrect = !this.validationResult.hasErrors()
+        if (this.syntaxCorrect) {
+            this.chunk = new LionWebJsonChunkWrapper(this.object as LionWebJsonChunk)
+        }
+    }
+
+    validateReferences(): void {
+        if (!this.syntaxCorrect) {
+            // console.log("validateReferences not executed because there are syntax errors.")
+            return
+        }
+        // when syntax is correct we know the chunk is actually a chunk!
+        this.referenceValidator.validate(this.chunk as LionWebJsonChunkWrapper)
+        this.referencesCorrect = !this.validationResult.hasErrors()
+    }
+
+    validateForLanguage(): void {
+        if (!this.syntaxCorrect) {
+            // console.log("validateForLanguage not executed because there are syntax errors.")
+            return
+        }
+        if (!this.referencesCorrect) {
+            // console.log("validateForLanguage not executed because there are reference errors.")
+            return
+        }
+        const languageReferenceValidator = new LionWebLanguageReferenceValidator(this.validationResult, this.registry)
+        // when syntax is correct we know the chunk is actually a chunk!
+        languageReferenceValidator.validate(this.chunk as LionWebJsonChunkWrapper)
+    }
+
+    // setLanguage(json: LionwebLanguageDefinition) {
+    //     this.language = json;
+    // }
+}

package/src/validators/ValidationFunctions.ts

@@ -0,0 +1,129 @@
+/**
+ * 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 { asMinimalJsonString } from "@lionweb/ts-utils"
+import { Language_PropertyValue_Issue } from "../issues/LanguageIssues.js"
+import {
+    Syntax_IdFormat_Issue,
+    Syntax_KeyFormat_Issue,
+    Syntax_PropertyNullIssue,
+    Syntax_SerializationFormatVersion_Issue,
+    Syntax_VersionFormat_Issue
+} from "../issues/SyntaxIssues.js"
+import { ValidationResult } from "./generic/ValidationResult.js"
+import { PropertyDefinition } from "./generic/schema/ValidationTypes.js"
+
+/**
+ * Check whether `id` is a valid LionWeb id.
+ * @param value     The `value` to be checked.
+ * @param result    Any validation issues found will be put into this object.
+ * @param context   The context for the error message in errors.
+ */
+export function validateId<String>(value: String, result: ValidationResult, context: JsonContext): void {
+    const idString: string = "" + value
+    const regexp = /^[a-zA-Z0-9_-][a-zA-Z0-9_-]*$/
+    if (!regexp.test(idString)) {
+        result.issue(new Syntax_IdFormat_Issue(context, idString))
+    }
+}    
+
+/**
+ * Check whether `key` is a valid LionWeb key.
+ * @param value     The `key` to be checked.
+ * @param result    Any validation issues found will be put into this object.
+ * @param context   The context for the error message in errors.
+ */
+export function validateKey<String>(value: String, result: ValidationResult, context: JsonContext): void {
+    const keyString: string = "" + value
+    const regexp = /^[a-zA-Z0-9_-][a-zA-Z0-9_-]*$/
+    if (!regexp.test(keyString)) {
+        result.issue(new Syntax_KeyFormat_Issue(context, keyString))
+    }
+}
+
+/**
+ * Check whether `version` is a valid LionWeb version.
+ * @param value     The version to be checked
+ * @param result    Any validation issues found will be put into this object.
+ * @param context   The location in the overall JSON.
+ */
+export function validateVersion<String>(value: String, result: ValidationResult, context: JsonContext): void {
+    const versionString: string = "" + value
+    if (versionString.length === 0) {
+        result.issue(new Syntax_VersionFormat_Issue(context, versionString))
+    }
+}
+
+/**
+ * Check whether the string `value` represents a LionWeb boolean, its value should be "true" or "false".
+ * @param value     The value to be checked
+ * @param result    Any validation issues found will be put into this object.
+ * @param context   The location in the overall JSON.
+ * @param propDef   The PropertyDefinition for this value
+ */
+export function validateBoolean<String>(value: String, result: ValidationResult, context: JsonContext, propDef?: PropertyDefinition): void {
+    const valueAsPrimitive = "" + value
+    if (valueAsPrimitive !== "true" && valueAsPrimitive !== "false") {
+        result.issue(
+            new Language_PropertyValue_Issue(
+                context,
+                propDef ? propDef.name : "unknown",
+                valueAsPrimitive,
+                "boolean " + asMinimalJsonString(value)
+            )
+        )
+    }
+}
+
+/**
+ * Check whether the string `value` represents a LionWeb integer
+ * @param value     The value to be checked
+ * @param result    Any validation issues found will be put into this object.
+ * @param context   The location in the overall JSON.
+ * @param propDef   The PropertyDefinition for this value
+ */
+export function validateInteger<String>(value: String, result: ValidationResult, context: JsonContext, propDef?: PropertyDefinition): void {
+    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.name : "unknown", valueAsPrimitive, "integer"))
+    }
+}
+
+/**
+ * Check whether the string `value` represents a LionWeb Json.
+ * @param value     The value to be checked
+ * @param result    Any validation issues found will be put into this object.
+ * @param context   The location in the overall JSON.
+ * @param propDef   The PropertyDefinition for this value
+ */
+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!.name!))
+    }
+    try {
+        JSON.parse(valueAsPrimitive)
+    } catch (_) {
+        result.issue(new Language_PropertyValue_Issue(context, propDef ? propDef.name : "unknown", valueAsPrimitive, "JSON"))
+    }
+}
+
+/**
+ * Check whether the string `value` is a correct LionWeb serializationFormatVersion.
+ * @param value
+ * @param result
+ * @param context
+ */
+export function validateSerializationFormatVersion<String>(value: String, result: ValidationResult, context: JsonContext): void {
+    if (typeof value !== "string") {
+        result.issue(new Syntax_SerializationFormatVersion_Issue(context, asMinimalJsonString(value)))
+        return
+    }
+    if (value.length === 0) {
+        result.issue(new Syntax_SerializationFormatVersion_Issue(context, value))
+        return
+    }
+}

package/src/validators/generic/SyntaxValidator.ts

@@ -0,0 +1,164 @@
+import { JsonContext } from "@lionweb/json-utils"
+import {
+    Syntax_ArrayContainsNull_Issue,
+    Syntax_PropertyMissingIssue,
+    Syntax_PropertyNullIssue,
+    Syntax_PropertyTypeIssue,
+    Syntax_PropertyUnknownIssue
+} from "../../issues/index.js"
+import { ValidationResult } from "./ValidationResult.js"
+import {
+    isObjectDefinition,
+    isPrimitiveDefinition, ObjectDefinition, PrimitiveDefinition, DefinitionSchema,
+    UnknownObjectType
+} from "./schema/index.js"
+
+/**
+ * Syntax Validator checks whether objects are structurally conforming to the
+ * definitions given in `schema`.
+ */
+export class SyntaxValidator {
+    validationResult: ValidationResult
+    schema: DefinitionSchema
+
+    constructor(validationResult: ValidationResult, schema: DefinitionSchema) {
+        this.validationResult = validationResult
+        this.schema = schema
+    }
+
+    /**
+     * Check whether `obj` is a JSON object that conforms to the definition of `expectedType`.
+     * 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.schema.getDefinition(expectedType)
+
+        if (typeDef === undefined) {
+            throw new Error(`SyntaxValidator.validate: cannot find definition for ${expectedType}`)
+        } 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 typeDef           The property definitions that are being validated
+     * @param object            The object being validated
+     * @param jsonContext       The location in the JSON
+     * @private
+     */
+    validateObjectProperties(originalProperty: string, typeDef: ObjectDefinition, object: UnknownObjectType, jsonContext: JsonContext) {
+        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.properties) {
+            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))
+                }
+                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 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 {
+                                // 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.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 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("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)
+    }
+
+    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))
+            return false
+        }
+        propDef.validate!(object, this.validationResult, jsonContext)
+        return true
+    }
+
+    /**
+     * Check whether there are extra properties that should not be there.
+     * @param obj           Object to be validated
+     * @param properties    The names of the expected properties
+     * @param context       Location in JSON
+     */
+    checkStrayProperties(obj: UnknownObjectType, def: ObjectDefinition, context: JsonContext) {
+        const own = Object.getOwnPropertyNames(obj)
+        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/ValidationResult.ts

@@ -0,0 +1,17 @@
+import { ValidationIssue } from "../../issues/ValidationIssue.js"
+
+export class ValidationResult {
+    issues: ValidationIssue[] = []
+
+    issue(issue: ValidationIssue) {
+        this.issues.push(issue)
+    }
+
+    reset() {
+        this.issues = []
+    }
+
+    hasErrors(): boolean {
+        return this.issues.length !== 0
+    }
+}

package/src/validators/generic/index.ts

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

package/src/validators/generic/schema/DefinitionSchema.ts

@@ -0,0 +1,52 @@
+import { Definition, PrimitiveDefinition, TaggedUnionDefinition } from "./ValidationTypes.js"
+
+/**
+ * A collection of object and primitive definitions describing JSON objects.
+ * Used to
+ * - validate an incoming JSON object
+ * - generate the corresponding TypeScript type definitions
+ * - generate handlers for the JSOn objects (in @lionweb/server)
+ */
+export class DefinitionSchema {
+    unionDefinition: TaggedUnionDefinition | undefined
+    /**
+     * Mapping from extenden object type name to list of extending Object Definitions
+     */
+    definitionsMap: Map<string, Definition> = new Map<string, Definition>()
+
+    constructor(definitions: Definition[], taggedUnion?: TaggedUnionDefinition) {
+        this.add(definitions)
+        this.unionDefinition = taggedUnion
+    }
+
+    getDefinition(name: string): Definition | undefined {
+        return this.definitionsMap.get(name)
+    }
+
+    add(definitions :Definition[] | Definition) {
+        if (!Array.isArray(definitions)) {
+            definitions = [definitions]
+        }
+        for(const def of definitions) {
+            this.definitionsMap.set(def.name, def)
+        }
+    }
+
+    isTagProperty(propertyName: string): boolean {
+        return this.unionDefinition?.unionProperty === propertyName
+    }
+
+    definitions(): Definition[] {
+        return Array.from(this.definitionsMap.values())
+    }
+
+    isUnionDiscriminator(propDef: PrimitiveDefinition): boolean {
+        return this.unionDefinition?.unionDiscriminator === propDef.name
+    }
+
+    joinDefinitions(...schema: DefinitionSchema[]): void {
+        schema.forEach(sch => {
+            this.add(sch.definitions())
+        })
+    }
+}