@lionweb/validation 0.6.13-beta.7 → 0.7.0-alpha.10

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

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.
@@ -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

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

package/src/validators/generic/SyntaxValidator.ts

@@ -1,3 +1,4 @@
+import { JsonContext } from "@lionweb/json-utils"
 import {
     Syntax_ArrayContainsNull_Issue,
     Syntax_PropertyMissingIssue,
@@ -5,139 +6,143 @@ 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, DefinitionSchema,
+    UnknownObjectType
+} from "./schema/index.js"
 
 /**
- * Syntax Validator can check whether objects are structurally conforming to the
- * definitions given in `expectedTypes`.
+ * Syntax Validator checks whether objects are structurally conforming to the
+ * definitions given in `schema`.
  */
 export class SyntaxValidator {
     validationResult: ValidationResult
-    expectedTypes: Map<string, PropertyDefinition[]>
+    schema: DefinitionSchema
 
-    constructor(validationResult: ValidationResult, expectedTypes: Map<string, PropertyDefinition[]>) {
+    constructor(validationResult: ValidationResult, schema: DefinitionSchema) {
         this.validationResult = validationResult
-        this.expectedTypes = 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) {
-        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.schema.getDefinition(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) {
+    validateObjectProperties(originalProperty: string, typeDef: ObjectDefinition, object: UnknownObjectType, jsonContext: JsonContext) {
+        if (typeDef === null || typeDef === undefined) {
             return
         }
-        if ((typeof object) !== "object") {
+        if (typeof object !== "object") {
             this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, originalProperty, "object", typeof object))
             return
         }
-        for (const pdef of propertyDef) {
-            const expectedPropertyDefs = this.expectedTypes.get(pdef.expectedType)
-            const validator = pdef.validate!
-            const propertyValue = object[pdef.property]
+        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) {
-                this.validationResult.issue(new Syntax_PropertyMissingIssue(jsonContext, pdef.property + `{ ${typeof object}}{${originalProperty}}`))
+                if (!propertyDef.isOptional) {
+                    this.validationResult.issue(new Syntax_PropertyMissingIssue(jsonContext, propertyDef.name))
+                }
                 continue
             }
-            if (!pdef.mayBeNull && propertyValue === null) {
-                this.validationResult.issue(new Syntax_PropertyNullIssue(jsonContext, pdef.property))
+            if (!propertyDef.mayBeNull && propertyValue === null) {
+                this.validationResult.issue(new Syntax_PropertyNullIssue(jsonContext, propertyDef.name))
                 continue
             }
-            if (pdef.mayBeNull && propertyValue === null) {
+            if (propertyDef.mayBeNull && propertyValue === null) {
                 // Ok, stop checking, continue with next property def
                 continue
             }
-            if (pdef.isList) {
+            if (propertyDef.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))
+                    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(pdef.property, index)
+                (propertyValue as UnknownObjectType[]).forEach((item, index) => {
+                    const newContext = jsonContext.concat(propertyDef.name, index)
                     if (item === null) {
-                        this.validationResult.issue(new Syntax_ArrayContainsNull_Issue(newContext, pdef.property,index ))
+                        this.validationResult.issue(new Syntax_ArrayContainsNull_Issue(newContext, propertyDef.name, 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 (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(pdef.property, expectedPropertyDefs, item as UnknownObjectType, newContext)
-                                validator.apply(null, [item, this.validationResult, newContext, pdef])
+                                this.validateObjectProperties(propertyDef.name, expectedTypeDef, item as UnknownObjectType, newContext)
+                                validator.apply(null, [item, this.validationResult, newContext, propertyDef])
                             }
                         } else {
-                            throw new Error(`Expected type '${pdef.expectedType} has neither property defs, nor a validator.`)
+                            throw new Error(`Expected type '${propertyDef.type} has neither property defs, nor a validator.`)
                         }
                     }
-                }) 
+                })
             } else {
-                const newContext = jsonContext.concat(pdef.property)
+                const newContext = jsonContext.concat(propertyDef.name)
                 if (Array.isArray(propertyValue)) {
-                    this.validationResult.issue(new Syntax_PropertyTypeIssue(newContext, pdef.property, pdef.expectedType, "array"))
+                    this.validationResult.issue(new Syntax_PropertyTypeIssue(newContext, propertyDef.name, propertyDef.type, "array"))
                     return
                 }
                 // Single valued property, validate it
-                if (expectedPropertyDefs !== undefined) {
-                    if (expectedPropertyDefs.length === 0) {
+                if (expectedTypeDef !== undefined) {
+                    if (isPrimitiveDefinition(expectedTypeDef)) {
                         // 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])
+                        if (this.validatePrimitiveValue(propertyDef.name, expectedTypeDef, propertyValue, jsonContext)) {
+                            validator.apply(null, [propertyValue, this.validationResult, newContext, propertyDef])
                         }
-                    } else {
+                    } else if (isObjectDefinition(expectedTypeDef)) {
                         // 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])
+                        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 '${pdef.expectedType}' for '${pdef.property}'  at ${newContext.toString()} has neither property defs, nor a validator.`)
+                    throw new Error(
+                        `Expected single type '${propertyDef.type}' for '${propertyDef.name}'  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
-        }
 
-        if (typeof object !== propDef.expectedType) {
-            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, propDef.property, propDef.expectedType,typeof object))
+    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
     }
 
@@ -147,17 +152,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)
-        own.forEach((ownProp) => {
-            if (!properties.includes(ownProp)) {
+        const defined = def.properties.map(pdef => pdef.name)
+        own.forEach(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/index.ts

@@ -1,4 +1,3 @@
-export * from "./ValidationTypes.js"
+export * from "./schema/index.js"
 export * from "./ValidationResult.js"
-export * from "../ValidationFunctions.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())
+        })
+    }
+}

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

@@ -0,0 +1,134 @@
+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.
+ * You should **always** use the `PropertyDef` function to create a `PropertyDefinition`.
+ */
+export type PropertyDefinition = {
+    /**
+     * The property name
+     */
+    name: string
+    /**
+     * The expected type of the property value
+     */
+    type: string
+    /**
+     * Whether the property value is allowed to be null
+     */
+    mayBeNull?: boolean
+    /**
+     * IS this a list property?
+     */
+    isList?: boolean,
+    /**
+     * Is this property optional?
+     */
+    isOptional?: boolean,
+    /**
+     * Additional validation function
+     */
+    validate?: ValidatorFunction
+}
+
+export type ValidatorFunction = <T>(obj: T, result: ValidationResult, ctx: JsonContext, pdef?: PropertyDefinition) => void
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function emptyValidation<T>(object: T, result: ValidationResult, ctx: JsonContext, pdef?: PropertyDefinition): void {}
+
+// Make boolean argument more readable.
+export const MAY_BE_NULL = true
+
+/**
+ * Definition of a primitive type.
+ */
+export type PrimitiveDefinition = {
+    name: string,
+    /**
+     * The expected type of the property value
+     */
+    primitiveType: string
+    /**
+     * Additional validation function
+     */
+    validate?: ValidatorFunction
+}
+
+/**
+ * Definition of an object type.
+ */
+export type ObjectDefinition = {
+    name: string,
+    properties: PropertyDefinition[],
+    /**
+     * The name of the tagged union that this type belongs to
+     */
+    taggedUnionType?: string
+}
+
+export type Definition = ObjectDefinition | PrimitiveDefinition
+/**
+ * Defionition of tagged union.
+ */
+export type TaggedUnionDefinition = {
+    /**
+     * The tagged union "super" type
+     */
+    unionType: string,
+    /**
+     * The primitive property type that is the discriminator or tag
+     */
+    unionDiscriminator: string,
+    /**
+     * The name of the property in an object that contains the discriminator value
+     */
+    unionProperty: string
+}
+/**
+ * Easy way to create a PrimitiveDefinition typed object with default values.
+ * @param propDef
+ * @constructor
+ */
+export function PrimitiveDef(propDef: PrimitiveDefinition): PrimitiveDefinition {
+    const { name, primitiveType, validate = emptyValidation } = propDef
+    return {
+        name: name,
+        primitiveType: primitiveType,
+        validate: validate
+    }
+}
+
+/**
+ * Easy way to create a PropertyDefinition typed object with default values.
+ * @param propDef
+ * @constructor
+ */
+export function PropertyDef(propDef: PropertyDefinition): PropertyDefinition {
+    const { name, type, mayBeNull = false, isList = false, isOptional = false, validate = emptyValidation } = propDef
+    return {
+        name: name,
+        type: type,
+        isList: isList,
+        mayBeNull: mayBeNull,
+        isOptional: isOptional,
+        validate: validate
+    }
+}
+
+export function isObjectDefinition(def: Definition | undefined): def is ObjectDefinition {
+    return  (def !== undefined) && Array.isArray((def as ObjectDefinition)?.properties)
+}
+
+export function isPrimitiveDefinition(def: Definition | undefined): def is PrimitiveDefinition {
+    return (def !== undefined) && (def as PrimitiveDefinition)?.primitiveType !== undefined
+}
+
+export function isJavaScriptPrimitive(type: string): boolean {
+    return ["number", "string", "boolean"].includes(type)
+}

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

@@ -0,0 +1,2 @@
+export * from "./ValidationTypes.js"
+export * from "./DefinitionSchema.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"