@lionweb/validation 0.7.0-beta.10 → 0.7.0-beta.12

package/src/validators/generic/SyntaxValidator.ts

@@ -1,216 +0,0 @@
-import { JsonContext } from "@lionweb/json-utils"
-import {
-    Syntax_ArrayContainsNull_Issue,
-    Syntax_PropertyMissingIssue,
-    Syntax_PropertyNullIssue,
-    Syntax_PropertyTypeIssue,
-    Syntax_PropertyUnknownIssue
-} from "../../issues/index.js"
-import { ValidationResult } from "./ValidationResult.js"
-import {
-    isObjectDefinition,
-    isPrimitiveDefinition, ObjectDefinition, PrimitiveDefinition, DefinitionSchema,
-    UnknownObjectType
-} from "./schema/index.js"
-
-/**
- * Syntax Validator checks whether objects are structurally conforming to the
- * definitions given in `schema`.
- */
-export class SyntaxValidator {
-    validationResult: ValidationResult
-    schema: DefinitionSchema
-
-    constructor(validationResult: ValidationResult, schema: DefinitionSchema) {
-        this.validationResult = validationResult
-        this.schema = schema
-    }
-
-    /**
-     * Check whether `obj` is a JSON object that conforms to the definition of `expectedType`.
-     * All errors found will be added to the `validationResult` object.
-     * @param obj           The object to validate.
-     * @param expectedType  The expected type of the object.
-     */
-    validate(obj: unknown, expectedType: string) {
-        const object = obj as UnknownObjectType
-        const typeDef = this.schema.getDefinition(expectedType)
-
-        if (typeDef === undefined) {
-            throw new Error(`SyntaxValidator.validate: cannot find definition for ${expectedType}`)
-        } else if (isObjectDefinition(typeDef)) {
-            this.validateObjectProperties(expectedType, typeDef, object, new JsonContext(null, ["$"]))
-        } else if (isPrimitiveDefinition(typeDef)) {
-            this.validatePrimitiveValue("$", typeDef, object, new JsonContext(null, ["$"]))
-        }
-    }
-
-    /**
-     * Validate whether `object` is structured conform the properties in `propertyDef`
-     * @param originalProperty  The property of which `object` it the value
-     * @param typeDef           The property definitions that are being validated
-     * @param object            The object being validated
-     * @param jsonContext       The location in the JSON
-     * @private
-     */
-    validateObjectProperties(originalProperty: string, typeDef: ObjectDefinition, object: UnknownObjectType, jsonContext: JsonContext) {
-        if (typeDef === null || typeDef === undefined) {
-            return
-        }
-        if (typeof object !== "object") {
-            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, originalProperty, "object", typeof object))
-            return
-        }
-        for (const propertyDef of typeDef.properties) {
-            // const taggedUnion = this.schema.getTaggedUnionDefinition(propertyDef.type)
-            // if (taggedUnion !== undefined) {
-            //     this.validateTaggedUnion(propertyDef, typeDef, object, jsonContext.concat(propertyDef.name))
-            //     continue
-            // }
-            const expectedTypeDef = this.schema.getDefinition(propertyDef.type)
-            const validator = propertyDef.validate!
-            const propertyValue = object[propertyDef.name]
-            if (propertyValue === undefined) {
-                if (!propertyDef.isOptional) {
-                    this.validationResult.issue(new Syntax_PropertyMissingIssue(jsonContext, propertyDef.name))
-                }
-                continue
-            }
-            if (!propertyDef.mayBeNull && propertyValue === null) {
-                this.validationResult.issue(new Syntax_PropertyNullIssue(jsonContext, propertyDef.name))
-                continue
-            }
-            if (propertyDef.mayBeNull && propertyValue === null) {
-                // Ok, stop checking, continue with next property def
-                continue
-            }
-            if (propertyDef.isList) {
-                // Check whether value is an array
-                if (!Array.isArray(propertyValue)) {
-                    const newContext = jsonContext.concat(propertyDef.name)
-                    this.validationResult.issue(new Syntax_PropertyTypeIssue(newContext, propertyDef.name, "array", typeof propertyValue))
-                    return
-                }
-                // If an array, validate every item in the array
-                (propertyValue as UnknownObjectType[]).forEach((item, index) => {
-                    const newContext = jsonContext.concat(propertyDef.name, index)
-                    if (item === null) {
-                        this.validationResult.issue(new Syntax_ArrayContainsNull_Issue(newContext, propertyDef.name, index))
-                    } else {
-                        if (expectedTypeDef !== undefined) {
-                            if (isPrimitiveDefinition(expectedTypeDef)) {
-                                if (this.validatePrimitiveValue(propertyDef.name, expectedTypeDef, item, jsonContext)) {
-                                    validator.apply(null, [item, this.validationResult, newContext, propertyDef])
-                                }
-                            } else {
-                                // propertyValue should be an object, validate its properties
-                                this.validateObjectProperties(propertyDef.name, expectedTypeDef, item as UnknownObjectType, newContext)
-                                validator.apply(null, [item, this.validationResult, newContext, propertyDef])
-                            }
-                        } else {
-                            throw new Error(`Expected type '${propertyDef.type} has neither property defs, nor a validator.`)
-                        }
-                    }
-                })
-            } else {
-                const newContext = jsonContext.concat(propertyDef.name)
-                if (Array.isArray(propertyValue)) {
-                    this.validationResult.issue(new Syntax_PropertyTypeIssue(newContext, propertyDef.name, propertyDef.type, "array"))
-                    return
-                }
-                // Single valued property, validate it
-                if (expectedTypeDef !== undefined) {
-                    if (isPrimitiveDefinition(expectedTypeDef)) {
-                        // propertyValue should be a primitive as it has no property definitions
-                        if (this.validatePrimitiveValue(propertyDef.name, expectedTypeDef, propertyValue, jsonContext)) {
-                            validator.apply(null, [propertyValue, this.validationResult, newContext, propertyDef])
-                        }
-                    } else if (isObjectDefinition(expectedTypeDef)) {
-                        // propertyValue should be an object, validate its properties
-                        this.validateObjectProperties(propertyDef.name, expectedTypeDef, propertyValue as UnknownObjectType, newContext)
-                        validator.apply(null, [propertyValue, this.validationResult, newContext, propertyDef])
-                    } else {
-                        throw new Error("EXPECTING ObjectDefinition or PrimitiveDefinition, but got something else")
-                    }
-                } else {
-                    throw new Error(
-                        `Expected single type '${propertyDef.type}' for '${propertyDef.name}'  at ${newContext.toString()} has neither property defs, nor a validator.`
-                    )
-                }
-            }
-        }
-        this.checkStrayProperties(object, typeDef, jsonContext)
-    }
-
-    validatePrimitiveValue(propertyName: string, propDef: PrimitiveDefinition, object: unknown, jsonContext: JsonContext): boolean {
-        if (typeof object !== propDef.primitiveType) {
-            this.validationResult.issue(new Syntax_PropertyTypeIssue(jsonContext, propertyName, propDef.primitiveType, typeof object))
-            return false
-        }
-        propDef.validate!(object, this.validationResult, jsonContext)
-        return true
-    }
-
-    /**
-     *
-     * @param propertyDef the definition of the property that has the TaggedUnionType as its type
-     * @param typeDef The object definition containing the `propertyDef`
-     * @param object The object of type `typeDef` that should have the property described by `propertyDef`
-     * @param jsonContext
-     */
-    // validateTaggedUnion(
-    //     propertyDef: PropertyDefinition,
-    //     typeDef: ObjectDefinition,
-    //     object: UnknownObjectType,
-    //     jsonContext: JsonContext
-    // ): void {
-    //     // console.log(`validateTaggedUnion ${JSON.stringify(propertyDef)}, typedef ${typeDef.name}  object: ${JSON.stringify(object, null, 3)}`)
-    //     const taggedObject = object[propertyDef.name]
-    //     if (propertyDef.isList) {
-    //         if (!Array.isArray(taggedObject)) {
-    //             this.validationResult.issue(new GenericIssue(jsonContext, `Property value '${propertyDef.name}' expects an array, found '${typeof taggedObject}'`))
-    //         } else {
-    //             taggedObject.forEach((taggedObjectSingle, index) => {
-    //                 this.validateTaggedObject(taggedObjectSingle, jsonContext.concat(index))
-    //             })
-    //         }
-    //     } else {
-    //         if (!(typeof taggedObject === "object")) {
-    //             this.validationResult.issue(new GenericIssue(jsonContext, `Property value '${propertyDef.name}' expects an object, found '${typeof taggedObject}'`))
-    //         } else {
-    //             this.validateTaggedObject(taggedObject as UnknownObjectType, jsonContext)
-    //         }
-    //     }
-    // }
-
-    /**
-     * Validate a single tagged object
-     * @param taggedObject
-     * @param jsonContext
-     */
-    // validateTaggedObject(taggedObject: UnknownObjectType, jsonContext: JsonContext): void {
-    //     const actualTypeName = taggedObject["messageKind"] as string
-    //     const actualType = this.schema.getDefinition(actualTypeName)
-    //     if (actualType === undefined || !isObjectDefinition(actualType)) {
-    //         this.validationResult.issue(new GenericIssue(jsonContext, `Expected object type is ${typeof taggedObject}, should be object`))
-    //     } else {
-    //         this.validateObjectProperties(actualTypeName, actualType, taggedObject, jsonContext)
-    //     }
-    // }
-
-    /**
-     * Check whether there are extra properties that should not be there.
-     * @param obj           Object to be validated
-     * @param properties    The names of the expected properties
-     * @param context       Location in JSON
-     */
-    checkStrayProperties(obj: UnknownObjectType, def: ObjectDefinition, context: JsonContext) {
-        const own = Object.getOwnPropertyNames(obj)
-        const defined = def.properties.map(pdef => pdef.name)
-        own.forEach(ownProp => {
-            if (!defined.includes(ownProp)) {
-                this.validationResult.issue(new Syntax_PropertyUnknownIssue(context, ownProp))
-            }
-        })
-    }
-}

package/src/validators/generic/ValidationResult.ts

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

package/src/validators/generic/index.ts

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

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

@@ -1,52 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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

@@ -1,2 +0,0 @@
-export * from "./ValidationTypes.js"
-export * from "./DefinitionSchema.js"

package/src/validators/index.ts

@@ -1,8 +0,0 @@
-export * from "./generic/index.js"
-export * from "./LionWebSyntaxValidator.js"
-export * from "./LionWebReferenceValidator.js"
-export * from "./LionWebLanguageValidator.js"
-export * from "./LionWebLanguageReferenceValidator.js"
-export * from "./LionWebValidator.js"
-export * from "./ValidationFunctions.js"
-export * from "./LionWebChunkDefinitions.js"

package/tsconfig.json

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