@lionweb/validation 0.5.0 → 0.6.0-beta.2

package/src/diff/changes/Change.ts

@@ -0,0 +1,52 @@
+import { JsonContext } from "../../issues/index.js"
+
+export type ChangeType =
+    | "GenericChange"
+    | "NodeRemoved"
+    | "NodeAdded"
+    | "ChildRemoved"
+    | "ChildAdded"
+    | "ParentChanged"
+    | "PropertyValueChanged"
+    | "SerializationFormatChange"
+    | "PropertyRemoved"
+    | "PropertyAdded"
+    | "NodeClassifierChanged"
+    | "ContainmentAdded"
+    | "ContainmentRemoved"
+    | "LanguageRemoved"
+    | "LanguageAdded"
+    | "TargetAdded"
+    | "TargetRemoved"
+    | "ReferenceRemoved"
+    | "ReferenceAdded"
+
+export abstract class Change {
+    abstract readonly id: ChangeType
+    context: JsonContext
+
+    constructor(context: JsonContext) {
+        this.context = context
+    }
+
+    protected abstract msg(): string
+
+    public changeMsg(): string {
+        return `${this.id}: ${this.msg()} at ${this.context.toString()} `
+    }
+}
+
+export class GenericChange extends Change {
+    readonly id = "GenericChange"
+
+    constructor(
+        context: JsonContext,
+        protected message: string,
+    ) {
+        super(context)
+    }
+
+    protected msg(): string {
+        return this.message
+    }
+}

package/src/diff/changes/ChunkChange.ts

@@ -0,0 +1,68 @@
+import { JsonContext } from "../../issues/index.js"
+import { LionWebJsonNode, LwJsonUsedLanguage } from "../../json/index.js"
+import { Change } from "./Change.js"
+
+export abstract class ChunkChange extends Change {
+    constructor(public context: JsonContext) {
+        super(context)
+    }
+}
+
+export class SerializationFormatChange extends ChunkChange {
+    readonly id = "SerializationFormatChange"
+
+    constructor(
+        public context: JsonContext,
+        protected original: string,
+        protected newValue: string,
+    ) {
+        super(context)
+    }
+
+    protected msg = () => `Serialization versions do not match: ${this.original} vs ${this.newValue}`
+}
+
+export class NodeRemoved extends ChunkChange {
+    readonly id = "NodeRemoved"
+
+    constructor(
+        public context: JsonContext,
+        public node: LionWebJsonNode,
+    ) {
+        super(context)
+    }
+
+    protected msg = () => `Node ${this.node.id} is removed`
+}
+
+export class NodeAdded extends ChunkChange {
+    readonly id = "NodeAdded"
+
+    constructor(
+        public context: JsonContext,
+        public node: LionWebJsonNode,
+    ) {
+        super(context)
+    }
+
+    protected msg = () => `Node ${this.node.id} is added`
+}
+
+export abstract class LanguageChange extends ChunkChange {
+    constructor(
+        public context: JsonContext,
+        public language: LwJsonUsedLanguage,
+    ) {
+        super(context)
+    }
+}
+
+export class LanguageRemoved extends LanguageChange {
+    readonly id = "LanguageRemoved"
+    protected msg = () => `Language with  key ${this.language.key} and version ${this.language.version} is removed`
+}
+
+export class LanguageAdded extends LanguageChange {
+    readonly id = "LanguageAdded"
+    protected msg = () => `Language with  key ${this.language.key} and version ${this.language.version} is added`
+}

package/src/diff/changes/ContainmentChange.ts

@@ -0,0 +1,34 @@
+import { JsonContext } from "../../issues/index.js"
+import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
+import { Change } from "./Change.js"
+
+export abstract class ContainmentChange extends Change {
+    constructor(
+        public context: JsonContext,
+        public parentNode: LionWebJsonNode,
+        public containment: LionWebJsonMetaPointer,
+        public childId: string,
+    ) {
+        super(context)
+    }
+}
+
+export class ChildAdded extends ContainmentChange {
+    readonly id = "ChildAdded"
+    protected msg = () => `Node "${this.parentNode.id}" added child "${this.childId}" to containment ${this.containment.key}`
+}
+
+export class ChildRemoved extends ContainmentChange {
+    readonly id = "ChildRemoved"
+    protected msg = () => `Node "${this.parentNode.id}" removed child "${this.childId}"`
+}
+
+export class ContainmentAdded extends Change {
+    readonly id = "ContainmentAdded";
+    constructor(ctx: JsonContext, public node: LionWebJsonNode, public containment: LionWebJsonMetaPointer) {
+        super(ctx)
+    }
+
+    protected msg = () => `Node "${this.node.id}" containment added: "${JSON.stringify(this.containment)}"`
+}
+

