@lionweb/validation 0.5.0-beta.8

package/src/validators/LionWebLanguageValidator.ts

@@ -0,0 +1,40 @@
+import { IncorrectLionCoreVersion_Issue, NotLionCoreLanguageKey_Issue, NumberOfLanguagesUsed_Issue } from "../issues/LanguageIssues";
+import { JsonContext } from "../issues/ValidationIssue";
+import { LionWebJsonChunk } from "../json/LionWebJson";
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper";
+import { ValidationResult } from "./ValidationResult";
+
+export class LionWebLanguageValidator {
+    validationResult: ValidationResult;
+
+    constructor() {
+        this.validationResult = new ValidationResult();
+    }
+
+    /**
+     * check JSON as in `check`, but also check whether the metamoddel is a Language.
+     * @param obj
+     */
+    checkLanguage(chunk: LionWebJsonChunk) {
+        // TODO Vaalidate syntax first via LionWebSyntaxValidator !!!
+        if (chunk.languages.length !== 1) {
+            // Check whether the LionCore M3 is the only used language, then this is a language model.
+            this.validationResult.issue(new NumberOfLanguagesUsed_Issue(new JsonContext(null, ["languages"]), chunk.languages.length))
+            return
+        }
+        const usedLanguage = chunk.languages[0];
+        if (usedLanguage.key !== "LionCore-M3") {
+            this.validationResult.issue(new NotLionCoreLanguageKey_Issue(new JsonContext(null, ["languages[0]"]), usedLanguage.key))
+        }
+        if (usedLanguage.version !== "1") {
+            this.validationResult.issue(new IncorrectLionCoreVersion_Issue(new JsonContext(null, ["languages[0]"]), usedLanguage.version))
+        }
+        const chunkWrapper = new LionWebJsonChunkWrapper(chunk);
+        const languageNodes = chunkWrapper.findNodesOfConcept("Language");
+        if (languageNodes.length !== 1) {
+            // TODO Better error handling.
+            console.error("Expected exactly one Language node, found " + languageNodes.length + " => " + JSON.stringify(languageNodes));
+
+        }
+    }
+}

package/src/validators/LionWebReferenceValidator.ts

