@lionweb/validation 0.5.0 → 0.6.0-beta.2

package/src/runners/FileUtils.ts

@@ -1,87 +1,86 @@
-import fs from "fs";
-import { LionWebJsonChunkWrapper, LionWebLanguageDefinition } from "../json/index.js";
-import { LionWebValidator } from "../validators/LionWebValidator.js";
-import { ValidationResult } from "../validators/ValidationResult.js";
-import { getFilesRecursive, printIssues } from "./Utils.js";
+import fs from "fs"
+import { LionWebJsonChunkWrapper, LionWebLanguageDefinition } from "../json/index.js"
+import { LionWebValidator } from "../validators/LionWebValidator.js"
+import { ValidationResult } from "../validators/ValidationResult.js"
+import { getFilesRecursive, printIssues } from "./Utils.js"
 
 export function validateFile(file: string): void {
-    const result = validateFileResult(file);
-    printIssues(result);
+    const result = validateFileResult(file)
+    printIssues(result)
 }
 
 export function validateFileResult(file: string): ValidationResult {
     if (file !== null) {
-        const jsonString1 = fs.readFileSync(file, "utf-8");
-        const json1 = JSON.parse(jsonString1);
-        const validator = new LionWebValidator(json1, null);
+        const jsonString1 = fs.readFileSync(file, "utf-8")
+        const json1 = JSON.parse(jsonString1)
+        const validator = new LionWebValidator(json1, null)
 
-        validator.validateSyntax();
-        validator.validateReferences();
-        validator.validateForLanguage();
-        return validator.validationResult;
+        validator.validateSyntax()
+        validator.validateReferences()
+        validator.validateForLanguage()
+        return validator.validationResult
     }
-    return new ValidationResult();
+    return new ValidationResult()
 }
 
 export function validateFileResultWithLanguage(file: string, languageFile?: string | null): ValidationResult {
-    let langDef: LionWebLanguageDefinition | null = null;
-    
+    let langDef: LionWebLanguageDefinition | null = null
+
     if (languageFile !== undefined && languageFile !== null) {
-        const jsonString1 = fs.readFileSync(file, "utf-8");
-        const languageJson = JSON.parse(jsonString1);
-        const validator = new LionWebValidator(languageJson, null);
+        const jsonString1 = fs.readFileSync(file, "utf-8")
+        const languageJson = JSON.parse(jsonString1)
+        const validator = new LionWebValidator(languageJson, null)
 
-        validator.validateSyntax();
-        validator.validateReferences();
-        validator.validateForLanguage();
+        validator.validateSyntax()
+        validator.validateReferences()
+        validator.validateForLanguage()
         if (validator.validationResult.hasErrors()) {
-            return validator.validationResult;
+            return validator.validationResult
         }
-        langDef = new LionWebLanguageDefinition(new LionWebJsonChunkWrapper(languageJson));
+        langDef = new LionWebLanguageDefinition(new LionWebJsonChunkWrapper(languageJson))
     }
 
     if (file !== null) {
-        const fileString = fs.readFileSync(file, "utf-8");
-        const fileJson = JSON.parse(fileString);
-        const validator = new LionWebValidator(fileJson, langDef);
-        validator.validateSyntax();
-        validator.validateReferences();
-        validator.validateForLanguage();
-        return validator.validationResult;
+        const fileString = fs.readFileSync(file, "utf-8")
+        const fileJson = JSON.parse(fileString)
+        const validator = new LionWebValidator(fileJson, langDef)
+        validator.validateSyntax()
+        validator.validateReferences()
+        validator.validateForLanguage()
+        return validator.validationResult
     }
-    return new ValidationResult();
+    return new ValidationResult()
 }
 
 export function validateFolder(folder: string): void {
-    let totalErrors = 0;
-    let totalSucceed = 0;
-    let totalFailed = 0;
-
+    let totalErrors = 0
+    let totalSucceed = 0
+    let totalFailed = 0
 
     for (const f of getFilesRecursive(folder, [])) {
-        const jsonString1 = fs.readFileSync(f, "utf-8");
-        const json1 = JSON.parse(jsonString1);
+        const jsonString1 = fs.readFileSync(f, "utf-8")
+        const json1 = JSON.parse(jsonString1)
         const validator = new LionWebValidator(json1, null)
 
         try {
-            validator.validateAll();
+            validator.validateAll()
 
             if (!validator.validationResult.hasErrors()) {
-                totalSucceed += 1;
-                console.log("V PASSED " + f);
+                totalSucceed += 1
+                console.log("V PASSED " + f)
                 printIssues(validator.validationResult, f)
             } else {
                 printIssues(validator.validationResult, f)
-                totalFailed += 1;
-                totalErrors += validator.validationResult.issues.length;
+                totalFailed += 1
+                totalErrors += validator.validationResult.issues.length
             }
         } catch (e: unknown) {
-            console.log("EXCEPTION in file: " + f);
-            console.log("EXCEPTION " + (e as Error)?.stack);
+            console.log("EXCEPTION in file: " + f)
+            console.log("EXCEPTION " + (e as Error)?.stack)
         }
     }
 
-    console.log("Total without errors: " + totalSucceed);
-    console.log("Total with errors: " + totalFailed);
-    console.log("Total number of errors: " + totalErrors);
+    console.log("Total without errors: " + totalSucceed)
+    console.log("Total with errors: " + totalFailed)
+    console.log("Total number of errors: " + totalErrors)
 }

