@lionweb/validation 0.6.3-beta.4 → 0.6.13-beta.0

package/src/validators/LionWebChunkDefinitions.ts

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

package/src/validators/LionWebLanguageReferenceValidator.ts

@@ -30,19 +30,17 @@ import {
     M3_Keys
 } from "../json/M3definitions.js"
 import { LanguageRegistry } from "../languages/index.js"
-import { SimpleFieldValidator } from "./SimpleFieldValidator.js"
-import { ValidationResult } from "./ValidationResult.js"
+import { validateBoolean, validateInteger, validateJSON } from "./ValidationFunctions.js"
+import { ValidationResult } from "./generic/ValidationResult.js"
 
 /**
  * Check against the language definition
  */
 export class LionWebLanguageReferenceValidator {
     validationResult: ValidationResult
-    simpleFieldValidator: SimpleFieldValidator
 
     constructor(validationResult: ValidationResult, private registry: LanguageRegistry) {
         this.validationResult = validationResult
-        this.simpleFieldValidator = new SimpleFieldValidator(this.validationResult)
     }
 
     // reset() {
@@ -147,16 +145,16 @@ export class LionWebLanguageReferenceValidator {
                 const typeReferenceId = refType.targets[0].reference
                 switch (typeReferenceId) {
                     case LIONWEB_BOOLEAN_TYPE:
-                        this.simpleFieldValidator.validateBoolean(prop, propertyName, context)
+                        validateBoolean(prop.value, this.validationResult, context)
                         break
                     case LIONWEB_INTEGER_TYPE:
-                        this.simpleFieldValidator.validateInteger(prop, propertyName, context)
+                        validateInteger(prop.value, this.validationResult, context)
                         break
                     case LIONWEB_STRING_TYPE:
                         // Each string is correct and having another JSON type is already captured
                         break
                     case LIONWEB_JSON_TYPE:
-                        this.simpleFieldValidator.validateJSON(prop, propertyName, context)
+                        validateJSON(prop.value, this.validationResult, context)
                         break
                     default: {
                         // Check for enumeration

package/src/validators/LionWebLanguageValidator.ts

@@ -5,7 +5,7 @@ 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 "./ValidationResult.js"
+import { ValidationResult } from "./generic/ValidationResult.js"
 
 /**
  * Validates whether a chunk is a valid language definition
@@ -23,7 +23,7 @@ export class LionWebLanguageValidator {
     /**
      * Check whether the metamodel is a Language.
      * Assumption is that _chunk_ is already validated as a correct :LionWebJsonChunk
-     * @param obj
+     * @param chunk
      */
     validateLanguage(chunk: LionWebJsonChunk) {
         this.chunkWrapper = new LionWebJsonChunkWrapper(chunk)

package/src/validators/LionWebReferenceValidator.ts

@@ -16,8 +16,7 @@ import {
     LwJsonUsedLanguage,
 } from "../json/LionWebJson.js"
 import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
-import { SimpleFieldValidator } from "./SimpleFieldValidator.js"
-import { ValidationResult } from "./ValidationResult.js"
+import { ValidationResult } from "./generic/ValidationResult.js"
 
 /**
  * Assuming that the syntax is correct, check whether all LionWeb references are correct,
@@ -26,11 +25,9 @@ import { ValidationResult } from "./ValidationResult.js"
 export class LionWebReferenceValidator {
     validationResult: ValidationResult
     nodesIdMap: Map<string, LionWebJsonNode> = new Map<string, LionWebJsonNode>()
-    simpleFieldValidator: SimpleFieldValidator
 
     constructor(validationResult: ValidationResult) {
         this.validationResult = validationResult
-        this.simpleFieldValidator = new SimpleFieldValidator(this.validationResult)
     }
 
     validateNodeIds(obj: LionWebJsonChunk, ctx: JsonContext): void {
@@ -158,7 +155,8 @@ export class LionWebReferenceValidator {
 
     /**
      * Checks whether the parent of node recursively points to `node` itself.
-     * @param node
+     * @param node    The noide being checked
+     * @param context The location in the JSON
      */
     checkParentCircular(node: LionWebJsonNode, context: JsonContext) {
         if (node === null || node === undefined) {

package/src/validators/LionWebSyntaxValidator.ts

@@ -1,308 +1,14 @@
-import {
-    Syntax_ArrayContainsNull_Issue,
-    Syntax_PropertyMissingIssue,
-    Syntax_PropertyNullIssue,
-    Syntax_PropertyTypeIssue,
-    Syntax_PropertyUnknownIssue,
-} from "../issues/SyntaxIssues.js"
-import { SimpleFieldValidator, ValidatorFunction } from "./SimpleFieldValidator.js"
-import { JsonContext } from "../json/JsonContext.js"
-import { ValidationResult } from "./ValidationResult.js"
-
-export type UnknownObjectType = { [key: string]: unknown }
-
-export type PropertyType = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "array"
-
-export type PropertyDefinition = {
-    /**
-     * The property name
-     */
-    property: string
-    /**
-     * The expected type of the property value
-     */
-    expectedType: PropertyType
-    /**
-     * Whether the property value is allowed to be null
-     */
-    mayBeNull: boolean
-    /**
-     * If the property type is correct, check its value further with this function.
-     * Will, only be called if `this.recursive === true`.
-     * If the property value is an Array, the `checkValue` will be called on each element in the array.
-     * @param obj
-     * @param ctx
-     */
-    validateValue?: ValidatorFunction
-}
-
-// Make boolean argument more readable.
-const MAY_BE_NULL = true
-const NOT_NULL = false
+import { expectedTypes } from "./LionWebChunkDefinitions.js"
+import { SyntaxValidator } from "./generic/SyntaxValidator.js"
+import { ValidationResult } from "./generic/ValidationResult.js"
 
 /**
- * LionWebCheck can check whether objects are structurally LionWeb JSON objects.
- * The check can be on a single object, or recursively on an object and its children.
+ * LionWebSyntaxValidator can check whether objects are structurally LionWeb objects.
  */
-export class LionWebSyntaxValidator {
-    validationResult: ValidationResult
-    simpleFieldValidator: SimpleFieldValidator
-    /**
-     * When true, each function will work recursively on the given object.
-     * When false, will only check the given object.
-     * Metapointers are always checked as part of the  object, disregarding the va;lue of `recursive`.
-     */
-    recursive: boolean = true
+export class LionWebSyntaxValidator extends SyntaxValidator {
 
     constructor(validationResult: ValidationResult) {
-        this.validationResult = validationResult
-        this.simpleFieldValidator = new SimpleFieldValidator(this.validationResult)
-    }
-
-    /**
-     * Check whether `obj` is a JSON object that conforms to the serialization syntax of LionCore.
-     * All errors found will be pushed into the `errors` array, if its length is not 0, the check has failed.
-     * @param obj 
-     */
-    validate(obj: unknown) {
-        this.validateLwChunk(obj, new JsonContext(null, ["$"]))
-    }
-
-    validateLwChunk = (obj: unknown, ctx: JsonContext): void => {
-        const expected: PropertyDefinition[] = [
-            {
-                property: "serializationFormatVersion",
-                expectedType: "string",
-                mayBeNull: NOT_NULL,
-                validateValue: this.simpleFieldValidator.validateSerializationFormatVersion,
-            },
-            { property: "languages", expectedType: "array", mayBeNull: NOT_NULL, validateValue: this.validateLwUsedLanguage },
-            { property: "nodes", expectedType: "array", mayBeNull: NOT_NULL, validateValue: this.validateLwNode },
-        ]
-        this.propertyChecks(obj, expected, ctx)
-    }
-
-    validateLwUsedLanguage = (obj: unknown, ctx: JsonContext): void => {
-        const expected: PropertyDefinition[] = [
-            { property: "key", expectedType: "string", mayBeNull: NOT_NULL, validateValue: this.simpleFieldValidator.validateKey },
-            { property: "version", expectedType: "string", mayBeNull: NOT_NULL, validateValue: this.simpleFieldValidator.validateVersion },
-        ]
-        // if (this.checkType(obj, "object", ctx)) {
-        this.propertyChecks(obj, expected, ctx)
-        // }
-    }
-
-    validateLwNode = (obj: unknown, ctx: JsonContext): void => {
-        const expected: PropertyDefinition[] = [
-            { property: "id", expectedType: "string", mayBeNull: NOT_NULL, validateValue: this.simpleFieldValidator.validateId },
-            { property: "classifier", expectedType: "object", mayBeNull: NOT_NULL, validateValue: this.validateLwMetaPointer },
-            { property: "properties", expectedType: "array", mayBeNull: NOT_NULL, validateValue: this.validateLwProperty },
-            { property: "containments", expectedType: "array", mayBeNull: NOT_NULL, validateValue: this.validateLwChild },
-            { property: "references", expectedType: "array", mayBeNull: NOT_NULL, validateValue: this.validateLwReference },
-            { property: "annotations", expectedType: "array", mayBeNull: NOT_NULL, validateValue: this.validateLwAnnotation },
-            { property: "parent", expectedType: "string", mayBeNull: MAY_BE_NULL, validateValue: this.simpleFieldValidator.validateId },
-        ]
-        this.propertyChecks(obj, expected, ctx)
-    }
-
-    validateLwAnnotation = (obj: unknown, context: JsonContext) => {
-        if (this.checkType(obj, "string", context)) {
-            this.simpleFieldValidator.validateId(obj as string, context)
-        }
-    }
-
-    validateLwProperty = (obj: unknown, ctx: JsonContext): void => {
-        const expected: PropertyDefinition[] = [
-            { property: "property", expectedType: "object", mayBeNull: NOT_NULL, validateValue: this.validateLwMetaPointer },
-            { property: "value", expectedType: "string", mayBeNull: MAY_BE_NULL },
-        ]
-        this.propertyChecks(obj, expected, ctx)
-        // TODO: hack for keys in M2 models
-        // if ((obj as any)["property"].key === "IKeyed-key") {
-        //     // console.log("CHECKING KEY");
-        //     this.simpleFieldValidator.validateKey((obj as any)["value"], ctx);
-        // }
-    }
-
-    validateLwMetaPointer = (obj: unknown, ctx: JsonContext): void => {
-        const expected: PropertyDefinition[] = [
-            { property: "key", expectedType: "string", mayBeNull: NOT_NULL, validateValue: this.simpleFieldValidator.validateKey },
-            {
-                property: "version",
-                expectedType: "string",
-                mayBeNull: MAY_BE_NULL,
-                validateValue: this.simpleFieldValidator.validateVersion,
-            },
-            { property: "language", expectedType: "string", mayBeNull: MAY_BE_NULL, validateValue: this.simpleFieldValidator.validateKey },
-        ]
-        this.propertyChecks(obj, expected, ctx)
-    }
-
-    validateLwChild = (obj: unknown, ctx: JsonContext): void => {
-        const expected: PropertyDefinition[] = [
-            { property: "containment", expectedType: "object", mayBeNull: NOT_NULL, validateValue: this.validateLwMetaPointer },
-            { property: "children", expectedType: "array", mayBeNull: NOT_NULL, validateValue: this.checkChild },
-        ]
-        this.propertyChecks(obj, expected, ctx)
-    }
-
-    private checkChild = (obj: unknown, context: JsonContext) => {
-        if (this.checkType(obj, "string", context)) {
-            this.simpleFieldValidator.validateId(obj as string, context)
-        }
-    }
-
-    /** Checks whether `obj` is not null or defined and has the correct type.
-     */
-    private checkType = (obj: unknown, expectedType: PropertyType, context: JsonContext): boolean => {
-        if (obj === null || obj === undefined) {
-            this.validationResult.issue(new Syntax_PropertyTypeIssue(context, "obj", expectedType, typeof obj))
-            return false
-        } else if (typeof obj !== expectedType) {
-            // TODO Better context: where does obj come from
-            this.validationResult.issue(new Syntax_PropertyTypeIssue(context, "obj", expectedType, typeof obj))
-            return false
-        }
-        return true
-    }
-
-    validateLwReference = (obj: unknown, ctx: JsonContext): void => {
-        const expected: PropertyDefinition[] = [
-            { property: "reference", expectedType: "object", mayBeNull: NOT_NULL, validateValue: this.validateLwMetaPointer },
-            { property: "targets", expectedType: "array", mayBeNull: NOT_NULL, validateValue: this.validateLwReferenceTarget },
-        ]
-        this.propertyChecks(obj, expected, ctx)
-    }
-
-    validateLwReferenceTarget = (obj: unknown, ctx: JsonContext): void => {
-        const expected: PropertyDefinition[] = [
-            { property: "resolveInfo", expectedType: "string", mayBeNull: MAY_BE_NULL },
-            { property: "reference", expectedType: "string", mayBeNull: MAY_BE_NULL, validateValue: this.simpleFieldValidator.validateId },
-        ]
-        this.propertyChecks(obj, expected, ctx)
-    }
-
-    /**
-     * Check whether all property definitions in `propDef` are correct and check that there are
-     * no iother properties in `obj`.
-     * @param obj
-     * @param propDefs
-     * @param context
-     */
-    propertyChecks(obj: unknown, propDefs: PropertyDefinition[], context: JsonContext): void {
-        if (!this.checkType(obj, "object", context)) {
-            return
-        }
-        const object = obj as UnknownObjectType
-        const allProperties: string[] = []
-        propDefs.forEach(propDef => {
-            if (propDef.property === "key") {
-                // console.log("CHECKING KEY of " + JSON.stringify(obj))
-            }
-            if (
-                this.checkPropertyType(object, propDef.property, propDef.expectedType, propDef.mayBeNull, context.concat(propDef.property))
-            ) {
-                const propValue = object[propDef.property]
-                if (this.recursive && propDef.expectedType === "array" && Array.isArray(propValue) && !!propDef.validateValue) {
-                    propValue.forEach((arrayItem: unknown, index: number) => {
-                        if (arrayItem === null) {
-                            this.validationResult.issue(
-                                new Syntax_ArrayContainsNull_Issue(context.concat(propDef.property, index), propDef.property, index),
-                            )
-                        } else {
-                            if (propDef.validateValue !== null && propDef.validateValue !== undefined) {
-                                propDef.validateValue(arrayItem, context.concat(propDef.property, index))
-                            } else {
-                                //  TODO: give an error, whih ine?
-                            }
-                        }
-                    })
-                } else if (propDef.validateValue !== null && propDef.validateValue !== undefined) {
-                    // propValue is niot an array, so it should be aa string
-                    propDef.validateValue(propValue as string, context.concat(propDef.property))
-                }
-            }
-            allProperties.push(propDef.property)
-        })
-        this.checkStrayProperties(object, allProperties, context)
-    }
-
-    /**
-     * Check whether there are extra properties that should not be there.
-     * @param obj
-     * @param properties
-     * @param context
-     */
-    checkStrayProperties(obj: UnknownObjectType, properties: string[], context: JsonContext) {
-        const own = Object.getOwnPropertyNames(obj)
-        own.forEach(ownProp => {
-            if (!properties.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))
-            }
-        })
-    }
-
-    /**
-     * Check whether the value of property `prop` of `obj` has type `expectedType`.
-     * @param obj
-     * @param prop
-     * @param expectedType
-     * @param context
-     */
-    checkPropertyType = (
-        obj: UnknownObjectType,
-        prop: string,
-        expectedType: PropertyType,
-        mayBeNull: boolean,
-        context: JsonContext,
-    ): boolean => {
-        if (prop === "key") {
-            // console.log("    checking type of key " + JSON.stringify(obj));
-        }
-        if (obj[prop] === undefined || obj[prop] === null) {
-            if (!mayBeNull) {
-                this.validationResult.issue(new Syntax_PropertyNullIssue(context, prop))
-                return false
-            } else {
-                return true
-            }
-        } else {
-            const actualType = typeof obj[prop]
-            if (expectedType !== actualType) {
-                if (expectedType === "array" && actualType === "object") {
-                    // typeof returns an object for an array, so we need to check this separately.
-                    if (!Array.isArray(obj[prop])) {
-                        this.validationResult.issue(new Syntax_PropertyTypeIssue(context, prop, "array", typeof obj[prop]))
-                        return false
-                    } else {
-                        return true
-                    }
-                } else {
-                    this.validationResult.issue(new Syntax_PropertyTypeIssue(context, prop, expectedType, actualType))
-                    return false
-                }
-            } else {
-                if (expectedType === "object") {
-                    // typeof returns an object for an array, so we need to check this separately.
-                    if (Array.isArray(obj[prop])) {
-                        this.validationResult.issue(new Syntax_PropertyTypeIssue(context, prop, expectedType, "array"))
-                        return false
-                    }
-                }
-            }
-        }
-        return true
+        super(validationResult, expectedTypes)
     }
 }
 
-export function SyntaxValidator(jsonChunk: unknown): ValidationResult {
-    const validationResult = new ValidationResult()
-    const syntaxValidator = new LionWebSyntaxValidator(validationResult)
-    syntaxValidator.validate(jsonChunk)
-    return validationResult
-}

package/src/validators/LionWebValidator.ts

@@ -4,7 +4,7 @@ import { LanguageRegistry } from "../languages/index.js"
 import { LionWebLanguageReferenceValidator } from "./LionWebLanguageReferenceValidator.js"
 import { LionWebReferenceValidator } from "./LionWebReferenceValidator.js"
 import { LionWebSyntaxValidator } from "./LionWebSyntaxValidator.js"
-import { ValidationResult } from "./ValidationResult.js"
+import { ValidationResult } from "./generic/ValidationResult.js"
 
 /**
  * Combined validator that calls all available validators.
@@ -34,8 +34,7 @@ export class LionWebValidator {
     }
 
     validateSyntax() {
-        this.syntaxValidator.recursive = true
-        this.syntaxValidator.validate(this.object)
+        this.syntaxValidator.validate(this.object, "LionWebChunk")
         this.syntaxCorrect = !this.validationResult.hasErrors()
         if (this.syntaxCorrect) {
             this.chunk = new LionWebJsonChunkWrapper(this.object as LionWebJsonChunk)

package/src/validators/ValidationFunctions.ts

@@ -0,0 +1,135 @@
+/**
+ * A list of functions that are used to validate primitive fields for LionWeb conformance.
+ * Used in the LionWebSyntaxValidator.
+ */
+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 { JsonContext } from "../json/JsonContext.js"
+import { ValidationResult } from "./generic/ValidationResult.js"
+import { PropertyDefinition } from "./generic/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.
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+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.
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+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.
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+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
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+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.property : "unknown",
+                valueAsPrimitive,
+                "boolean " + JSON.stringify(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
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+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.property : "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
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+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!))
+    }
+    try {
+        JSON.parse(valueAsPrimitive)
+    } catch (e) {
+        result.issue(new Language_PropertyValue_Issue(context, propDef ? propDef.property : "unknown", valueAsPrimitive, "JSON"))
+    }
+}
+
+/**
+ * Check whether the string `value` is a correct LionWeb serializationFormatVersion.
+ * @param value
+ * @param result
+ * @param context
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function validateSerializationFormatVersion<String>(value: String, result: ValidationResult, context: JsonContext): void {
+    if (typeof value !== "string") {
+        result.issue(new Syntax_SerializationFormatVersion_Issue(context, JSON.stringify(value)))
+        return
+    }
+    if (value.length === 0) {
+        result.issue(new Syntax_SerializationFormatVersion_Issue(context, value))
+        return
+    }
+}