@lionweb/validation 0.7.2-beta.6 → 0.8.0-beta.0

package/dist/validators/index.d.ts

@@ -4,6 +4,6 @@ export * from "./LionWebReferenceValidator.js";
 export * from "./LionWebLanguageValidator.js";
 export * from "./LionWebLanguageReferenceValidator.js";
 export * from "./LionWebValidator.js";
+export * from "./definitions/index.js";
 export * from "./ValidationFunctions.js";
-export * from "./LionWebChunkDefinitions.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/validators/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validators/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,wCAAwC,CAAA;AACtD,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,cAAc,8BAA8B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/validators/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,wCAAwC,CAAA;AACtD,cAAc,uBAAuB,CAAA;AACrC,cAAc,wBAAwB,CAAA;AACtC,cAAc,0BAA0B,CAAA"}

package/dist/validators/index.js

@@ -4,6 +4,6 @@ export * from "./LionWebReferenceValidator.js";
 export * from "./LionWebLanguageValidator.js";
 export * from "./LionWebLanguageReferenceValidator.js";
 export * from "./LionWebValidator.js";
+export * from "./definitions/index.js";
 export * from "./ValidationFunctions.js";
-export * from "./LionWebChunkDefinitions.js";
 //# sourceMappingURL=index.js.map

package/dist/validators/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/validators/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,wCAAwC,CAAA;AACtD,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,cAAc,8BAA8B,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/validators/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,gCAAgC,CAAA;AAC9C,cAAc,+BAA+B,CAAA;AAC7C,cAAc,wCAAwC,CAAA;AACtD,cAAc,uBAAuB,CAAA;AACrC,cAAc,wBAAwB,CAAA;AACtC,cAAc,0BAA0B,CAAA"}

package/package.json

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

package/src/validators/LionWebReferenceValidator.ts

@@ -22,9 +22,14 @@ export class LionWebReferenceValidator {
         this.validationResult = validationResult
     }
 
-    validateNodeIds(obj: LionWebJsonChunk, ctx: JsonContext): void {
+    /**
+     * Checks for duplicate node id's.
+     * As a side-effect creates a map from `id` to `node` for all nodes in `chunk` to make further validation faster.
+     * @param ctx
+     */
+    validateNodeIds(chunk: 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) => {
+        chunk.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))
@@ -172,6 +177,13 @@ export class LionWebReferenceValidator {
         }
     }
 