package/src/runners/RunCheckFolder.ts

@@ -1,5 +1,5 @@
-import { validateFolder } from "./FileUtils.js";
+import { validateFolder } from "./FileUtils.js"
 
-const folder = process.argv[2];
+const folder = process.argv[2]
 
-validateFolder(folder);
+validateFolder(folder)

package/src/runners/RunCheckFolderWithLanguage.ts

@@ -1,44 +1,45 @@
-import fs from "fs";
-import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js";
-import { LionWebLanguageDefinition} from "../json/LionWebLanguageDefinition.js";
-import { LionWebValidator } from "../validators/LionWebValidator.js";
-import { getFilesRecursive, printIssues } from "./Utils.js";
+import fs from "fs"
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
+import { LionWebLanguageDefinition } from "../json/LionWebLanguageDefinition.js"
+import { LionWebValidator } from "../validators/LionWebValidator.js"
+import { getFilesRecursive, printIssues } from "./Utils.js"
 
-const folder = process.argv[2];
-const language = process.argv[3];
+const folder = process.argv[2]
+const language = process.argv[3]
 
-let totalSucceed = 0;
-let totalFailed = 0;
+let totalSucceed = 0
+let totalFailed = 0
 
+const languageString = fs.readFileSync(language, "utf-8")
+const languageJson = JSON.parse(languageString)
+const languageValidator = new LionWebValidator(languageJson, null)
 
-const languageString = fs.readFileSync(language, "utf-8");
-const languageJson = JSON.parse(languageString);
-const languageValidator = new LionWebValidator(languageJson, null);
-
-languageValidator.validateSyntax();
-languageValidator.validateReferences();
+languageValidator.validateSyntax()
+languageValidator.validateReferences()
 if (languageValidator.validationResult.hasErrors()) {
-    console.log("===== Language errors, ignoring folder ======");
-    printIssues(languageValidator.validationResult);
-    process.exit(1);
+    console.log("===== Language errors, ignoring folder ======")
+    printIssues(languageValidator.validationResult)
+    process.exit(1)
 }
 
 for (const modelFile of getFilesRecursive(folder, [])) {
-    const jsonString1 = fs.readFileSync(modelFile, "utf-8");
-    const jsonModel = JSON.parse(jsonString1);
-    const modelValidator = new LionWebValidator(jsonModel, new LionWebLanguageDefinition(languageValidator.chunk as LionWebJsonChunkWrapper));
-
-    modelValidator.validateAll();
+    const jsonString1 = fs.readFileSync(modelFile, "utf-8")
+    const jsonModel = JSON.parse(jsonString1)
+    const modelValidator = new LionWebValidator(
+        jsonModel,
+        new LionWebLanguageDefinition(languageValidator.chunk as LionWebJsonChunkWrapper),
+    )
+
+    modelValidator.validateAll()
     if (modelValidator.validationResult.hasErrors()) {
-        totalFailed++;
+        totalFailed++
         // console.log("FAILED: " + modelFile)
-        printIssues(modelValidator.validationResult, modelFile);
+        printIssues(modelValidator.validationResult, modelFile)
     } else {
-        console.log("SUCCEEDED: " + modelFile);
-        totalSucceed++;
+        console.log("SUCCEEDED: " + modelFile)
+        totalSucceed++
     }
 }
 
-console.log("Total without errors: " + totalSucceed);
-console.log("Total with errors: " + totalFailed);
-
+console.log("Total without errors: " + totalSucceed)
+console.log("Total with errors: " + totalFailed)