@@ -0,0 +1,213 @@
+import {
+    Duplicates_Issue,
+    Reference_ChildMissingInParent_Issue,
+    Reference_CirculairParent_Issue,
+    Reference_DuplicateNodeId_Issue, Reference_LanguageUnknown_Issue,
+    Reference_ParentMissingInChild_Issue
+} from "../issues/ReferenceIssues";
+import { JsonContext } from "../issues/ValidationIssue";
+import { ChunkUtils } from "../json/ChunkUtils";
+import { LION_CORE_BUILTINS_KEY, LionWebJsonChild, LionWebJsonChunk, LionWebJsonMetaPointer, LionWebJsonNode, LwJsonUsedLanguage } from "../json/LionWebJson";
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper";
+import { SimpleFieldValidator } from "./SimpleFieldValidator";
+import { ValidationResult } from "./ValidationResult";
+
+/**
+ * Assuming that the syntax is correct, check whether all LionWeb references are correct,
+ * as far as they do not need the used language definition.
+ */
+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 {
+        // put all nodes in a map, validate that there are no two nodes with the same id.
+        obj.nodes.forEach((node, index) => {
+            // this.validationResult.check(this.nodesIdMap.get(node.id) === undefined, `Node number ${index} has duplicate id "${node.id}"`);
+            if (! (this.nodesIdMap.get(node.id) === undefined)) {
+                this.validationResult.issue(new Reference_DuplicateNodeId_Issue(ctx.concat("nodes", index), node.id));
+            }
+            this.nodesIdMap.set(node.id, node);
+        });
+    }
+
+    validate(obj: LionWebJsonChunkWrapper): void {
+        const rootCtx =  new JsonContext(null, ["$"]);
+        this.checkDuplicateUsedLanguage(obj.jsonChunk.languages, rootCtx);
+        this.validateNodeIds(obj.jsonChunk, rootCtx);
+        obj.jsonChunk.nodes.forEach((node, nodeIndex) => {
+            const context = rootCtx.concat(`node`, nodeIndex);
+            const parentNode = node.parent;
+            if (parentNode !== null) {
+                this.validateExistsAsChild(context, this.nodesIdMap.get(parentNode), node);
+            }
+            this.validateLanguageReference(obj, node.classifier, context);
+            this.checkParentCircular(node, context);
+            this.checkDuplicate(node.annotations, rootCtx.concat("node", nodeIndex, "annotations"));
+            this.validateChildrenHaveCorrectParent(node, rootCtx.concat("node", nodeIndex));
+            node.properties.forEach((prop, propertyIndex) => {
+                this.validateLanguageReference(obj, prop.property, rootCtx.concat("node", nodeIndex, "property", propertyIndex));
+            });
+            node.containments.forEach((containment, childIndex) => {
+                this.validateLanguageReference(obj, containment.containment, rootCtx.concat("node", nodeIndex, "containments", childIndex));
+                this.checkDuplicate(containment.children, rootCtx.concat("node", nodeIndex, "containments", childIndex));
+                containment.children.forEach((childId) => {
+                    const childNode = this.nodesIdMap.get(childId);
+                    if (childNode !== undefined) {
+                        if (childNode.parent !== null && childNode.parent !== undefined && childNode.parent !== node.id) {
+                            // TODO this.validationResult.error(`Child "${childId}" with parent "${childNode.parent}" is defined as child in node "${node.id}"`);
+                        }
+                        if (childNode.parent === null || childNode.parent === undefined) {
+                            // TODO this.validationResult.error(`Child "${childId}" of node "${node.id}" has different parent "${childNode.parent}"`);
+                        }
+                    }
+                });
+            });
+            node.references.forEach((ref, refIndex) => {
+                this.validateLanguageReference(obj, ref.reference, rootCtx.concat("node", nodeIndex, "references", refIndex));
+                // TODO Check for duplicate targets?
+                // If so, what to check because there can be either or both a `resolveInfo` and a `reference`
+            });
+        });
+    }
+
+    /**
+     * Check whether the metapointer refers to a language defined in the usedLanguages of chunk.
+     * @param chunk
+     * @param metaPointer
+     * @param context
+     */
+    validateLanguageReference(chunk: LionWebJsonChunkWrapper, metaPointer: LionWebJsonMetaPointer, context: JsonContext) {
+        const lang = ChunkUtils.findLwUsedLanguageWithVersion(chunk.jsonChunk, metaPointer.language, metaPointer.version);
+        if (metaPointer.language === LION_CORE_BUILTINS_KEY) {
+            // Ok, builtin
+            return;
+        }
+        if (lang === undefined || lang === null) {
+            this.validationResult.issue(new Reference_LanguageUnknown_Issue(context, metaPointer))
+        } else {
+            if (lang.version !== metaPointer.version) {
+                this.validationResult.issue(new Reference_LanguageUnknown_Issue(context, metaPointer))
+            }
+        }
+    }
+
+    /**
+     * Check whether there are duplicate values in `strings`.
+     * @param strings
+     * @param context
+     */
+    checkDuplicate(strings: string[], context: JsonContext) {
+        if (strings === null || strings === undefined) {
+            return;
+        }
+        const alreadySeen: Record<string, boolean> = {};
+        strings.forEach((str) => {
+            if (alreadySeen[str]) {
+                this.validationResult.issue(new Duplicates_Issue(context, str))
+            } else {
+                alreadySeen[str] = true;
+            }
+        });
+    }
+
+    /**
+     * Checks whether there are duplicate usedLanguages in `usedLanguages`.
+     * usedLanguages are considered equal when bith their `key` and `version` are identical.
+     * @param usedLanguages
+     * @param context
+     */
+    checkDuplicateUsedLanguage(usedLanguages: LwJsonUsedLanguage[], context: JsonContext) {
+        if (usedLanguages === null || usedLanguages === undefined) {
+            return;
+        }
+        const alreadySeen = new Map<string, string[]>();
+        usedLanguages.forEach((usedLanguage, index) => {
+            const seenKeys = alreadySeen.get(usedLanguage.key);
+            if (seenKeys !== null && seenKeys !== undefined) {
+                if (seenKeys.includes(usedLanguage.version)) {
+                    this.validationResult.issue(new Duplicates_Issue(context.concat("language", index, "version"), usedLanguage.version));
+                }
+            } else {
+                alreadySeen.set(usedLanguage.key, [usedLanguage.version]);
+            }
+        });
+    }
+
+    /**
+     * Checks whether the parent of node recursively points to `node` itself.
+     * @param node
+     */
+    checkParentCircular(node: LionWebJsonNode, context: JsonContext) {
+        if (node === null || node === undefined) {
+            return;
+        }
+        if (node.parent === null || node.parent === undefined) {
+            return;
+        }
+        let current: LionWebJsonNode | undefined = node;
+        const seenParents = [node.id];
+        while (current !== null && current !== undefined && current.parent !== null && current.parent !== undefined) {
+            const nextParent = current.parent;
+            if (nextParent !== null && nextParent !== undefined && seenParents.includes(nextParent)) {
+                this.validationResult.issue(new Reference_CirculairParent_Issue(context.concat("???"), this.nodesIdMap.get(nextParent), seenParents));
+                return;
+            }
+            seenParents.push(nextParent);
+            current = this.nodesIdMap.get(nextParent);
+        }
+    }
+
+    validateExistsAsChild(context: JsonContext, parent: LionWebJsonNode | undefined, child: LionWebJsonNode) {
+        if (parent === undefined || parent === null) {
+            return;
+        }
+        for (const containment of parent.containments) {
+            if (containment.children.includes(child.id)) {
+                return;
+            }
+        }
+        if (parent.annotations.includes(child.id)) {
+            return;
+        }
+        this.validationResult.issue(new Reference_ChildMissingInParent_Issue(context, child, parent));
+    }
+
+    validateChildrenHaveCorrectParent(node: LionWebJsonNode, context: JsonContext) {
+        node.containments.forEach((child: LionWebJsonChild) => {
+            child.children.forEach((childId: string, index: number) => {
+                const childNode = this.nodesIdMap.get(childId);
+                if (childNode !== undefined) {
+                    if (childNode.parent !== node.id) {
+                        // TODO Check that this is already tested from the child in vaidateExistsAsChild().
+                    }
+                    if (childNode.parent === null || childNode.parent === undefined) {
+                        this.validationResult.issue(new Reference_ParentMissingInChild_Issue(context.concat("child", "containment", "key", index), node, childNode));
+                    }
+                }
+            });
+        });
+        node.annotations.forEach((annotationId: string, annotationIndex: number) => {
+            const childNode = this.nodesIdMap.get(annotationId);
+            if (childNode !== undefined) {
+                if (childNode.parent === null || childNode.parent === undefined) {
+                    this.validationResult.issue(new Reference_ParentMissingInChild_Issue(context.concat("annotations", annotationIndex), node, childNode));
+                }
+            }
+        });
+        // for (const childId of NodeUtils.allChildren(node)) {
+        //     const childNode = this.nodesIdMap.get(childId);
+        //     if (childNode !== undefined) {
+        //         if (childNode.parent !== node.id) {
+        //             this.validationResult.error(`QQ Parent of child "${childId}" is "${childNode.parent}", but should be "${node.id}" in ${context}`);
+        //         }
+        //     }
+        // }
+    }
+}