+    /**
+     * Checks whether `child` appears in a `containment` of `parent`.
+     * Only applicable when both `parent` and `child` are in the same LionWebJsonChunk being validated.
+     * @param context
+     * @param parent
+     * @param child
+     */
     validateExistsAsChild(context: JsonContext, parent: LionWebJsonNode | undefined, child: LionWebJsonNode) {
         if (parent === undefined || parent === null) {
             return
@@ -187,6 +199,12 @@ export class LionWebReferenceValidator {
         this.validationResult.issue(new Reference_ChildMissingInParent_Issue(context, child, parent))
     }
 
+    /**
+     * Checks whether the `children` in the `containments` of `parent` have `parent` as their parent node.
+     * Only applicable when both `parent` and `child` are in the same LionWebJsonChunk being validated.
+     * @param node
+     * @param context
+     */
     validateChildrenHaveCorrectParent(node: LionWebJsonNode, context: JsonContext) {
         node.containments.forEach((child: LionWebJsonContainment) => {
             child.children.forEach((childId: LionWebId, index: number) => {

package/src/validators/LionWebSyntaxValidator.ts

@@ -1,14 +1,21 @@
+import { ChunksDefinitions, DeltaTypesDefinitions } from "./definitions/index.js"
+import { SyntaxDefinition } from "./generic/index.js"
 import { SyntaxValidator } from "./generic/SyntaxValidator.js"
 import { ValidationResult } from "./generic/ValidationResult.js"
-import { LionWebSchema } from "./LionWebChunkDefinitions.js"
+import { validateId, validateKey, validateSerializationFormatVersion, validateVersion } from "./ValidationFunctions.js"
 
-/**
+const schema = new SyntaxDefinition([], [ChunksDefinitions, DeltaTypesDefinitions] )
+schema.addValidator("LionWebId", validateId ),
+schema.addValidator("LionWebKey", validateKey ),
+schema.addValidator("LionWebVersion",validateVersion),
+schema.addValidator("LionWebSerializationFormatVersion", validateSerializationFormatVersion)
+/*
  * LionWebSyntaxValidator can check whether objects are structurally LionWeb objects.
  */
 export class LionWebSyntaxValidator extends SyntaxValidator {
 
     constructor(validationResult: ValidationResult) {
-        super(validationResult, LionWebSchema)
+        super(validationResult, schema)
     }
 }
 

package/src/validators/ValidationFunctions.ts

@@ -12,8 +12,8 @@ import {
     Syntax_SerializationFormatVersion_Issue,
     Syntax_VersionFormat_Issue
 } from "../issues/SyntaxIssues.js"
+import { PropertyDefinition } from "./generic/index.js"
 import { ValidationResult } from "./generic/ValidationResult.js"
-import { PropertyDefinition } from "./generic/schema/ValidationTypes.js"
 
 /**
  * Check whether `id` is a valid LionWeb id.

package/src/validators/definitions/ChunksDefinitions.ts

@@ -0,0 +1,252 @@
+import { TypeGroup } from "../generic/schema/SyntaxDefinition.js";
+
+export const ChunksDefinitions: TypeGroup = {
+    name: "Chunks",
+    primitiveTypes: [
+        {
+            name: "LionWebId",
+            primitiveType: "string",
+        },
+        {
+            name: "LionWebKey",
+            primitiveType: "string",
+        },
+        {
+            name: "LionWebVersion",
+            primitiveType: "string",
+        },
+        {
+            name: "LionWebSerializationFormatVersion",
+            primitiveType: "string",
+        },
+    ],
+    structuredTypes: [
+        {
+            name: "LionWebJsonMetaPointer",
+            properties: [
+                {
+                    name: "key",
+                    type: "LionWebKey",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "version",
+                    type: "LionWebVersion",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "language",
+                    type: "LionWebKey",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "ResponseMessage",
+            properties: [
+                {
+                    name: "kind",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "message",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "data",
+                    type: "KeyValuePair",
+                    isList: false,
+                    isOptional: true,
+                    mayBeNull: true,
+                },
+            ],
+        },
+        {
+            name: "LionWebJsonChunk",
+            properties: [
+                {
+                    name: "serializationFormatVersion",
+                    type: "LionWebSerializationFormatVersion",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "languages",
+                    type: "LionWebJsonUsedLanguage",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "nodes",
+                    type: "LionWebJsonNode",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "LionWebJsonUsedLanguage",
+            properties: [
+                {
+                    name: "key",
+                    type: "LionWebKey",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "version",
+                    type: "LionWebVersion",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "LionWebJsonNode",
+            properties: [
+                {
+                    name: "id",
+                    type: "LionWebId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "classifier",
+                    type: "LionWebJsonMetaPointer",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "properties",
+                    type: "LionWebJsonProperty",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "containments",
+                    type: "LionWebJsonContainment",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "references",
+                    type: "LionWebJsonReference",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "annotations",
+                    type: "LionWebId",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "parent",
+                    type: "LionWebId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: true,
+                },
+            ],
+        },
+        {
+            name: "LionWebJsonProperty",
+            properties: [
+                {
+                    name: "property",
+                    type: "LionWebJsonMetaPointer",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "value",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: true,
+                },
+            ],
+        },
+        {
+            name: "LionWebJsonContainment",
+            properties: [
+                {
+                    name: "containment",
+                    type: "LionWebJsonMetaPointer",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "children",
+                    type: "LionWebId",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "LionWebJsonReference",
+            properties: [
+                {
+                    name: "reference",
+                    type: "LionWebJsonMetaPointer",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+                {
+                    name: "targets",
+                    type: "LionWebJsonReferenceTarget",
+                    isList: true,
+                    isOptional: false,
+                    mayBeNull: false,
+                },
+            ],
+        },
+        {
+            name: "LionWebJsonReferenceTarget",
+            properties: [
+                {
+                    name: "resolveInfo",
+                    type: "String",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: true,
+                },
+                {
+                    name: "reference",
+                    type: "LionWebId",
+                    isList: false,
+                    isOptional: false,
+                    mayBeNull: true,
+                },
+            ],
+        },
+    ],
+};