@lionweb/validation 0.6.13-beta.6 → 0.6.13-beta.7

package/src/validators/LionWebReferenceValidator.ts

@@ -1,13 +1,21 @@
-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"
 
 /**
@@ -128,7 +136,7 @@ export class LionWebReferenceValidator {
      * @param usedLanguages
      * @param context
      */
-    checkDuplicateUsedLanguage(usedLanguages: LionWebJsonUsedLanguage[], context: JsonContext) {
+    checkDuplicateUsedLanguage(usedLanguages: LwJsonUsedLanguage[], context: JsonContext) {
         if (usedLanguages === null || usedLanguages === undefined) {
             return
         }
@@ -189,7 +197,7 @@ export class LionWebReferenceValidator {
 
     validateChildrenHaveCorrectParent(node: LionWebJsonNode, context: JsonContext) {
         node.containments.forEach((child: LionWebJsonContainment) => {
-            child.children.forEach((childId: LionWebId, index: number) => {
+            child.children.forEach((childId: string, index: number) => {
                 const childNode = this.nodesIdMap.get(childId)
                 if (childNode !== undefined) {
                     if (childNode.parent !== node.id) {
@@ -203,7 +211,7 @@ export class LionWebReferenceValidator {
                 }
             })
         })
-        node.annotations.forEach((annotationId: LionWebId, annotationIndex: number) => {
+        node.annotations.forEach((annotationId: string, 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 "@lionweb/json"
-import { LionWebJsonChunkWrapper } from "@lionweb/json-utils"
+import { LionWebJsonChunk } from "../json/LionWebJson.js"
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
 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,7 +2,6 @@
  * 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,
@@ -11,6 +10,7 @@ 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,4 +1,3 @@
-import { JsonContext } from "@lionweb/json-utils"
 import {
     Syntax_ArrayContainsNull_Issue,
     Syntax_PropertyMissingIssue,
@@ -6,27 +5,21 @@ import {
     Syntax_PropertyTypeIssue,
     Syntax_PropertyUnknownIssue
 } from "../../issues/index.js"
+import { JsonContext } from "../../json/JsonContext.js"
 import { ValidationResult } from "./ValidationResult.js"
-import {
-    isObjectDefinition,
-    isPrimitiveDefinition,
-    ObjectDefinition,
-    PrimitiveDefinition,
-    TypeDefinition,
-    UnknownObjectType
-} from "./ValidationTypes.js"
+import { PropertyDefinition, UnknownObjectType } from "./ValidationTypes.js"
 
 /**
  * Syntax Validator can check whether objects are structurally conforming to the
- * definitions given in `typeDefinitions`.
+ * definitions given in `expectedTypes`.
  */
 export class SyntaxValidator {
     validationResult: ValidationResult
-    typeDefinitions: Map<string, TypeDefinition>
+    expectedTypes: Map<string, PropertyDefinition[]>
 
-    constructor(validationResult: ValidationResult, expectedTypes: Map<string, TypeDefinition>) {
+    constructor(validationResult: ValidationResult, expectedTypes: Map<string, PropertyDefinition[]>) {
         this.validationResult = validationResult
-        this.typeDefinitions = expectedTypes
+        this.expectedTypes = expectedTypes
     }
 
     /**
@@ -36,119 +29,115 @@ 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 typeDef = this.typeDefinitions.get(expectedType)
-        if (typeDef === undefined) {
+        const defs = this.expectedTypes.get(expectedType)
+        if (defs === 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, ["$"]))
+        } else {
+            this.validateObjectProperties(expectedType, defs, 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 propertyDef       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) {
+    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))
             return
         }
-            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]
+            if (propertyValue === undefined) {
+                this.validationResult.issue(new Syntax_PropertyMissingIssue(jsonContext, pdef.property + `{ ${typeof object}}{${originalProperty}}`))
+                continue
             }
-            for (const propertyDef of typeDef) {
-                const expectedTypeDef = this.typeDefinitions.get(propertyDef.expectedType)
-                const validator = propertyDef.validate!
-                const propertyValue = object[propertyDef.property]
-                if (propertyValue === undefined) {
-                    if (!propertyDef.isOptional) {
-                        this.validationResult.issue(new Syntax_PropertyMissingIssue(jsonContext, propertyDef.property))
-                    }
-                    continue
-                }
-                if (!propertyDef.mayBeNull && propertyValue === null) {
-                    this.validationResult.issue(new Syntax_PropertyNullIssue(jsonContext, propertyDef.property))
-                    continue
-                }
-                if (propertyDef.mayBeNull && propertyValue === null) {
-                    // Ok, stop checking, continue with next property def
-                    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 (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
                 }
-                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])
+                // 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])
                                 }
                             } else {
-                                throw new Error(`Expected type '${propertyDef.expectedType} has neither property defs, nor a validator.`)
+                                // propertyValue should be an object, validate its properties
+                                this.validateObjectProperties(pdef.property, expectedPropertyDefs, item as UnknownObjectType, newContext)
+                                validator.apply(null, [item, this.validationResult, newContext, pdef])
                             }
+                        } 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
                     }
-                    // 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 {
+                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])
                         }
                     } else {
-                        throw new Error(`Expected single type '${propertyDef.expectedType}' for '${propertyDef.property}'  at ${newContext.toString()} has neither property defs, nor a validator.`)
+                        // 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])
                     }
+                } 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, typeDef, jsonContext)
+        }
+        this.checkStrayProperties(object, propertyDef.map(pdef => pdef.property ), jsonContext)
     }
     
-    validatePrimitiveValue(propertyName: string, propDef: PrimitiveDefinition, object: unknown, jsonContext: JsonContext): boolean {
-        // if (!propDef.mayBeNull && (object === null || object === undefined)) {
-        //     this.validationResult.issue(new Syntax_PropertyNullIssue(jsonContext, propDef.property))
-        //     return false
-        // }
+    validatePrimitiveValue(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.primitiveType) {
-            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, propertyName, propDef.primitiveType,typeof object))
+        if (typeof object !== propDef.expectedType) {
+            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, propDef.property, propDef.expectedType,typeof object))
             return false
         }
-        propDef.validate!(object, this.validationResult, jsonContext)
         return true
     }
 
@@ -158,13 +147,17 @@ export class SyntaxValidator {
      * @param properties    The names of the expected properties
      * @param context       Location in JSON
      */
-    checkStrayProperties(obj: UnknownObjectType, def: ObjectDefinition, context: JsonContext) {
+    checkStrayProperties(obj: UnknownObjectType, properties: string[], context: JsonContext) {
         const own = Object.getOwnPropertyNames(obj)
-        const defined = def.map(pdef => pdef.property)
         own.forEach((ownProp) => {
-            if (!defined.includes(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))
+            }
+        })
     }
 }

package/src/validators/generic/ValidationTypes.ts

@@ -1,11 +1,11 @@
-import { JsonContext } from "@lionweb/json-utils"
+import { JsonContext } from "../../json/index.js"
 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,10 +28,6 @@ export type PropertyDefinition = {
      * IS this a list property?
      */
     isList?: boolean,
-    /**
-     * Is this property optional?
-     */
-    isOptional?: boolean,
     /**
      * Additional validation function
      */
@@ -48,7 +44,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
@@ -59,46 +55,13 @@ export const MAY_BE_NULL = true
  * @constructor
  */
 export function PropertyDef(propDef: PropertyDefinition): PropertyDefinition {
-    const { property, expectedType, mayBeNull = false, isList = false, isOptional = false, validate = emptyValidation } = propDef
+    const { property, expectedType, mayBeNull = false, isList = 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,3 +1,4 @@
 export * from "./ValidationTypes.js"
 export * from "./ValidationResult.js"
+export * from "../ValidationFunctions.js"
 export * from "./SyntaxValidator.js"

package/src/validators/index.ts

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