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

package/src/issues/ValidationIssue.ts

@@ -2,16 +2,16 @@ import { JsonContext } from "@lionweb/json-utils"
 
 export abstract class ValidationIssue {
     abstract readonly issueType: string
-    context: JsonContext
+    context: JsonContext | null
 
-    constructor(context: JsonContext) {
+    constructor(context: JsonContext | null) {
         this.context = context
     }
 
     protected abstract msg(): string
 
     public errorMsg(): string {
-        return `${this.issueType}: ${this.msg()} at ${this.context.toString()} `
+        return `${this.issueType}: ${this.msg()} at ${this.context?.toString()} `
     }
 }
 
@@ -19,7 +19,7 @@ export class GenericIssue extends ValidationIssue {
     readonly issueType = "GenericIssue"
 
     constructor(
-        context: JsonContext,
+        context: JsonContext | null,
         public text: string
     ) {
         super(context)

package/src/runners/Utils.ts

@@ -48,7 +48,7 @@ export function printIssues(result: ValidationResult, file?: string): void {
 }
 
 export function issuestoString(vresult: ValidationResult, file?: string): string {
-    let result = ""
-    vresult.issues.forEach(issue => (result += (file == undefined ? "" : `File ${file}: `) + issue.errorMsg() + "\n"))
+    let result = "ISSUES: "
+    vresult.issues.forEach(issue => (result += (file === undefined ? "NOFILE" : `File ${file}: `) + issue.errorMsg() + "\n"))
     return result
 }

package/src/validators/LionWebChunkDefinitions.ts

@@ -1,112 +1,102 @@
-import { MAY_BE_NULL, PrimitiveDef, PropertyDef, TypeDefinition } from "./generic/ValidationTypes.js"
+import { DefinitionSchema,  MAY_BE_NULL, PropertyDef, PrimitiveDef } from "./generic/index.js"
 import { validateId, validateKey, validateSerializationFormatVersion, validateVersion } from "./ValidationFunctions.js"
 
 /**
  * The structure below defines the structure of a LionWeb Chunk by defining all the properties.
  * It can
- *   - be fed to the SyntaxValidator to validate an object sat runtime.
- *   - used to generate all the types for a LionWebChunk.
+ *   - be used by the SyntaxValidator to validate an object sat runtime.
+ *   - used to generate all the TypeScript types for a LionWebChunk.
  */
-export const expectedTypes: Map<string, TypeDefinition> = new Map<string, TypeDefinition>([
-    [
-        "LionWebMetaPointer",
-        [
-            PropertyDef({ property: "key", expectedType: "LionWebKey" }),
-            PropertyDef({ property: "version", expectedType: "LionWebVersion" }),
-            PropertyDef({ property: "language", expectedType: "LionWebKey" })
+export const LionWebSchema: DefinitionSchema = new DefinitionSchema([
+    {
+        name: "LionWebJsonMetaPointer",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" }),
+            PropertyDef({ name: "language", type: "LionWebKey" })
         ]
-    ],
-    [
-        "ResponseMessage",
-        [
-            PropertyDef({ property: "kind", expectedType: "string" }),
-            PropertyDef({ property: "message", expectedType: "string" }),
-            PropertyDef({ property: "data", expectedType: "object", mayBeNull: true, isOptional: true })
+    },
+    {
+        name: "LionWebJsonMetaPointer",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" }),
+            PropertyDef({ name: "language", type: "LionWebKey" }),
         ]
-    ],
-    [
-        "LionWebChunk",
-        [
-            PropertyDef({ property: "serializationFormatVersion", expectedType: "LionWebSerializationFormatVersion" }),
-            PropertyDef({ property: "languages", expectedType: "LionWebUsedLanguage", isList: true }),
-            PropertyDef({ property: "nodes", expectedType: "LionWebNode", isList: true })
+    },
+    {
+        name: "ResponseMessage",
+        properties: [
+            PropertyDef({ name: "kind", type: "JSstring" }),
+            PropertyDef({ name: "message", type: "JSstring" }),
+            PropertyDef({ name: "data", type: "JSobject", mayBeNull: true, isOptional: true })
         ]
-    ],
-    [
-        "LionWebUsedLanguage",
-        [
-            PropertyDef({ property: "key", expectedType: "LionWebKey" }),
-            PropertyDef({ property: "version", expectedType: "LionWebVersion" })
+    },
+    {
+        name: "LionWebJsonChunk",
+        properties: [
+            PropertyDef({ name: "serializationFormatVersion", type: "LionWebSerializationFormatVersion" }),
+            PropertyDef({ name: "languages", type: "LionWebJsonUsedLanguage", isList: true }),
+            PropertyDef({ name: "nodes", type: "LionWebJsonNode", isList: true })
         ]
-    ],
-    [
-        "LionWebNode",
-        [
-            PropertyDef({ property: "id", expectedType: "LionWebId" }),
-            PropertyDef({ property: "classifier", expectedType: "LionWebMetaPointer" }),
-            PropertyDef({ property: "properties", expectedType: "LionWebProperty", isList: true }),
-            PropertyDef({ property: "containments", expectedType: "LionWebContainment", isList: true }),
-            PropertyDef({ property: "references", expectedType: "LionWebReference", isList: true }),
-            PropertyDef({ property: "annotations", expectedType: "LionWebId", isList: true }),
-            PropertyDef({ property: "parent", expectedType: "LionWebId", mayBeNull: MAY_BE_NULL }),
+    },
+    {
+        name: "LionWebJsonUsedLanguage",
+        properties: [
+            PropertyDef({ name: "key", type: "LionWebKey" }),
+            PropertyDef({ name: "version", type: "LionWebVersion" })
         ]
-    ],
-    [
-        "LionWebProperty",
-        [
-            PropertyDef({ property: "property", expectedType: "LionWebMetaPointer" }),
-            PropertyDef({ property: "value", expectedType: "string", mayBeNull: MAY_BE_NULL }),
+    },
+    {
+        name: "LionWebJsonNode",
+        properties: [
+            PropertyDef({ name: "id", type: "LionWebId" }),
+            PropertyDef({ name: "classifier", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "properties", type: "LionWebJsonProperty", isList: true }),
+            PropertyDef({ name: "containments", type: "LionWebJsonContainment", isList: true }),
+            PropertyDef({ name: "references", type: "LionWebJsonReference", isList: true }),
+            PropertyDef({ name: "annotations", type: "LionWebId", isList: true }),
+            PropertyDef({ name: "parent", type: "LionWebId", mayBeNull: MAY_BE_NULL }),
         ]
-    ],
-    [
-        "LionWebContainment",
-        [
-            PropertyDef({ property: "containment", expectedType: "LionWebMetaPointer" }),
-            PropertyDef({ property: "children", expectedType: "LionWebId", isList: true }),
+    },
+    {
+        name: "LionWebJsonProperty",
+        properties: [
+            PropertyDef({ name: "property", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "value", type: "JSstring", mayBeNull: MAY_BE_NULL }),
         ]
-    ],
-    [
-        "LionWebReference",
-        [
-            PropertyDef({ property: "reference", expectedType: "LionWebMetaPointer"}),
-            PropertyDef({ property: "targets", expectedType: "LionWebReferenceTarget", isList: true}),
+    },
+    {
+        name: "LionWebJsonContainment",
+        properties: [
+            PropertyDef({ name: "containment", type: "LionWebJsonMetaPointer" }),
+            PropertyDef({ name: "children", type: "LionWebId", isList: true }),
         ]
-    ],
-    [
-        "LionWebReferenceTarget",
-        [
-            PropertyDef({ property: "resolveInfo", expectedType: "string", mayBeNull: MAY_BE_NULL }),
-            PropertyDef({ property: "reference", expectedType: "LionWebId", mayBeNull: MAY_BE_NULL }),
+    },
+    {
+        name: "LionWebJsonReference",
+        properties: [
+            PropertyDef({ name: "reference", type: "LionWebJsonMetaPointer"}),
+            PropertyDef({ name: "targets", type: "LionWebJsonReferenceTarget", isList: true}),
         ]
-    ],
+    },
+    {
+        name: "LionWebJsonReferenceTarget",
+        properties: [
+            PropertyDef({ name: "resolveInfo", type: "JSstring", mayBeNull: MAY_BE_NULL }),
+            PropertyDef({ name: "reference", type: "LionWebId", mayBeNull: MAY_BE_NULL }),
+        ]
+    },
     /**
      * Elements without properties are assumed to be JSON/JS primitive values, and tested using `typeof`
      * and the (optional) validate function.
      */
-    [
-        "LionWebId",
-        PrimitiveDef({ primitiveType: "string", validate: validateId }),
-    ],
-    [
-        "LionWebKey",
-        PrimitiveDef({ primitiveType: "string", validate: validateKey }),
-    ],
-    [
-        "LionWebVersion",
-        PrimitiveDef({ primitiveType: "string", validate: validateVersion }),
-    ],
-    [
-        "LionWebSerializationFormatVersion",
-        PrimitiveDef({ primitiveType: "string", validate: validateSerializationFormatVersion }),
-    ],
-    [
-        "string",
-        PrimitiveDef({ primitiveType: "string" }),
-    ],
-    [
-        "object",
-        PrimitiveDef({ primitiveType: "object" }),
-    ]
+    PrimitiveDef({ name: "LionWebId", primitiveType: "string", validate: validateId }),
+    PrimitiveDef({ name: "LionWebKey", primitiveType: "string", validate: validateKey }),
+    PrimitiveDef({ name: "LionWebVersion",primitiveType: "string", validate: validateVersion }),
+    PrimitiveDef({ name: "LionWebSerializationFormatVersion",primitiveType: "string", validate: validateSerializationFormatVersion }),
+    PrimitiveDef({ name: "JSstring", primitiveType: "string" }),
+    PrimitiveDef({ name: "JSobject",primitiveType: "object" }),
 ])
 
 

package/src/validators/LionWebLanguageReferenceValidator.ts

@@ -66,7 +66,7 @@ export class LionWebLanguageReferenceValidator {
         })
     }
 
-    private validateContainment(node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, containment: LionWebJsonContainment, context: JsonContext) {
+    private validateContainment(_node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, containment: LionWebJsonContainment, context: JsonContext) {
         const metaConcept = this.registry.getNodeByMetaPointer(containment.containment)
         if (metaConcept === null || metaConcept === undefined) {
             this.validationResult.issue(new Language_UnknownContainment_Issue(context, containment.containment))
@@ -85,7 +85,7 @@ export class LionWebLanguageReferenceValidator {
         // TODO check type of children
     }
 
-    private validateReference(node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, ref: LionWebJsonReference, context: JsonContext) {
+    private validateReference(_node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, ref: LionWebJsonReference, context: JsonContext) {
         const referenceDefinition = this.registry.getNodeByMetaPointer(ref.reference)
         if (referenceDefinition === null || referenceDefinition === undefined) {
             this.validationResult.issue(new Language_UnknownReference_Issue(context, ref.reference))
@@ -113,7 +113,7 @@ export class LionWebLanguageReferenceValidator {
      * Checks wwhether the value of `prop1` is correct in relation with its property definition in the referred language.
      * @param prop
      */
-    validateProperty(node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, prop: LionWebJsonProperty, context: JsonContext): void {
+    validateProperty(_node: LionWebJsonNode, nodeConcept: LionWebJsonNode | undefined, prop: LionWebJsonProperty, context: JsonContext): void {
         if (prop.value === null) {
             return
         }

package/src/validators/LionWebLanguageValidator.ts

@@ -1,5 +1,6 @@
 import { isEqualMetaPointer, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
 import { isLionWebM3Language, JsonContext, LionWebJsonChunkWrapper, MetaPointers } from "@lionweb/json-utils"
+import { asMinimalJsonString } from "@lionweb/ts-utils"
 import { GenericIssue } from "../issues/index.js"
 import { MissingM3Language_Issue } from "../issues/LanguageIssues.js"
 import { isConcept, LanguageRegistry } from "../languages/index.js"
@@ -33,7 +34,7 @@ export class LionWebLanguageValidator {
         const languageNodes = this.chunkWrapper.findNodesOfClassifier(MetaPointers.Language)
         if (languageNodes.length !== 1) {
             // TODO Better error handling.
-            console.error("Error: xpected exactly one Language node, found " + languageNodes.length + " => " + JSON.stringify(languageNodes))
+            console.error("Error: xpected exactly one Language node, found " + languageNodes.length + " => " + asMinimalJsonString(languageNodes))
         }
         chunk.nodes.forEach((node, index) => {
             if (!isConcept(node)) {

package/src/validators/LionWebSyntaxValidator.ts

@@ -1,6 +1,6 @@
 import { SyntaxValidator } from "./generic/SyntaxValidator.js"
 import { ValidationResult } from "./generic/ValidationResult.js"
-import { expectedTypes } from "./LionWebChunkDefinitions.js"
+import { LionWebSchema } from "./LionWebChunkDefinitions.js"
 
 /**
  * LionWebSyntaxValidator can check whether objects are structurally LionWeb objects.
@@ -8,7 +8,7 @@ import { expectedTypes } from "./LionWebChunkDefinitions.js"
 export class LionWebSyntaxValidator extends SyntaxValidator {
 
     constructor(validationResult: ValidationResult) {
-        super(validationResult, expectedTypes)
+        super(validationResult, LionWebSchema)
     }
 }
 

package/src/validators/LionWebValidator.ts

@@ -34,7 +34,7 @@ export class LionWebValidator {
     }
 
     validateSyntax() {
-        this.syntaxValidator.validate(this.object, "LionWebChunk")
+        this.syntaxValidator.validate(this.object, "LionWebJsonChunk")
         this.syntaxCorrect = !this.validationResult.hasErrors()
         if (this.syntaxCorrect) {
             this.chunk = new LionWebJsonChunkWrapper(this.object as LionWebJsonChunk)

package/src/validators/ValidationFunctions.ts

@@ -3,6 +3,7 @@
  * Used in the LionWebSyntaxValidator.
  */
 import { JsonContext } from "@lionweb/json-utils"
+import { asMinimalJsonString } from "@lionweb/ts-utils"
 import { Language_PropertyValue_Issue } from "../issues/LanguageIssues.js"
 import {
     Syntax_IdFormat_Issue,
@@ -12,7 +13,7 @@ import {
     Syntax_VersionFormat_Issue
 } from "../issues/SyntaxIssues.js"
 import { ValidationResult } from "./generic/ValidationResult.js"
-import { PropertyDefinition } from "./generic/ValidationTypes.js"
+import { PropertyDefinition } from "./generic/schema/ValidationTypes.js"
 
 /**
  * Check whether `id` is a valid LionWeb id.
@@ -20,7 +21,6 @@ import { PropertyDefinition } from "./generic/ValidationTypes.js"
  * @param result    Any validation issues found will be put into this object.
  * @param context   The context for the error message in errors.
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
 export function validateId<String>(value: String, result: ValidationResult, context: JsonContext): void {
     const idString: string = "" + value
     const regexp = /^[a-zA-Z0-9_-][a-zA-Z0-9_-]*$/
@@ -35,7 +35,6 @@ export function validateId<String>(value: String, result: ValidationResult, cont
  * @param result    Any validation issues found will be put into this object.
  * @param context   The context for the error message in errors.
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
 export function validateKey<String>(value: String, result: ValidationResult, context: JsonContext): void {
     const keyString: string = "" + value
     const regexp = /^[a-zA-Z0-9_-][a-zA-Z0-9_-]*$/
@@ -50,7 +49,6 @@ export function validateKey<String>(value: String, result: ValidationResult, con
  * @param result    Any validation issues found will be put into this object.
  * @param context   The location in the overall JSON.
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
 export function validateVersion<String>(value: String, result: ValidationResult, context: JsonContext): void {
     const versionString: string = "" + value
     if (versionString.length === 0) {
@@ -65,16 +63,15 @@ export function validateVersion<String>(value: String, result: ValidationResult,
  * @param context   The location in the overall JSON.
  * @param propDef   The PropertyDefinition for this value
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
 export function validateBoolean<String>(value: String, result: ValidationResult, context: JsonContext, propDef?: PropertyDefinition): void {
     const valueAsPrimitive = "" + value
     if (valueAsPrimitive !== "true" && valueAsPrimitive !== "false") {
         result.issue(
             new Language_PropertyValue_Issue(
                 context,
-                propDef ? propDef.property : "unknown",
+                propDef ? propDef.name : "unknown",
                 valueAsPrimitive,
-                "boolean " + JSON.stringify(value)
+                "boolean " + asMinimalJsonString(value)
             )
         )
     }
@@ -87,12 +84,11 @@ export function validateBoolean<String>(value: String, result: ValidationResult,
  * @param context   The location in the overall JSON.
  * @param propDef   The PropertyDefinition for this value
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
 export function validateInteger<String>(value: String, result: ValidationResult, context: JsonContext, propDef?: PropertyDefinition): void {
     const valueAsPrimitive = "" + value
     const regexp = /^[+-]?(0|[1-9][0-9]*)$/
     if (valueAsPrimitive === null || !regexp.test(valueAsPrimitive)) {
-        result.issue(new Language_PropertyValue_Issue(context, propDef ? propDef.property : "unknown", valueAsPrimitive, "integer"))
+        result.issue(new Language_PropertyValue_Issue(context, propDef ? propDef.name : "unknown", valueAsPrimitive, "integer"))
     }
 }
 
@@ -103,16 +99,15 @@ export function validateInteger<String>(value: String, result: ValidationResult,
  * @param context   The location in the overall JSON.
  * @param propDef   The PropertyDefinition for this value
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
 export function validateJSON<String>(value: String, result: ValidationResult, context: JsonContext, propDef?: PropertyDefinition): void {
     const valueAsPrimitive = "" + value
     if (value === null) {
-        result.issue(new Syntax_PropertyNullIssue(context, propDef!.property!))
+        result.issue(new Syntax_PropertyNullIssue(context, propDef!.name!))
     }
     try {
         JSON.parse(valueAsPrimitive)
-    } catch (e) {
-        result.issue(new Language_PropertyValue_Issue(context, propDef ? propDef.property : "unknown", valueAsPrimitive, "JSON"))
+    } catch (_) {
+        result.issue(new Language_PropertyValue_Issue(context, propDef ? propDef.name : "unknown", valueAsPrimitive, "JSON"))
     }
 }
 
@@ -122,10 +117,9 @@ export function validateJSON<String>(value: String, result: ValidationResult, co
  * @param result
  * @param context
  */
-// eslint-disable-next-line @typescript-eslint/ban-types
 export function validateSerializationFormatVersion<String>(value: String, result: ValidationResult, context: JsonContext): void {
     if (typeof value !== "string") {
-        result.issue(new Syntax_SerializationFormatVersion_Issue(context, JSON.stringify(value)))
+        result.issue(new Syntax_SerializationFormatVersion_Issue(context, asMinimalJsonString(value)))
         return
     }
     if (value.length === 0) {