package/src/diff/changes/NodeChange.ts

@@ -0,0 +1,32 @@
+import { JsonContext } from "../../issues/index.js"
+import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
+import { Change, ChangeType } from "./Change.js"
+
+export class NodeClassifierChanged extends Change {
+    readonly id: ChangeType = "NodeClassifierChanged"
+
+    constructor(
+        public context: JsonContext,
+        public node: LionWebJsonNode,
+        public oldClassifier: LionWebJsonMetaPointer,
+        public newClassifier: LionWebJsonMetaPointer,
+    ) {
+        super(context)
+    }
+    protected msg = () => `Object ${this.node.id} has classifier changed from ${this.oldClassifier.key} to ${this.newClassifier.key}`
+}
+
+export class ParentChanged extends Change {
+    readonly id = "ParentChanged"
+
+    constructor(
+        public context: JsonContext,
+        public node: LionWebJsonNode,
+        public beforeParentId: string | null,
+        public afterParentId: string | null,
+    ) {
+        super(context)
+    }
+
+    protected msg = () => `Node "${this.node.id}" changed parent from "${this.beforeParentId}" to "${this.afterParentId}`
+}

package/src/diff/changes/PropertyChange.ts

@@ -0,0 +1,29 @@
+import { JsonContext } from "../../issues/index.js"
+import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
+import { Change } from "./Change.js"
+
+export abstract class PropertyChange extends Change {
+    constructor(
+        public context: JsonContext,
+        public nodeId: string,
+        public property: LionWebJsonMetaPointer,
+        public oldValue: string | undefined,
+        public newValue: string | undefined,
+    ) {
+        super(context)
+    }
+}
+
+export class PropertyValueChanged extends PropertyChange {
+    readonly id = "PropertyValueChanged"
+    protected msg = () => `Node "${this.nodeId} changed value of property "${this.property.key}" from "${this.oldValue}" to "${this.newValue}"`
+}
+
+export class PropertyAdded extends Change {
+    readonly id = "PropertyAdded";
+    constructor(ctx: JsonContext, public node: LionWebJsonNode, public property: LionWebJsonMetaPointer) {
+        super(ctx)
+    }
+
+    protected msg = () => `Node "${this.node.id}" containment added: "${JSON.stringify(this.property)}"`
+}

package/src/diff/changes/ReferenceChange.ts

@@ -0,0 +1,24 @@
+import { JsonContext } from "../../issues/index.js"
+import { LionWebJsonMetaPointer, LionWebJsonNode } from "../../json/index.js"
+import { Change } from "./Change.js"
+
+export abstract class ReferenceChange extends Change {
+    constructor(
+        public context: JsonContext,
+        public node: LionWebJsonNode,
+        public reference: LionWebJsonMetaPointer,
+        public targetId: string,
+    ) {
+        super(context)
+    }
+}
+
+export class TargetAdded extends ReferenceChange {
+    readonly id = "TargetAdded"
+    protected msg = () => `Node "${this.node.id}" added target "${this.targetId}" to reference "${this.reference.key}"`
+}
+
+export class TargetRemoved extends ReferenceChange {
+    readonly id = "TargetRemoved"
+    protected msg = () => `Node "${this.node.id}" removed target "${this.targetId}" from reference "${this.reference.key}"`
+}

package/src/diff/changes/index.ts

@@ -0,0 +1,6 @@
+export * from "./Change.js"
+export * from "./ChunkChange.js"
+export * from "./ContainmentChange.js"
+export * from "./NodeChange.js"
+export * from "./PropertyChange.js"
+export * from "./ReferenceChange.js"

package/src/diff/index.ts

@@ -0,0 +1,3 @@
+export * from "./changes/index.js"
+export * from "./DiffResult.js"
+export * from "./LionWebJsonDiff.js"

package/src/index.ts

