@fluid-experimental/property-changeset 2.0.0-internal.3.0.5 → 2.0.0-internal.3.1.1

package/lib/templateValidator.js

@@ -178,8 +178,10 @@ const _psetDeepEquals = function (in_source, in_target) {
                 // A template with abstract properties must equal one with an empty properties array
                 // We check the difference in keys between the source and target and if the only difference is the
                 // properties array we check if it's empty. Then we reverse the condition so it work both ways.
-                if ((isEqual(difference(keysTarget, keysSource), ["properties"]) && !target.properties.length) ||
-                    (isEqual(difference(keysSource, keysTarget), ["properties"]) && !source.properties.length)) {
+                if ((isEqual(difference(keysTarget, keysSource), ["properties"]) &&
+                    !target.properties.length) ||
+                    (isEqual(difference(keysSource, keysTarget), ["properties"]) &&
+                        !source.properties.length)) {
                     return _getPSetDeepEqualsResult(true);
                 }
                 return _getPSetDeepEqualsResult(false);
@@ -291,40 +293,42 @@ const _validatePositiveIncrement = function (in_template, in_templatePrevious, i
             }
             if (CHANGE_LEVEL[versionDiff] < CHANGE_LEVEL[minimumLevel]) {
                 // Violates rule 6 (warning).
-                this._resultBuilder.addWarning(MSG.CHANGE_LEVEL_TOO_LOW_1 + JSON.stringify({
-                    mutation,
-                    id: idPath.join("."),
-                    level: {
-                        expected: minimumLevel,
-                        actual: versionDiff,
-                    },
-                    version: {
-                        current: in_version,
-                        previous: in_versionPrevious,
-                    },
-                }));
+                this._resultBuilder.addWarning(MSG.CHANGE_LEVEL_TOO_LOW_1 +
+                    JSON.stringify({
+                        mutation,
+                        id: idPath.join("."),
+                        level: {
+                            expected: minimumLevel,
+                            actual: versionDiff,
+                        },
+                        version: {
+                            current: in_version,
+                            previous: in_versionPrevious,
+                        },
+                    }));
             }
         }
         else {
             const sourceObjType = _getType.call(this, sourceObj);
             const targetObjType = _getType.call(this, targetObj);
             if (sourceObjType !== targetObjType) {
-                this._resultBuilder.addWarning(MSG.CHANGE_LEVEL_TOO_LOW_1 + JSON.stringify({
-                    mutation: "change",
-                    id: idPath.join("."),
-                    type: {
-                        current: targetObjType,
-                        previous: sourceObjType,
-                    },
-                    level: {
-                        expected: "major",
-                        actual: versionDiff,
-                    },
-                    version: {
-                        current: in_version,
-                        previous: in_versionPrevious,
-                    },
-                }));
+                this._resultBuilder.addWarning(MSG.CHANGE_LEVEL_TOO_LOW_1 +
+                    JSON.stringify({
+                        mutation: "change",
+                        id: idPath.join("."),
+                        type: {
+                            current: targetObjType,
+                            previous: sourceObjType,
+                        },
+                        level: {
+                            expected: "major",
+                            actual: versionDiff,
+                        },
+                        version: {
+                            current: in_version,
+                            previous: in_versionPrevious,
+                        },
+                    }));
             }
             if (Array.isArray(sourceObj)) {
                 let targetMap = {};
@@ -342,18 +346,19 @@ const _validatePositiveIncrement = function (in_template, in_templatePrevious, i
                     if (CHANGE_LEVEL[versionDiff] < CHANGE_LEVEL[minimumLevel]) {
                         // Violates rule 5 (warning)
                         idPath.push(Object.keys(targetMap)[0]);
-                        this._resultBuilder.addWarning(MSG.CHANGE_LEVEL_TOO_LOW_1 + JSON.stringify({
-                            mutation: "add",
-                            id: idPath.join("."),
-                            level: {
-                                expected: minimumLevel,
-                                actual: versionDiff,
-                            },
-                            version: {
-                                current: in_version,
-                                previous: in_versionPrevious,
-                            },
-                        }));
+                        this._resultBuilder.addWarning(MSG.CHANGE_LEVEL_TOO_LOW_1 +
+                            JSON.stringify({
+                                mutation: "add",
+                                id: idPath.join("."),
+                                level: {
+                                    expected: minimumLevel,
+                                    actual: versionDiff,
+                                },
+                                version: {
+                                    current: in_version,
+                                    previous: in_versionPrevious,
+                                },
+                            }));
                         idPath.pop();
                     }
                 }
@@ -374,22 +379,25 @@ const _validatePositiveIncrement = function (in_template, in_templatePrevious, i
                 if (!isEmpty(remainingKeys)) {
                     // Added new keys to the target. This is a MINOR change, unless they new key is a
                     // comment, in which case this is a PATCH level change.
-                    let minimumLevel = remainingKeys.length === 1 && remainingKeys[0] === "annotation" ? "patch" : "minor";
+                    let minimumLevel = remainingKeys.length === 1 && remainingKeys[0] === "annotation"
+                        ? "patch"
+                        : "minor";
                     if (CHANGE_LEVEL[versionDiff] < CHANGE_LEVEL[minimumLevel]) {
                         // Violates rule 5 (warning)
                         idPath.push(remainingKeys[0]);
-                        this._resultBuilder.addWarning(MSG.CHANGE_LEVEL_TOO_LOW_1 + JSON.stringify({
-                            mutation: "add",
-                            id: idPath.join("."),
-                            level: {
-                                expected: minimumLevel,
-                                actual: versionDiff,
-                            },
-                            version: {
-                                current: in_version,
-                                previous: in_versionPrevious,
-                            },
-                        }));
+                        this._resultBuilder.addWarning(MSG.CHANGE_LEVEL_TOO_LOW_1 +
+                            JSON.stringify({
+                                mutation: "add",
+                                id: idPath.join("."),
+                                level: {
+                                    expected: minimumLevel,
+                                    actual: versionDiff,
+                                },
+                                version: {
+                                    current: in_version,
+                                    previous: in_versionPrevious,
+                                },
+                            }));
                         idPath.pop();
                     }
                 }
@@ -403,22 +411,23 @@ const _validatePositiveIncrement = function (in_template, in_templatePrevious, i
                 if (sourceObj !== targetObj) {
                     let minimumLevel = id === "value" ? "minor" : "major";
                     if (CHANGE_LEVEL[versionDiff] < CHANGE_LEVEL[minimumLevel]) {
-                        this._resultBuilder.addWarning(MSG.CHANGE_LEVEL_TOO_LOW_1 + JSON.stringify({
-                            mutation: "change",
-                            id: idPath.join("."),
-                            level: {
-                                expected: minimumLevel,
-                                actual: versionDiff,
-                            },
-                            value: {
-                                current: targetObj,
-                                previous: sourceObj,
-                            },
-                            version: {
-                                current: in_version,
-                                previous: in_versionPrevious,
-                            },
-                        }));
+                        this._resultBuilder.addWarning(MSG.CHANGE_LEVEL_TOO_LOW_1 +
+                            JSON.stringify({
+                                mutation: "change",
+                                id: idPath.join("."),
+                                level: {
+                                    expected: minimumLevel,
+                                    actual: versionDiff,
+                                },
+                                value: {
+                                    current: targetObj,
+                                    previous: sourceObj,
+                                },
+                                version: {
+                                    current: in_version,
+                                    previous: in_versionPrevious,
+                                },
+                            }));
                     }
                 }
             }
@@ -582,30 +591,36 @@ const _validateContextAsync = async function (in_template) {
             return Promise.reject(new Error(MSG.SET_ONLY_NAMED_PROPS));
         }
         // Since context is 'set' the template must eventually inherit from NamedProperty (same as above)
-        if (includes(in_template.inherits, "NamedProperty") || in_template.inherits === "NamedProperty") {
+        if (includes(in_template.inherits, "NamedProperty") ||
+            in_template.inherits === "NamedProperty") {
             return Promise.resolve();
         }
     }
     const typedValuePromise = Promise.all(typedValuePromises);
     let parents = [];
     if (in_template.inherits) {
-        parents = Array.isArray(in_template.inherits) ? in_template.inherits : [in_template.inherits];
+        parents = Array.isArray(in_template.inherits)
+            ? in_template.inherits
+            : [in_template.inherits];
     }
     const inheritsPromises = parents.map((typeid) => this._inheritsFromAsync(typeid, "NamedProperty"));
     // Combine results from inheritsPromises and typedValuePromise
     inheritsPromises.push(typedValuePromise);
-    return Promise.all(inheritsPromises).then(function (results) {
+    return Promise.all(inheritsPromises)
+        .then(function (results) {
         const foundNamedPropertyDescendant = find(results, (res) => res);
         if (!foundNamedPropertyDescendant) {
             return Promise.reject(Error(MSG.SET_ONLY_NAMED_PROPS));
         }
         return that._hasSchemaAsync(in_template.typeid);
-    }).then(function (hasIt) {
+    })
+        .then(function (hasIt) {
         if (!hasIt) {
             return Promise.reject(new Error(MSG.SET_ONLY_NAMED_PROPS));
         }
         return that._inheritsFromAsync(in_template.typeid, "NamedProperty");
-    }).then(async function (res) {
+    })
+        .then(async function (res) {
         if (res) {
             return undefined;
         }
@@ -656,13 +671,14 @@ const _processValidationResults = function (in_template) {
                         error.message = `typeid should have a pattern like: my.example:point-1.0.0 ${error.data} does not match that pattern`;
                     }
                     else if ("pattern" && regexTypeId.test(error.dataPath)) {
-                        error.message = error.schemaPath === "#/definitions/typed-reference-typeid/pattern"
-                            ? ""
-                            : `${error.dataPath} should follow this pattern: <namespace>:<typeid>-<version> ` +
-                                `(for example: Sample:Rectangle-1.0.0) or match one of the Primitive Types (Float32, Float64, ` +
-                                `Int8, Uint8, Int16, Uint16, Int32, Uint32, Bool, String, Reference, Enum, Int64, Uint64) or ` +
-                                `Reserved Types (BaseProperty, NamedProperty, NodeProperty, NamedNodeProperty, ` +
-                                `RelationshipProperty). '${error.data}' is not valid`;
+                        error.message =
+                            error.schemaPath === "#/definitions/typed-reference-typeid/pattern"
+                                ? ""
+                                : `${error.dataPath} should follow this pattern: <namespace>:<typeid>-<version> ` +
+                                    `(for example: Sample:Rectangle-1.0.0) or match one of the Primitive Types (Float32, Float64, ` +
+                                    `Int8, Uint8, Int16, Uint16, Int32, Uint32, Bool, String, Reference, Enum, Int64, Uint64) or ` +
+                                    `Reserved Types (BaseProperty, NamedProperty, NodeProperty, NamedNodeProperty, ` +
+                                    `RelationshipProperty). '${error.data}' is not valid`;
                     }
                     break;
                 case "enum":
@@ -728,9 +744,12 @@ const createContextCheckAsyncQueue = function () {
     const that = this;
     const contextCheckWorker = function (in_task, in_callback) {
         const property = in_task.property;
-        _validateContextAsync.call(that, property).then(function (response) {
+        _validateContextAsync
+            .call(that, property)
+            .then(function (response) {
             in_callback();
-        }).catch(function (error) {
+        })
+            .catch(function (error) {
             in_callback({ error });
         });
     };
@@ -794,11 +813,15 @@ export class TemplateValidator {
         this._skipSemver = in_params ? !!in_params.skipSemver : false;
         this._allowDraft = in_params ? !!in_params.allowDraft : false;
         // Used by validate()
-        if (in_params && in_params.inheritsFrom !== undefined && in_params.hasSchema !== undefined) {
+        if (in_params &&
+            in_params.inheritsFrom !== undefined &&
+            in_params.hasSchema !== undefined) {
             this._inheritsFrom = in_params.inheritsFrom;
             this._hasSchema = in_params.hasSchema;
         }
-        else if (in_params && in_params.inheritsFromAsync !== undefined && in_params.hasSchemaAsync !== undefined) {
+        else if (in_params &&
+            in_params.inheritsFromAsync !== undefined &&
+            in_params.hasSchemaAsync !== undefined) {
             this._inheritsFromAsync = in_params.inheritsFromAsync;
             this._hasSchemaAsync = in_params.hasSchemaAsync;
         }
@@ -847,7 +870,8 @@ export class TemplateValidator {
     validate(in_template, in_templatePrevious) {
         this._resultBuilder = new ValidationResultBuilder(in_template ? in_template.typeid : "");
         let isDraft = false;
-        if (in_template && in_template.typeid &&
+        if (in_template &&
+            in_template.typeid &&
             TypeIdHelper.extractVersion(in_template.typeid).version === "draft") {
             if (this._allowDraft) {
                 isDraft = true;
@@ -883,7 +907,9 @@ export class TemplateValidator {
         }
         // semver format validation
         const version = _validateSemverFormat.call(this, in_template);
-        const versionPrevious = in_templatePrevious ? _validateSemverFormat.call(this, in_templatePrevious) : null;
+        const versionPrevious = in_templatePrevious
+            ? _validateSemverFormat.call(this, in_templatePrevious)
+            : null;
         // semver format validation must pass.
         if (!this._resultBuilder.isValid()) {
             return this._resultBuilder.result;
@@ -901,10 +927,11 @@ export class TemplateValidator {
                 default:
                 case -1:
                     // previousVersion is greater. Violates rule 3b.
-                    this._resultBuilder.addError(new Error(MSG.VERSION_REGRESSION_1 + JSON.stringify({
-                        current: version,
-                        previous: versionPrevious,
-                    })));
+                    this._resultBuilder.addError(new Error(MSG.VERSION_REGRESSION_1 +
+                        JSON.stringify({
+                            current: version,
+                            previous: versionPrevious,
+                        })));
                     break;
             }
         }
@@ -957,9 +984,9 @@ export class TemplateValidator {
         if (!this._resultBuilder.isValid()) {
             return Promise.resolve(this._resultBuilder.result);
         }
-        return (in_templatePrevious) ?
-            this._validateAsyncWithPreviousSchema(in_template, in_templatePrevious) :
-            _validateSemanticAndSyntaxAsync.call(this, in_template);
+        return in_templatePrevious
+            ? this._validateAsyncWithPreviousSchema(in_template, in_templatePrevious)
+            : _validateSemanticAndSyntaxAsync.call(this, in_template);
     }
     /**
      * Called by validateAsync if a previous schema is passed in argument
@@ -972,7 +999,10 @@ export class TemplateValidator {
      */
     async _validateAsyncWithPreviousSchema(in_template, in_templatePrevious) {
         const that = this;
-        return _validateSemanticAndSyntaxAsync.call(that, in_template).then(() => _validateSemanticAndSyntaxAsync.call(that, in_templatePrevious)).then(function () {
+        return _validateSemanticAndSyntaxAsync
+            .call(that, in_template)
+            .then(() => _validateSemanticAndSyntaxAsync.call(that, in_templatePrevious))
+            .then(function () {
             if (!that._resultBuilder.isValid()) {
                 // Here the previous template is not valid. Make sure the typeid in the returned info is
                 // the root of the template that failed validation.
@@ -982,7 +1012,9 @@ export class TemplateValidator {
                 _validateSkipSemver.call(that, in_template, in_templatePrevious);
             }
             const version = _validateSemverFormat.call(that, in_template);
-            const versionPrevious = in_templatePrevious ? _validateSemverFormat.call(that, in_templatePrevious) : null;
+            const versionPrevious = in_templatePrevious
+                ? _validateSemverFormat.call(that, in_templatePrevious)
+                : null;
             // Validate that the semver change is valid.
             switch (compare(version, versionPrevious)) {
                 case 0:
@@ -995,10 +1027,11 @@ export class TemplateValidator {
                 default:
                 case -1:
                     // previousVersion is greater. Violates rule 3b.
-                    that._resultBuilder.addError(new Error(MSG.VERSION_REGRESSION_1 + JSON.stringify({
-                        current: version,
-                        previous: versionPrevious,
-                    })));
+                    that._resultBuilder.addError(new Error(MSG.VERSION_REGRESSION_1 +
+                        JSON.stringify({
+                            current: version,
+                            previous: versionPrevious,
+                        })));
                     break;
             }
             return that._resultBuilder.result;