package/src/runners/RunCheckOneFile.ts

@@ -1,5 +1,5 @@
-import { validateFile } from "./FileUtils.js";
+import { validateFile } from "./FileUtils.js"
 
-const file1 = process.argv[2];
+const file1 = process.argv[2]
 
-validateFile(file1);
+validateFile(file1)

package/src/runners/RunCheckOneFileWithLanguage.ts

@@ -1,28 +1,30 @@
-import fs from "fs";
-import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js";
-import { LionWebLanguageDefinition} from "../json/LionWebLanguageDefinition.js";
-import { LionWebValidator } from "../validators/LionWebValidator.js";
-import { printIssues } from "./Utils.js";
+import fs from "fs"
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
+import { LionWebLanguageDefinition } from "../json/LionWebLanguageDefinition.js"
+import { LionWebValidator } from "../validators/LionWebValidator.js"
+import { printIssues } from "./Utils.js"
 
-
-const modelFile = process.argv[2];
-const language = process.argv[3];
+const modelFile = process.argv[2]
+const language = process.argv[3]
 
 if (modelFile !== null) {
-    const jsonString1 = fs.readFileSync(modelFile, "utf-8");
-    const jsonModel = JSON.parse(jsonString1);
-    const languageString = fs.readFileSync(language, "utf-8");
-    const languageJson = JSON.parse(languageString);
+    const jsonString1 = fs.readFileSync(modelFile, "utf-8")
+    const jsonModel = JSON.parse(jsonString1)
+    const languageString = fs.readFileSync(language, "utf-8")
+    const languageJson = JSON.parse(languageString)
 
-    const languageValidator = new LionWebValidator(languageJson, null);
+    const languageValidator = new LionWebValidator(languageJson, null)
 
-    languageValidator.validateSyntax();
-    languageValidator.validateReferences();
+    languageValidator.validateSyntax()
+    languageValidator.validateReferences()
     console.log("===== Language errors ======")
-    printIssues(languageValidator.validationResult);
+    printIssues(languageValidator.validationResult)
 
-    const modelValidator = new LionWebValidator(jsonModel, new LionWebLanguageDefinition(languageValidator.chunk as LionWebJsonChunkWrapper));
-    modelValidator.validateAll();
+    const modelValidator = new LionWebValidator(
+        jsonModel,
+        new LionWebLanguageDefinition(languageValidator.chunk as LionWebJsonChunkWrapper),
+    )
+    modelValidator.validateAll()
     console.log("===== Model errors ======")
-    printIssues(modelValidator.validationResult);
+    printIssues(modelValidator.validationResult)
 }

package/src/runners/RunLioncoreDiff.ts

@@ -1,23 +1,23 @@
-import fs from "fs";
-import { LwDiff } from "../diff/LionwebDiff.js";
-import { LionWebJsonChunk } from "../json/LionWebJson.js";
+import fs from "fs"
+import { LionWebJsonDiff } from "../diff/index.js"
+import { LionWebJsonChunk } from "../json/LionWebJson.js"
 