@@ -1,4 +1,5 @@
-export * from "./issues/index.js";
-export * from "./json/index.js";
-export * from "./validators/index.js";
-export * from "./runners/index.js";
+export * from "./issues/index.js"
+export * from "./json/index.js"
+export * from "./validators/index.js"
+export * from "./diff/index.js"
+export * from "./runners/index.js"

package/src/issues/LanguageIssues.ts

@@ -1,12 +1,17 @@
-import { LionWebJsonMetaPointer } from "../json/LionWebJson.js";
-import { JsonContext } from "./JsonContext.js";
-import { ValidationIssue } from "./ValidationIssue.js";
+import { LionWebJsonMetaPointer } from "../json/LionWebJson.js"
+import { JsonContext } from "../json/JsonContext.js"
+import { ValidationIssue } from "./ValidationIssue.js"
 
 export class Language_PropertyValue_Issue extends ValidationIssue {
-    readonly id = "PropertyValue";
+    readonly id = "PropertyValue"
 
-    constructor(context: JsonContext, public property: string, public value: string,public expectedType: string  ) {
-        super(context);
+    constructor(
+        context: JsonContext,
+        public property: string,
+        public value: string,
+        public expectedType: string,
+    ) {
+        super(context)
     }
 
     msg = (): string => `Property  "${this.property}" with value "${this.value}" is not of type "${this.expectedType}"`
@@ -14,79 +19,96 @@ export class Language_PropertyValue_Issue extends ValidationIssue {
 
 // Incorrect Meta Pointers
 export abstract class Language_IncorrectMetaPointerType_Issue extends ValidationIssue {
-    abstract readonly metaType: string;
+    abstract readonly metaType: string
 
-    constructor(context: JsonContext, public metaPointer: LionWebJsonMetaPointer, public incorrectType: string) {
-        super(context);
+    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}"`
+    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 id = "IncorrectPropertyMetaPointer";
-    readonly metaType = "Property";
+    readonly id = "IncorrectPropertyMetaPointer"
+    readonly metaType = "Property"
 }
 export class Language_IncorrectConceptMetaPointer_Issue extends Language_IncorrectMetaPointerType_Issue {
-    readonly id = "IncorrectConceptMetaPointer";
-    readonly metaType = "Concept";
+    readonly id = "IncorrectConceptMetaPointer"
+    readonly metaType = "Concept"
 }
 export class Language_IncorrectReferenceMetaPointer_Issue extends Language_IncorrectMetaPointerType_Issue {
-    readonly id = "IncorrectReferenceMetaPointer";
-    readonly metaType = "Reference";
+    readonly id = "IncorrectReferenceMetaPointer"
+    readonly metaType = "Reference"
 }
 export class Language_IncorrectContainmentMetaPointer_Issue extends Language_IncorrectMetaPointerType_Issue {
-    readonly id = "IncorrectContainmentMetaPointer";
-    readonly metaType = "Containment";
+    readonly id = "IncorrectContainmentMetaPointer"
+    readonly metaType = "Containment"
 }
 
 // Unknown Meta Pointers
 export abstract class Language_UnknownMetaPointer_Issue extends ValidationIssue {
-    abstract readonly metaType: string;
+    abstract readonly metaType: string
 
-    constructor(context: JsonContext, public metaPointer: LionWebJsonMetaPointer) {
-        super(context);
+    constructor(
+        context: JsonContext,
+        public metaPointer: LionWebJsonMetaPointer,
+    ) {
+        super(context)
     }
 
-    msg = (): string => `${this.metaType} with key ${this.metaPointer.key} is unknown in the language`;
+    msg = (): string => `${this.metaType} with key ${this.metaPointer.key} is unknown in the language`
 }
 
 export class Language_UnknownReference_Issue extends Language_UnknownMetaPointer_Issue {
-    readonly id = "UnknownReference";
-    readonly metaType = "Reference";
+    readonly id = "UnknownReference"
+    readonly metaType = "Reference"
 }
 export class Language_UnknownContainment_Issue extends Language_UnknownMetaPointer_Issue {
-    readonly id = "UnknownContainment";
-    readonly metaType = "Containment";
+    readonly id = "UnknownContainment"
+    readonly metaType = "Containment"
 }
 export class Language_UnknownProperty_Issue extends Language_UnknownMetaPointer_Issue {
-    readonly id = "UnknownProperty";
-    readonly metaType = "Property";
+    readonly id = "UnknownProperty"
+    readonly metaType = "Property"
 }
 export class Language_UnknownConcept_Issue extends Language_UnknownMetaPointer_Issue {
-    readonly id = "UnknownConcept";
-    readonly metaType = "Concept";
+    readonly id = "UnknownConcept"
+    readonly metaType = "Concept"
 }
 
 // Actual Language checks on M2
 export class NumberOfLanguagesUsed_Issue extends ValidationIssue {
-    readonly id = "NumberOfLanguagesUsed";
-    constructor(context: JsonContext, public nrOfLanguages: number) {
-        super(context);
+    readonly id = "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 NotLionCoreLanguageKey_Issue extends ValidationIssue {
-    readonly id = "NotLionCoreLanguageKey";
-    constructor(context: JsonContext, public incorrectKey: string) {
-        super(context);
+    readonly id = "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 id = "IncorrectLionCoreVersion";
-    constructor(context: JsonContext, public incorrectVersion: string) {
-        super(context);
+    readonly id = "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

@@ -1,61 +1,83 @@
-import { LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js";
-import { JsonContext } from "./JsonContext.js";
-import { ValidationIssue } from "./ValidationIssue.js";
+import { LionWebJsonMetaPointer, LionWebJsonNode } from "../json/LionWebJson.js"
+import { JsonContext } from "../json/JsonContext.js"
+import { ValidationIssue } from "./ValidationIssue.js"
 
 export class Reference_DuplicateNodeId_Issue extends ValidationIssue {
-    readonly id = "DuplicateNodeId";
-    
-    constructor(context: JsonContext, public nodeId: string) {
-        super(context);
+    readonly id = "DuplicateNodeId"
+
+    constructor(
+        context: JsonContext,
+        public nodeId: string,
+    ) {
+        super(context)
     }
-    
-    msg = () : string => `Node has duplicate id "${this.nodeId}"`
+
+    msg = (): string => `Node has duplicate id "${this.nodeId}"`
 }
 
 export class Reference_ChildMissingInParent_Issue extends ValidationIssue {
-    readonly id = "ChildMissingInParent";
+    readonly id = "ChildMissingInParent"
 
-    constructor(context: JsonContext, public child: LionWebJsonNode, public parent: LionWebJsonNode) {
-        super(context);
+    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.`
+    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 id = "ParentMissingInChild";
+    readonly id = "ParentMissingInChild"
 
-    constructor(context: JsonContext, public parent: LionWebJsonNode, public child: LionWebJsonNode) {
-        super(context);
+    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 empty parent.`
+    msg = (): string => `Node with id "${this.parent.id}" has child with id "${this.child.id}" but child has empty parent.`
 }
 
 export class Reference_CirculairParent_Issue extends ValidationIssue {
-    readonly id = "CirculairParent";
+    readonly id = "CirculairParent"
 
-    constructor(context: JsonContext, public node: LionWebJsonNode | undefined, public parentPath: string[]) {
-        super(context);
+    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}".`
+    msg = (): string => `Node with id "${this.node?.id}" has circulair parent through "${this.parentPath}".`
 }
 
 export class Reference_LanguageUnknown_Issue extends ValidationIssue {
-    readonly id = "LanguageUnknown";
-    
-    constructor(context: JsonContext, public languageRef: LionWebJsonMetaPointer) {
-        super(context);
+    readonly id = "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`
+    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 id = "Duplicates";
+    readonly id = "Duplicates"
 
-    constructor(context: JsonContext, public nodeid: string) {
-        super(context);
+    constructor(
+        context: JsonContext,
+        public nodeid: string,
+    ) {
+        super(context)
     }
     msg = () => `Duplicate value "${this.nodeid}"`
 }

package/src/issues/SyntaxIssues.ts

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

package/src/issues/ValidationIssue.ts

@@ -1,15 +1,15 @@
-import { JsonContext } from "./JsonContext.js";
+import { JsonContext } from "../json/JsonContext.js"
 
 export abstract class ValidationIssue {
-    abstract readonly id: string;
-    context: JsonContext;
-    
+    abstract readonly id: string
+    context: JsonContext
+
     constructor(context: JsonContext) {
-        this.context = context;
+        this.context = context
     }
 
-    protected abstract msg(): string;
-    
+    protected abstract msg(): string
+
     public errorMsg(): string {
         return `${this.id}: ${this.msg()} at ${this.context.toString()} `
     }