@lionweb/validation 0.7.0-beta.18 → 0.7.0-beta.19

package/CHANGELOG.md

@@ -3,7 +3,6 @@
 ## 0.7.0
 
 * Refactor validation schema to enable generation ot TypeScript types with discriminator.
-* (Don't publish TypeScript sources to NPM.)
 
 
 ## 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lionweb/validation",
-    "version": "0.7.0-beta.18",
+    "version": "0.7.0-beta.19",
     "license": "Apache 2.0",
     "description": "LionWeb Serialization validation",
     "author": "jos.warmer@openmodeling.nl",
@@ -32,8 +32,8 @@
         "republish-local": "yarn unpublish-local && yarn publish-local"
     },
     "dependencies": {
-        "@lionweb/json": "0.7.0-beta.18",
-        "@lionweb/ts-utils": "0.7.0-beta.18",
-        "@lionweb/json-utils": "0.7.0-beta.18"
+        "@lionweb/json": "0.7.0-beta.19",
+        "@lionweb/ts-utils": "0.7.0-beta.19",
+        "@lionweb/json-utils": "0.7.0-beta.19"
     }
 }

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./issues/index.js"
+export * from "./validators/index.js"
+export * from "./runners/index.js"
+export * from "./languages/index.js"

package/src/issues/LanguageIssues.ts