-const file1 = process.argv[2];
-const file2 = process.argv[3];
+const file1 = process.argv[2]
+const file2 = process.argv[3]
 
 if (file1 !== null && file1 !== undefined) {
-    const jsonString1 = fs.readFileSync(file1, "utf-8");
-    const json1 = JSON.parse(jsonString1);
-    const jsonString2 = fs.readFileSync(file2, "utf-8");
-    const json2 = JSON.parse(jsonString2);
+    const jsonString1 = fs.readFileSync(file1, "utf-8")
+    const json1 = JSON.parse(jsonString1)
+    const jsonString2 = fs.readFileSync(file2, "utf-8")
+    const json2 = JSON.parse(jsonString2)
 
-    const lwDiff = new LwDiff();
-    lwDiff.diffLwChunk(json1 as LionWebJsonChunk, json2 as LionWebJsonChunk);
-    if (lwDiff.errors.length === 0) {
-        console.log("LwDiff: equal");
+    const lwDiff = new LionWebJsonDiff()
+    lwDiff.diffLwChunk(json1 as LionWebJsonChunk, json2 as LionWebJsonChunk)
+    if (lwDiff.diffResult.changes.length === 0) {
+        console.log("LionWebJsonDiff: equal")
     } else {
-        console.log("LwDiff: " + lwDiff.errors);
+        console.log("LionWebJsonDiff: " + lwDiff.diff)
     }
 } else {
-    console.log("Error in arguments");
+    console.log("Error in arguments")
 }

package/src/runners/Utils.ts

@@ -1,55 +1,55 @@
-import fs from "fs";
-import path from "path";
-import { ValidationResult } from "../validators/ValidationResult.js";
+import fs from "fs"
+import path from "path"
+import { ValidationResult } from "../validators/ValidationResult.js"
 
 export function getFilesRecursive(dirPath: string, arrayOfFiles: string[]) {
-    const files = fs.readdirSync(dirPath);
-    arrayOfFiles = arrayOfFiles || [];
+    const files = fs.readdirSync(dirPath)
+    arrayOfFiles = arrayOfFiles || []
 
     files.forEach(function (file: string) {
         if (fs.statSync(dirPath + "/" + file).isDirectory()) {
-            arrayOfFiles = getFilesRecursive(dirPath + "/" + file, arrayOfFiles);
+            arrayOfFiles = getFilesRecursive(dirPath + "/" + file, arrayOfFiles)
             // arrayOfFiles.push(path.join(dirPath, "/", file));
         } else {
-            arrayOfFiles.push(path.join(dirPath, "/", file));
+            arrayOfFiles.push(path.join(dirPath, "/", file))
         }
-    });
-    return arrayOfFiles;
+    })
+    return arrayOfFiles
 }
 
 export function getFilesDirect(dirPath: string, arrayOfFiles: string[]) {
-    const files = fs.readdirSync(dirPath);
-    arrayOfFiles = arrayOfFiles || [];
+    const files = fs.readdirSync(dirPath)
+    arrayOfFiles = arrayOfFiles || []
 
     files.forEach(function (file: string) {
         if (fs.statSync(dirPath + "/" + file).isFile()) {
-            arrayOfFiles.push(file);
+            arrayOfFiles.push(file)
         }
-    });
-    return arrayOfFiles;
+    })
+    return arrayOfFiles
 }
 
 export function getAllDirectories(dirPath: string, arrayOfDirs: string[]) {
-    const files = fs.readdirSync(dirPath, {withFileTypes: true});
-    arrayOfDirs = arrayOfDirs || [];
+    const files = fs.readdirSync(dirPath, { withFileTypes: true })
+    arrayOfDirs = arrayOfDirs || []
 
     files.forEach(function (file: fs.Dirent) {
         if (file.isDirectory()) {
-            arrayOfDirs = getAllDirectories(dirPath + "/" + file.name, arrayOfDirs);
-            arrayOfDirs.push(path.join(dirPath, "/", file.name));
+            arrayOfDirs = getAllDirectories(dirPath + "/" + file.name, arrayOfDirs)
+            arrayOfDirs.push(path.join(dirPath, "/", file.name))
         } else {
             // ignore files
         }
-    });
-    return arrayOfDirs;
+    })
+    return arrayOfDirs
 }
 
 export function printIssues(result: ValidationResult, file?: string): void {
-    result.issues.forEach(issue => console.log((file == undefined ? "" : `File ${file}: `) + issue.errorMsg()));
+    result.issues.forEach(issue => console.log((file == undefined ? "" : `File ${file}: `) + issue.errorMsg()))
 }
 
 export function issuestoString(vresult: ValidationResult, file?: string): string {
-    let result = "";
-    vresult.issues.forEach(issue => result += (file == undefined ? "" : `File ${file}: `) + issue.errorMsg() + "\n");
-    return result;
+    let result = ""
+    vresult.issues.forEach(issue => (result += (file == undefined ? "" : `File ${file}: `) + issue.errorMsg() + "\n"))
+    return result
 }

package/src/runners/index.ts

@@ -1,2 +1,2 @@
-export * from "./FileUtils.js";
-export * from "./Utils.js";
+export * from "./FileUtils.js"
+export * from "./Utils.js"

package/src/validators/LionWebLanguageReferenceValidator.ts