package/src/validators/LionWebSyntaxValidator.ts

@@ -0,0 +1,297 @@
+import {
+    Syntax_ArrayContainsNull_Issue,
+    Syntax_PropertyMissingIssue,
+    Syntax_PropertyNullIssue,
+    Syntax_PropertyTypeIssue,
+    Syntax_PropertyUnknownIssue
+} from "../issues/SyntaxIssues";
+import { SimpleFieldValidator, ValidatorFunction } from "./SimpleFieldValidator";
+import { JsonContext } from "../issues/ValidationIssue";
+import { ValidationResult } from "./ValidationResult";
+
+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;
+
+/**
+ * LionWebCheck can chack whether objects are LionWeb JSON objects.
+ * The check can be on a single object, or recursively on an object and its children.
+ */
+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;
+
+    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 }
+        ];
+        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)) {
+            // console.log("UNEXPECTED NULL OBJECT");
+            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;
+    }
+}
+
+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

@@ -0,0 +1,76 @@
+import { LionWebJsonChunk } from "../json/LionWebJson";
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper";
+import { LionWebLanguageDefinition } from "../json/LionWebLanguageDefinition";
+import { LionWebLanguageReferenceValidator } from "./LionWebLanguageReferenceValidator";
+import { LionWebReferenceValidator } from "./LionWebReferenceValidator";
+import { LionWebSyntaxValidator } from "./LionWebSyntaxValidator";
+import { ValidationResult } from "./ValidationResult";
+
+/**
+ * Combined validator that calls all available validators.
+ * Will stop when one validator fails.
+ */
+export class LionWebValidator {
+    object: unknown;
+    language: LionWebLanguageDefinition | null = null;
+
+    chunk: unknown;
+    validationResult: ValidationResult;
+    syntaxValidator: LionWebSyntaxValidator;
+    referenceValidator: LionWebReferenceValidator;
+    syntaxCorrect: boolean = false;
+    referencesCorrect: boolean = false;
+
+    constructor(json: unknown, lang: LionWebLanguageDefinition | null) {
+        this.object = json;
+        this.language =lang;
+        this.validationResult = new ValidationResult();
+        this.syntaxValidator = new LionWebSyntaxValidator(this.validationResult);
+        this.referenceValidator = new LionWebReferenceValidator(this.validationResult);
+    }
+
+    validateAll() {
+        this.validateSyntax();
+        this.validateReferences();
+        this.validateForLanguage();
+    }
+
+    validateSyntax() {
+        this.syntaxValidator.recursive = true;
+        this.syntaxValidator.validate(this.object);
+        this.syntaxCorrect = !this.validationResult.hasErrors();
+        if (this.syntaxCorrect) {
+            this.chunk = new LionWebJsonChunkWrapper(this.object as LionWebJsonChunk);
+        }
+    }
+
+    validateReferences(): void {
+        if (!this.syntaxCorrect) {
+            // console.log("validateReferences not executed because there are syntax errors.")
+            return;
+        }
+        // when syntax is correct we know the chunk is actually a chunk!
+        this.referenceValidator.validate(this.chunk as LionWebJsonChunkWrapper);
+        this.referencesCorrect = !this.validationResult.hasErrors()
+    }
+
+    validateForLanguage(): void {
+        if (!this.syntaxCorrect) {
+            // console.log("validateForLanguage not executed because there are syntax errors.")
+            return;
+        }
+        if (!this.referencesCorrect) {
+            // console.log("validateForLanguage not executed because there are reference errors.")
+            return;
+        }
+        if (this.language !== null) {
+            const languageReferenceValidator = new LionWebLanguageReferenceValidator(this.validationResult, this.language);
+            // when syntax is correct we know the chunk is actually a chunk!
+            languageReferenceValidator.validate(this.chunk as LionWebJsonChunkWrapper);
+        }
+    }
+
+    // setLanguage(json: LionwebLanguageDefinition) {
+    //     this.language = json;
+    // }
+}