@@ -0,0 +1,147 @@
+import { LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
+import { JsonContext } from "@lionweb/json-utils"
+import { ValidationIssue } from "./ValidationIssue.js"
+
+export class Language_PropertyValue_Issue extends ValidationIssue {
+    readonly issueType = "PropertyValueIncorrect"
+
+    constructor(
+        context: JsonContext,
+        public property: string,
+        public value: string | null,
+        public expectedType: string
+    ) {
+        super(context)
+    }
+
+    msg = (): string => `Property "${this.property}" with value "${this.value}" is not of type "${this.expectedType}"`
+}
+
+// Incorrect Meta Pointers
+export abstract class Language_IncorrectMetaPointerType_Issue extends ValidationIssue {
+    abstract readonly metaType: string
+
+    constructor(
+        context: JsonContext,
+        public metaPointer: LionWebJsonMetaPointer,
+        public incorrectType: string
+    ) {
+        super(context)
+    }
+
+    msg = (): string =>
+        `${this.metaType} with key "${this.metaPointer.key}" does not refer to a "${this.metaType}", but to a "${this.incorrectType}"`
+}
+
+export class Language_IncorrectPropertyMetaPointer_Issue extends Language_IncorrectMetaPointerType_Issue {
+    readonly issueType = "IncorrectPropertyMetaPointer"
+    readonly metaType = "Property"
+}
+
+export abstract class Language_FeatureMetaPointerNotInClassifier_Issue extends ValidationIssue {
+    abstract readonly metaType: string
+    constructor(
+        context: JsonContext,
+        public featureMetaPointer: LionWebJsonMetaPointer,
+        public classifierPointer: LionWebJsonNode
+    ) {
+        super(context)
+    }
+
+    msg = (): string =>
+        `${this.metaType} with key "${this.featureMetaPointer.key}" is not part of classifier "${this.classifierPointer.id}"`
+}
+export class Language_PropertyMetaPointerNotInClass_Issue extends Language_FeatureMetaPointerNotInClassifier_Issue {
+    readonly issueType = "PropertyMetaPointerNotInClass"
+    readonly metaType = "Property"
+}
+export class Language_ReferenceMetaPointerNotInClass_Issue extends Language_FeatureMetaPointerNotInClassifier_Issue {
+    readonly issueType = "ReferenceMetaPointerNotInClass"
+    readonly metaType = "Reference"
+}
+export class Language_ContainmentMetaPointerNotInClass_Issue extends Language_FeatureMetaPointerNotInClassifier_Issue {
+    readonly issueType = "ContainmentMetaPointerNotInClass"
+    readonly metaType = "Containment"
+}
+export class Language_IncorrectConceptMetaPointer_Issue extends Language_IncorrectMetaPointerType_Issue {
+    readonly issueType = "IncorrectConceptMetaPointer"
+    readonly metaType = "Concept"
+}
+export class Language_IncorrectReferenceMetaPointer_Issue extends Language_IncorrectMetaPointerType_Issue {
+    readonly issueType = "IncorrectReferenceMetaPointer"
+    readonly metaType = "Reference"
+}
+export class Language_IncorrectContainmentMetaPointer_Issue extends Language_IncorrectMetaPointerType_Issue {
+    readonly issueType = "IncorrectContainmentMetaPointer"
+    readonly metaType = "Containment"
+}
+
+// Unknown Meta Pointers
+export abstract class Language_UnknownMetaPointer_Issue extends ValidationIssue {
+    abstract readonly metaType: string
+
+    constructor(
+        context: JsonContext,
+        public metaPointer: LionWebJsonMetaPointer
+    ) {
+        super(context)
+    }
+
+    msg = (): string => `${this.metaType} with key ${this.metaPointer.key} is unknown in the language`
+}
+
+export class Language_UnknownReference_Issue extends Language_UnknownMetaPointer_Issue {
+    readonly issueType = "UnknownReference"
+    readonly metaType = "Reference"
+}
+export class Language_UnknownContainment_Issue extends Language_UnknownMetaPointer_Issue {
+    readonly issueType = "UnknownContainment"
+    readonly metaType = "Containment"
+}
+export class Language_UnknownProperty_Issue extends Language_UnknownMetaPointer_Issue {
+    readonly issueType = "UnknownProperty"
+    readonly metaType = "Property"
+}
+export class Language_UnknownConcept_Issue extends Language_UnknownMetaPointer_Issue {
+    readonly issueType = "UnknownConcept"
+    readonly metaType = "Concept"
+}
+
+// Actual Language checks on M2
+export class NumberOfLanguagesUsed_Issue extends ValidationIssue {
+    readonly issueType = "NumberOfLanguagesUsed"
+    constructor(
+        context: JsonContext,
+        public nrOfLanguages: number
+    ) {
+        super(context)
+    }
+    msg = () => `Is not a language: number of used languages should be 1, is ${this.nrOfLanguages}`
+}
+export class MissingM3Language_Issue extends ValidationIssue {
+    readonly issueType = "MissingM3Language"
+    constructor(context: JsonContext) {
+        super(context)
+    }
+    msg = () => `Missing used language LionCore-M3`
+}
+export class NotLionCoreLanguageKey_Issue extends ValidationIssue {
+    readonly issueType = "NotLionCoreLanguageKey"
+    constructor(
+        context: JsonContext,
+        public incorrectKey: string
+    ) {
+        super(context)
+    }
+    msg = () => `Is not a language: the used language key is not LionCore-M3, but ${this.incorrectKey}`
+}
+export class IncorrectLionCoreVersion_Issue extends ValidationIssue {
+    readonly issueType = "IncorrectLionCoreVersion"
+    constructor(
+        context: JsonContext,
+        public incorrectVersion: string
+    ) {
+        super(context)
+    }
+    msg = () => `Is not a language: the used language version is not 1, but ${this.incorrectVersion}`
+}

package/src/issues/ReferenceIssues.ts

@@ -0,0 +1,83 @@
+import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
+import { JsonContext } from "@lionweb/json-utils"
+import { ValidationIssue } from "./ValidationIssue.js"
+
+export class Reference_DuplicateNodeId_Issue extends ValidationIssue {
+    readonly issueType = "DuplicateNodeId"
+
+    constructor(
+        context: JsonContext,
+        public nodeId: LionWebId
+    ) {
+        super(context)
+    }
+
+    msg = (): string => `Node has duplicate id "${this.nodeId}"`
+}
+
+export class Reference_ChildMissingInParent_Issue extends ValidationIssue {
+    readonly issueType = "ChildMissingInParent"
+
+    constructor(
+        context: JsonContext,
+        public child: LionWebJsonNode,
+        public parent: LionWebJsonNode
+    ) {
+        super(context)
+    }
+
+    msg = (): string => `Node with id "${this.child.id}" has parent with id "${this.parent.id}" but parent does not contains it as a child.`
+}
+
+export class Reference_ParentMissingInChild_Issue extends ValidationIssue {
+    readonly issueType = "ParentMissingInChild"
+
+    constructor(
+        context: JsonContext,
+        public parent: LionWebJsonNode,
+        public child: LionWebJsonNode
+    ) {
+        super(context)
+    }
+
+    msg = (): string => `Node with id "${this.parent.id}" has child with id "${this.child.id}" but child has parent ${this.child.parent}.`
+}
+
+export class Reference_CirculairParent_Issue extends ValidationIssue {
+    readonly issueType = "CirculairParent"
+
+    constructor(
+        context: JsonContext,
+        public node: LionWebJsonNode | undefined,
+        public parentPath: string[]
+    ) {
+        super(context)
+    }
+
+    msg = (): string => `Node with id "${this.node?.id}" has circulair parent through "${this.parentPath}".`
+}
+
+export class Reference_LanguageUnknown_Issue extends ValidationIssue {
+    readonly issueType = "LanguageUnknown"
+
+    constructor(
+        context: JsonContext,
+        public languageRef: LionWebJsonMetaPointer
+    ) {
+        super(context)
+    }
+    msg = () =>
+        `Node uses language { language = ${this.languageRef.language}, version = ${this.languageRef.version} } which is not declared in used languages`
+}
+
+export class Duplicates_Issue extends ValidationIssue {
+    readonly issueType = "Duplicates"
+
+    constructor(
+        context: JsonContext,
+        public nodeId: LionWebId
+    ) {
+        super(context)
+    }
+    msg = () => `Duplicate value "${this.nodeId}"`
+}

package/src/issues/SyntaxIssues.ts

@@ -0,0 +1,84 @@
+import { JsonContext } from "@lionweb/json-utils"
+import { ValidationIssue } from "./ValidationIssue.js"
+
+export abstract class Syntax_PropertyIssue extends ValidationIssue {
+    constructor(
+        public context: JsonContext,
+        protected property: string
+    ) {
+        super(context)
+    }
+}
+
+export class Syntax_PropertyMissingIssue extends Syntax_PropertyIssue {
+    readonly issueType = "PropertyMissing"
+    protected msg = () => `Property "${this.property}" is missing`
+}
+
+export class Syntax_PropertyUnknownIssue extends Syntax_PropertyIssue {
+    readonly issueType = "PropertyUnknown"
+    protected msg = () => `Property "${this.property}" is not defined as a LionWeb property`
+}
+
+export class Syntax_PropertyNullIssue extends Syntax_PropertyIssue {
+    readonly issueType = "PropertyNull"
+    protected msg = () => `Property "${this.property}" is null, but it should have a value`
+}
+
+export class Syntax_PropertyTypeIssue extends Syntax_PropertyIssue {
+    readonly issueType = "PropertyTypeIncorrect"
+
+    constructor(
+        context: JsonContext,
+        property: string,
+        protected expectedType: string,
+        protected actualType: string
+    ) {
+        super(context, property)
+    }
+
+    protected msg = () => `Property ${this.property} should have type "${this.expectedType}", but has type "${this.actualType}"`
+}
+
+export class Syntax_ArrayContainsNull_Issue extends Syntax_PropertyIssue {
+    readonly issueType = "ArrayContainsNull"
+
+    constructor(
+        context: JsonContext,
+        property: string,
+        public index: number
+    ) {
+        super(context, property)
+    }
+
+    protected msg = () => `Property "${this.property}" of type array contains null at index "${"" + this.index}" `
+}
+
+export abstract class Syntax_IncorrectFormat_Issue extends ValidationIssue {
+    constructor(
+        context: JsonContext,
+        public value: string
+    ) {
+        super(context)
+    }
+}
+
+export class Syntax_SerializationFormatVersion_Issue extends Syntax_IncorrectFormat_Issue {
+    readonly issueType = "SerializationFormatVersion"
+    protected msg = () => `SerializationFormatVersion "${this.value}" is not a number`
+}
+
+export class Syntax_VersionFormat_Issue extends Syntax_IncorrectFormat_Issue {
+    readonly issueType = "VersionFormat"
+    protected msg = () => `Version "${this.value}" is an empty string.`
+}
+
+export class Syntax_KeyFormat_Issue extends Syntax_IncorrectFormat_Issue {
+    readonly issueType = "KeyFormat"
+    protected msg = () => `Key "${this.value}" has incorrect format.`
+}
+
+export class Syntax_IdFormat_Issue extends Syntax_IncorrectFormat_Issue {
+    readonly issueType = "IdFormat"
+    protected msg = () => `Id "${this.value}" has incorrect format.`
+}

package/src/issues/ValidationIssue.ts

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

package/src/issues/index.ts

@@ -0,0 +1,4 @@
+export * from "./ValidationIssue.js"
+export * from "./SyntaxIssues.js"
+export * from "./ReferenceIssues.js"
+export * from "./LanguageIssues.js"

package/src/languages/CompositeLionWebLanguageWrapper.ts

@@ -0,0 +1,57 @@
+import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
+import { LionWebLanguageWrapper } from "./LionWebLanguageWrapper.js"
+import { MetaPointerMap } from "./MetaPointerMap.js"
+
+/**
+ * Collection of language definitions
+ */
+export class CompositeLionWebLanguageWrapper extends LionWebLanguageWrapper {
+    metaPointerMap: MetaPointerMap = new MetaPointerMap()
+    languageMap = new Map<string, Map<string, LionWebLanguageWrapper>>()
+    languages: LionWebLanguageWrapper[] = []
+
+    addLanguage(lionWebLanguage: LionWebLanguageWrapper) {
+        let language = this.languageMap.get(lionWebLanguage.key)
+        if (language === undefined) {
+            language = new Map<string, LionWebLanguageWrapper>()
+            this.languageMap.set(lionWebLanguage.key, language)
+        }
+        const version = language.get(lionWebLanguage.version)
+        if (version === undefined) {
+            language.set(lionWebLanguage.version, lionWebLanguage)
+        } else {
+            // console.error("Language already known")
+            return
+        }
+        this.languages.push(lionWebLanguage)
+        lionWebLanguage.jsonChunk.nodes.forEach(node => {
+            this.metaPointerMap.add(lionWebLanguage.key, lionWebLanguage.version, node)
+        })
+    }
+
+    getLanguage(pointer: LionWebJsonMetaPointer): LionWebLanguageWrapper | undefined {
+        return this.languageMap.get(pointer.language)?.get(pointer.version)
+    }
+
+    /**
+     * Gets the node with _metaPointer_ in any of the known languages
+     * @param metaPointer
+     */
+    getNodeByMetaPointer(metaPointer: LionWebJsonMetaPointer): LionWebJsonNode | undefined {
+        return this.metaPointerMap.get(metaPointer)
+    }
+
+    /**
+     * Get node in any of the languages.
+     * @param nodeId
+     */
+    getNode(nodeId: LionWebId) {
+        for (const chunk of this.languages) {
+            const node = chunk.getNode(nodeId)
+            if (node !== undefined) {
+                return node
+            }
+        }
+        return undefined
+    }
+}

package/src/languages/LanguageRegistry.ts

@@ -0,0 +1,44 @@
+import { LionWebId, LionWebJsonMetaPointer, LionWebJsonNode } from "@lionweb/json"
+import { CompositeLionWebLanguageWrapper } from "./CompositeLionWebLanguageWrapper.js"
+import { LionWebLanguageWrapper } from "./LionWebLanguageWrapper.js"
+
+/**
+ * Collection of language definitions
+ */
+export class LanguageRegistry {
+    languages: CompositeLionWebLanguageWrapper = new CompositeLionWebLanguageWrapper({nodes: [], languages: [], serializationFormatVersion: "2023.1"})
+    
+    addLanguage(lionWebLanguage: LionWebLanguageWrapper) {
+        // console.log("LanguageRegistry.add: " + lionWebLanguage.name + "  " + lionWebLanguage.jsonChunk.nodes.length)
+
+        this.languages.addLanguage(lionWebLanguage)
+    }
+    
+    clear(): void {
+        this.languages = new CompositeLionWebLanguageWrapper({nodes: [], languages: [], serializationFormatVersion: "2023.1"})
+    }
+
+    getLanguage(pointer: LionWebJsonMetaPointer): LionWebLanguageWrapper | undefined {
+        return this.languages.languageMap.get(pointer.language)?.get(pointer.version)
+    }
+
+    /**
+     * Gets the node with _metaPointer_ in any of the known languages
+     * @param metaPointer
+     */
+    getNodeByMetaPointer(metaPointer: LionWebJsonMetaPointer): LionWebJsonNode | undefined {
+        return this.languages.getNodeByMetaPointer(metaPointer)
+    }
+
+    findNode(nodeId: LionWebId) {
+        for (const chunk of this.languages.languages) {
+            const node = chunk.getNode(nodeId)
+            if (node !== undefined) {
+                return node
+            }
+        }
+        return undefined
+    }
+}
+
+// export const KnownLanguages = new LanguageRegistry()

package/src/languages/LanguageUtils.ts

@@ -0,0 +1,63 @@
+import { isEqualMetaPointer, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
+import { LION_CORE_M3_KEY, MetaPointers } from "@lionweb/json-utils"
+
+import { createRequire } from "module"
+
+const require = createRequire(import.meta.url)
+const LionCore_M3 = require("./LionCore-M3.json")
+const LionCore_builtins = require("./LionCore-builtins.json")
+
+export const LionCore_M3_Json = LionCore_M3 as LionWebJsonChunk
+export const LionCore_builtins_Json = LionCore_builtins as LionWebJsonChunk
+
+export function isLionCoreLanguage(node: LionWebJsonNode) {
+    return node.classifier.language === LION_CORE_M3_KEY && node.classifier.version === "2023.1"
+}
+
+/**
+ * Does _node_ represent a language concept?
+ * @param node
+ */
+export const isConcept = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Concept)
+}
+
+/**
+ * Does _node_ represent a language annotation?
+ * @param node
+ */
+export const isAnnotation = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Annotation)
+}
+
+/**
+ * Does _node_ represent a language interface?
+ * @param node
+ */
+export const isInterface = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Interface)
+}
+
+/**
+ * Does _node_ represent a language property?
+ * @param node
+ */
+export const isProperty = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Property)
+}
+
+/**
+ * Does _node_ represent a language containment?
+ * @param node
+ */
+export const isContainment = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Containment)
+}
+
+/**
+ * Does _node_ represent a language reference?
+ * @param node
+ */
+export const isReference = (node: LionWebJsonNode): boolean => {
+    return isEqualMetaPointer(node.classifier, MetaPointers.Reference)
+}