@@ -1,37 +1,45 @@
 import {
     Language_IncorrectContainmentMetaPointer_Issue,
-    Language_IncorrectPropertyMetaPointer_Issue, Language_IncorrectReferenceMetaPointer_Issue,
+    Language_IncorrectPropertyMetaPointer_Issue,
+    Language_IncorrectReferenceMetaPointer_Issue,
     Language_UnknownConcept_Issue,
     Language_UnknownContainment_Issue,
     Language_UnknownProperty_Issue,
-    Language_UnknownReference_Issue
-} from "../issues/LanguageIssues.js";
-import { JsonContext } from "./../issues/JsonContext.js";
+    Language_UnknownReference_Issue,
+} from "../issues/LanguageIssues.js"
+import { JsonContext } from "../json/JsonContext.js"
 import {
     LION_CORE_BUILTINS_INAMED_NAME,
     LIONWEB_BOOLEAN_TYPE,
     LIONWEB_INTEGER_TYPE,
     LIONWEB_JSON_TYPE,
-    LIONWEB_STRING_TYPE, LionWebJsonChild,
-    LionWebJsonProperty, LionWebJsonReference
-} from "../json/LionWebJson.js";
-import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js";
-import { LIONWEB_M3_CONCEPT_KEY, LIONWEB_M3_PROPERTY_KEY, LIONWEB_M3_PROPERTY_TYPE_KEY, LionWebLanguageDefinition } from "../json/LionWebLanguageDefinition.js";
-import { SimpleFieldValidator } from "./SimpleFieldValidator.js";
-import { ValidationResult } from "./ValidationResult.js";
+    LIONWEB_STRING_TYPE,
+    LionWebJsonContainment,
+    LionWebJsonProperty,
+    LionWebJsonReference,
+} from "../json/LionWebJson.js"
+import { LionWebJsonChunkWrapper } from "../json/LionWebJsonChunkWrapper.js"
+import {
+    LIONWEB_M3_CONCEPT_KEY,
+    LIONWEB_M3_PROPERTY_KEY,
+    LIONWEB_M3_PROPERTY_TYPE_KEY,
+    LionWebLanguageDefinition,
+} from "../json/LionWebLanguageDefinition.js"
+import { SimpleFieldValidator } from "./SimpleFieldValidator.js"
+import { ValidationResult } from "./ValidationResult.js"
 
 /**
  * Check against the language definition
  */
 export class LionWebLanguageReferenceValidator {
-    validationResult: ValidationResult;
-    language: LionWebLanguageDefinition;
-    simpleFieldValidator: SimpleFieldValidator;
+    validationResult: ValidationResult
+    language: LionWebLanguageDefinition
+    simpleFieldValidator: SimpleFieldValidator
 
     constructor(validationResult: ValidationResult, lang: LionWebLanguageDefinition) {
-        this.validationResult = validationResult;
-        this.language = lang;
-        this.simpleFieldValidator = new SimpleFieldValidator(this.validationResult);
+        this.validationResult = validationResult
+        this.language = lang
+        this.simpleFieldValidator = new SimpleFieldValidator(this.validationResult)
     }
 
     // reset() {
@@ -41,94 +49,94 @@ export class LionWebLanguageReferenceValidator {
     // TODO test reference and children implementation
     validate(obj: LionWebJsonChunkWrapper): void {
         if (this.language === undefined || this.language === null) {
-            return;
+            return
         }
         obj.jsonChunk.nodes.forEach((node, nodeIndex) => {
-            const nodeContext = new JsonContext(null, ["node", nodeIndex]);
-            const jsonConcept = this.language.getNodeByMetaPointer(node.classifier);
+            const nodeContext = new JsonContext(null, ["node", nodeIndex])
+            const jsonConcept = this.language.getNodeByMetaPointer(node.classifier)
             if (jsonConcept === null || jsonConcept === undefined) {
-                this.validationResult.issue(new Language_UnknownConcept_Issue(nodeContext, node.classifier));
-                return;
+                this.validationResult.issue(new Language_UnknownConcept_Issue(nodeContext, node.classifier))
+                return
             }
             node.properties.forEach((property, propIndex) => {
-                this.validateProperty(property, nodeContext.concat("properties", propIndex));
-            });
+                this.validateProperty(property, nodeContext.concat("properties", propIndex))
+            })
             node.containments.forEach((containment, childIndex) => {
-                this.validateContainment(containment, nodeContext.concat("containments", childIndex));
-            });
+                this.validateContainment(containment, nodeContext.concat("containments", childIndex))
+            })
             node.references.forEach((reference, refIndex) => {
-                this.validateReference(reference, nodeContext.concat("references", refIndex));
-            });
-        });
+                this.validateReference(reference, nodeContext.concat("references", refIndex))
+            })
+        })
     }
 
