@lionweb/validation 0.7.0-beta.2 → 0.7.0-beta.21

package/src/validators/generic/SyntaxValidator.ts

@@ -9,40 +9,38 @@ import {
 import { ValidationResult } from "./ValidationResult.js"
 import {
     isObjectDefinition,
-    isPrimitiveDefinition,
-    ObjectDefinition,
-    PrimitiveDefinition,
-    TypeDefinition,
+    isPrimitiveDefinition, ObjectDefinition, PrimitiveDefinition, DefinitionSchema,
     UnknownObjectType
-} from "./ValidationTypes.js"
+} from "./schema/index.js"
 
 /**
- * Syntax Validator can check whether objects are structurally conforming to the
- * definitions given in `typeDefinitions`.
+ * Syntax Validator checks whether objects are structurally conforming to the
+ * definitions given in `schema`.
  */
 export class SyntaxValidator {
     validationResult: ValidationResult
-    typeDefinitions: Map<string, TypeDefinition>
+    schema: DefinitionSchema
 
-    constructor(validationResult: ValidationResult, expectedTypes: Map<string, TypeDefinition>) {
+    constructor(validationResult: ValidationResult, schema: DefinitionSchema) {
         this.validationResult = validationResult
-        this.typeDefinitions = 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) {
         const object = obj as UnknownObjectType
-        const typeDef = this.typeDefinitions.get(expectedType)
+        const typeDef = this.schema.getDefinition(expectedType)
+
         if (typeDef === undefined) {
             throw new Error(`SyntaxValidator.validate: cannot find definition for ${expectedType}`)
-        } else if (isObjectDefinition(typeDef)){
+        } else if (isObjectDefinition(typeDef)) {
             this.validateObjectProperties(expectedType, typeDef, object, new JsonContext(null, ["$"]))
-        } else if( isPrimitiveDefinition(typeDef)) {
+        } else if (isPrimitiveDefinition(typeDef)) {
             this.validatePrimitiveValue("$", typeDef, object, new JsonContext(null, ["$"]))
         }
     }
@@ -50,7 +48,7 @@ export class SyntaxValidator {
     /**
      * 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 typeDef           The property definitions that are being validated
      * @param object            The object being validated
      * @param jsonContext       The location in the JSON
      * @private
@@ -59,93 +57,89 @@ export class SyntaxValidator {
         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) {
-                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 (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))
                 }
-                if (propertyDef.mayBeNull && propertyValue === null) {
-                    // Ok, stop checking, continue with next property def
-                    continue
+                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 (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)
+                // 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 {
-                                throw new Error(`Expected type '${propertyDef.expectedType} has neither property defs, nor a validator.`)
+                                // 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.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)
+                })
+            } 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 {
-                            throw new Error("EXPECTING ObjectDefinition or PrimitiveDefinition, but got something else")
                         }
+                    } 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(`Expected single type '${propertyDef.expectedType}' for '${propertyDef.property}'  at ${newContext.toString()} has neither property defs, nor a validator.`)
+                        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)
+        }
+        this.checkStrayProperties(object, typeDef, 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(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))
+            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, propertyName, propDef.primitiveType, typeof object))
             return false
         }
         propDef.validate!(object, this.validationResult, jsonContext)
@@ -160,8 +154,8 @@ export class SyntaxValidator {
      */
     checkStrayProperties(obj: UnknownObjectType, def: ObjectDefinition, context: JsonContext) {
         const own = Object.getOwnPropertyNames(obj)
-        const defined = def.map(pdef => pdef.property)
-        own.forEach((ownProp) => {
+        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/index.ts

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

package/src/validators/generic/{ValidationTypes.ts → schema/ValidationTypes.ts}

@@ -1,5 +1,5 @@
 import { JsonContext } from "@lionweb/json-utils"
-import { ValidationResult } from "./ValidationResult.js"
+import { ValidationResult } from "../ValidationResult.js"
 
 export type UnknownObjectType = { [key: string]: unknown }
 
@@ -15,11 +15,11 @@ export type PropertyDefinition = {
     /**
      * The property name
      */
-    property: string
+    name: string
     /**
      * The expected type of the property value
      */
-    expectedType: string
+    type: string
     /**
      * Whether the property value is allowed to be null
      */
@@ -39,38 +39,17 @@ export type PropertyDefinition = {
 }
 
 export type ValidatorFunction = <T>(obj: T, result: ValidationResult, ctx: JsonContext, pdef?: PropertyDefinition) => void
-
-/**
- * Default for the `validation` property, does nothing.
- * @param object
- * @param result
- * @param ctx
- * @param pdef
- */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-function emptyValidation<T>(object: T, result: ValidationResult, ctx: JsonContext, pdef?: PropertyDefinition): void {}
+export function emptyValidation<T>(object: T, result: ValidationResult, ctx: JsonContext, pdef?: PropertyDefinition): void {}
 
 // Make boolean argument more readable.
 export const MAY_BE_NULL = true
 
 /**
- * Easy way to create a PropertyDefinition typed object with default values.
- * @param propDef
- * @constructor
+ * Definition of a primitive type.
  */
-export function PropertyDef(propDef: PropertyDefinition): PropertyDefinition {
-    const { property, expectedType, mayBeNull = false, isList = false, isOptional = false, validate = emptyValidation } = propDef
-    return {
-        property: property,
-        expectedType: expectedType,
-        isList: isList,
-        mayBeNull: mayBeNull,
-        isOptional: isOptional,
-        validate: validate
-    }
-}
-
 export type PrimitiveDefinition = {
+    name: string,
     /**
      * The expected type of the property value
      */
@@ -80,25 +59,76 @@ export type PrimitiveDefinition = {
      */
     validate?: ValidatorFunction
 }
+
 /**
- * Easy way to create a PropertyDefinition typed object with default values.
+ * 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 { primitiveType, validate = emptyValidation } = propDef
+    const { name, primitiveType, validate = emptyValidation } = propDef
     return {
+        name: name,
         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)
+/**
+ * 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 isPrimitiveDefinition(def: TypeDefinition): def is PrimitiveDefinition {
-    return (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/dist/validators/generic/ValidationTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ValidationTypes.d.ts","sourceRoot":"","sources":["../../../src/validators/generic/ValidationTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAExD,MAAM,MAAM,iBAAiB,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAA;AAE1D;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC7B;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;OAEG;IACH,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC/B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,kBAAkB,KAAK,IAAI,CAAA;AAa1H,eAAO,MAAM,WAAW,OAAO,CAAA;AAE/B;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,kBAAkB,CAU3E;AAED,MAAM,MAAM,mBAAmB,GAAG;IAC9B;;OAEG;IACH,aAAa,EAAE,MAAM,CAAA;IACrB;;OAEG;IACH,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC/B,CAAA;AACD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,mBAAmB,CAM9E;AACD,MAAM,MAAM,gBAAgB,GAAG,kBAAkB,EAAE,CAAA;AACnD,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG,mBAAmB,CAAA;AAEnE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,GAAG,IAAI,gBAAgB,CAE/E;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,cAAc,GAAG,GAAG,IAAI,mBAAmB,CAErF"}

package/dist/validators/generic/ValidationTypes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ValidationTypes.js","sourceRoot":"","sources":["../../../src/validators/generic/ValidationTypes.ts"],"names":[],"mappings":"AA0CA;;;;;;GAMG;AACH,6DAA6D;AAC7D,SAAS,eAAe,CAAI,MAAS,EAAE,MAAwB,EAAE,GAAgB,EAAE,IAAyB,IAAS,CAAC;AAEtH,uCAAuC;AACvC,MAAM,CAAC,MAAM,WAAW,GAAG,IAAI,CAAA;AAE/B;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,OAA2B;IACnD,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,SAAS,GAAG,KAAK,EAAE,MAAM,GAAG,KAAK,EAAE,UAAU,GAAG,KAAK,EAAE,QAAQ,GAAG,eAAe,EAAE,GAAG,OAAO,CAAA;IAC7H,OAAO;QACH,QAAQ,EAAE,QAAQ;QAClB,YAAY,EAAE,YAAY;QAC1B,MAAM,EAAE,MAAM;QACd,SAAS,EAAE,SAAS;QACpB,UAAU,EAAE,UAAU;QACtB,QAAQ,EAAE,QAAQ;KACrB,CAAA;AACL,CAAC;AAYD;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,OAA4B;IACrD,MAAM,EAAE,aAAa,EAAE,QAAQ,GAAG,eAAe,EAAE,GAAG,OAAO,CAAA;IAC7D,OAAO;QACH,aAAa,EAAE,aAAa;QAC5B,QAAQ,EAAE,QAAQ;KACrB,CAAA;AACL,CAAC;AAID,MAAM,UAAU,kBAAkB,CAAC,GAAmB;IAClD,OAAO,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;AAC7B,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAC,GAAmB;IACrD,OAAQ,GAA2B,EAAE,aAAa,KAAK,SAAS,CAAA;AACpE,CAAC"}

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist/",
-    "resolveJsonModule": true,                        /* Enable importing .json files */
-  }
-}