-    private validateContainment(child: LionWebJsonChild, context: JsonContext) {
-        const type = this.language.getNodeByMetaPointer(child.containment);
+    private validateContainment(child: LionWebJsonContainment, context: JsonContext) {
+        const type = this.language.getNodeByMetaPointer(child.containment)
         if (type === null || type === undefined) {
-            this.validationResult.issue(new Language_UnknownContainment_Issue(context, child.containment));
-            return;
+            this.validationResult.issue(new Language_UnknownContainment_Issue(context, child.containment))
+            return
         }
         if (type.classifier.key !== LIONWEB_M3_CONCEPT_KEY) {
-            this.validationResult.issue(new Language_IncorrectContainmentMetaPointer_Issue(context, child.containment, type.classifier.key));
+            this.validationResult.issue(new Language_IncorrectContainmentMetaPointer_Issue(context, child.containment, type.classifier.key))
         }
         // TODO check type of children
     }
 
     private validateReference(ref: LionWebJsonReference, context: JsonContext) {
-        const type = this.language.getNodeByMetaPointer(ref.reference);
+        const type = this.language.getNodeByMetaPointer(ref.reference)
         if (type === null || type === undefined) {
-            this.validationResult.issue(new Language_UnknownReference_Issue(context, ref.reference));
-            return;
+            this.validationResult.issue(new Language_UnknownReference_Issue(context, ref.reference))
+            return
         }
         if (type.classifier.key !== LIONWEB_M3_CONCEPT_KEY) {
-            this.validationResult.issue(new Language_IncorrectReferenceMetaPointer_Issue(context, ref.reference, type.classifier.key));
+            this.validationResult.issue(new Language_IncorrectReferenceMetaPointer_Issue(context, ref.reference, type.classifier.key))
         }
         // TODO Check type of reference (if possible)
 
         // TODO Check for duplicate targets?
         // If so, what to check because there can be either or both a `resolveInfo` and a `reference`
     }
-    
+
     /**
      * Checks wwhether the value of `prop1` is correct in relation with its property definition in the referred language.
      * @param prop
      */
     validateProperty(prop: LionWebJsonProperty, context: JsonContext): void {
         if (prop.value === null) {
-            return;
+            return
         }
-        const type = this.language.getNodeByMetaPointer(prop.property);
+        const type = this.language.getNodeByMetaPointer(prop.property)
         if (type === null || type === undefined) {
-            this.validationResult.issue(new Language_UnknownProperty_Issue(context, prop.property));
-            return;
+            this.validationResult.issue(new Language_UnknownProperty_Issue(context, prop.property))
+            return
         }
         if (type.classifier.key !== LIONWEB_M3_PROPERTY_KEY) {
-            this.validationResult.issue(new Language_IncorrectPropertyMetaPointer_Issue(context, prop.property, type.classifier.key));
-            return;
+            this.validationResult.issue(new Language_IncorrectPropertyMetaPointer_Issue(context, prop.property, type.classifier.key))
+            return
         }
         // TODO check for property to exist inside the concept in the language
         //      Need to find inherited and implemented properties as well: complex!
 
-        const refType = type.references.find((ref) => (ref.reference.key === LIONWEB_M3_PROPERTY_TYPE_KEY));
-        const propertyName = type.properties.find(p => p.property.key === LION_CORE_BUILTINS_INAMED_NAME)?.value;
+        const refType = type.references.find(ref => ref.reference.key === LIONWEB_M3_PROPERTY_TYPE_KEY)
+        const propertyName = type.properties.find(p => p.property.key === LION_CORE_BUILTINS_INAMED_NAME)?.value
         // console.log("Fount type should be " + refType.targets[0].reference);
         if (propertyName !== undefined) {
             if (refType !== null && refType !== undefined) {
                 switch (refType.targets[0].reference) {
                     case LIONWEB_BOOLEAN_TYPE:
-                        this.simpleFieldValidator.validateBoolean(prop, propertyName, context);
-                        break;
+                        this.simpleFieldValidator.validateBoolean(prop, propertyName, context)
+                        break
                     case LIONWEB_INTEGER_TYPE:
-                        this.simpleFieldValidator.validateInteger(prop, propertyName, context);
-                        break;
+                        this.simpleFieldValidator.validateInteger(prop, propertyName, context)
+                        break
                     case LIONWEB_STRING_TYPE:
-                        break;
+                        break
                     case LIONWEB_JSON_TYPE:
-                        this.simpleFieldValidator.validateJSON(prop, propertyName, context);
-                        break;
+                        this.simpleFieldValidator.validateJSON(prop, propertyName, context)
+                        break
                 }
             } else {
-                // TODO refType not found, but 
+                // TODO refType not found, but
             }
         }
     }