@hello.nrfcloud.com/proto-map 4.0.0

package/dist/models/asset_tracker_v2+AWS/examples/examples.spec.js

@@ -0,0 +1,489 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { describe, it } from "node:test";
+import { senMLtoLwM2M } from "../../../senml/senMLtoLwM2M.js";
+import { TransformType } from "../../types.js";
+import jsonata from "jsonata";
+import { arrayContaining, check } from "tsmatchers";
+import { models } from "../../../models/models.js";
+void describe("asset_tracker_v2+AWS examples", function() {
+    var _loop = function(_i, _iter) {
+        var _iter__i = _sliced_to_array(_iter[_i], 2), input = _iter__i[0], expected = _iter__i[1];
+        void it(input, /*#__PURE__*/ _async_to_generator(function() {
+            var _models_asset_tracker_v2AWS, _models_asset_tracker_v2AWS_transforms, result, _, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, expectedObject;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _ = transformShadowUpdateToLwM2M(((_models_asset_tracker_v2AWS_transforms = (_models_asset_tracker_v2AWS = models["asset_tracker_v2+AWS"]) === null || _models_asset_tracker_v2AWS === void 0 ? void 0 : _models_asset_tracker_v2AWS.transforms) !== null && _models_asset_tracker_v2AWS_transforms !== void 0 ? _models_asset_tracker_v2AWS_transforms : []).filter(function(param) {
+                            var type = param.type;
+                            return type === TransformType.Shadow;
+                        }));
+                        return [
+                            4,
+                            import(input, {
+                                assert: {
+                                    type: "json"
+                                }
+                            })
+                        ];
+                    case 1:
+                        return [
+                            4,
+                            _.apply(void 0, [
+                                _state.sent()
+                            ])
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        try {
+                            for(_iterator = expected[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                expectedObject = _step.value;
+                                check(result).is(arrayContaining(expectedObject));
+                            }
+                        } catch (err) {
+                            _didIteratorError = true;
+                            _iteratorError = err;
+                        } finally{
+                            try {
+                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                    _iterator.return();
+                                }
+                            } finally{
+                                if (_didIteratorError) {
+                                    throw _iteratorError;
+                                }
+                            }
+                        }
+                        return [
+                            2
+                        ];
+                }
+            });
+        }));
+    };
+    for(var _i = 0, _iter = [
+        [
+            "./shadow/example-1.json",
+            [
+                {
+                    ObjectID: 14202,
+                    Resources: {
+                        1: 4.398,
+                        99: new Date(1699050063028)
+                    }
+                },
+                {
+                    ObjectID: 14205,
+                    Resources: {
+                        0: 27.06,
+                        1: 31.125,
+                        2: 97.748,
+                        99: new Date(1699050061608)
+                    }
+                },
+                {
+                    ObjectID: 14203,
+                    Resources: {
+                        11: 8,
+                        99: new Date(1699050062990)
+                    }
+                }
+            ]
+        ],
+        [
+            "./shadow/example-2.json",
+            [
+                {
+                    ObjectID: 14201,
+                    Resources: {
+                        0: 33.98771459323253,
+                        1: -84.50632147267358,
+                        2: 241.9342498779297,
+                        3: 11.317643165588379,
+                        4: 0.03478508070111275,
+                        5: 90.31222534179688,
+                        6: "GNSS",
+                        99: new Date(1699049744000)
+                    }
+                },
+                {
+                    ObjectID: 14202,
+                    Resources: {
+                        1: 4.414,
+                        99: new Date(1699049729959)
+                    }
+                },
+                {
+                    ObjectID: 14205,
+                    Resources: {
+                        0: 21.915307998657227,
+                        1: 34.569278717041016,
+                        2: 98.846,
+                        10: 148,
+                        99: new Date(1699049729518)
+                    }
+                }
+            ]
+        ],
+        [
+            "./shadow/example-3.json",
+            [
+                {
+                    ObjectID: 14203,
+                    Resources: {
+                        2: -95,
+                        11: 7,
+                        99: new Date(1699049610301)
+                    }
+                }
+            ]
+        ],
+        [
+            "./shadow/example-4.json",
+            [
+                {
+                    ObjectID: 14204,
+                    Resources: {
+                        0: "358299840016535",
+                        1: "89450421180216254864",
+                        2: "mfw_nrf91x1_2.0.0-77.beta",
+                        3: "0.0.0-development",
+                        4: "thingy91x_nrf9161",
+                        99: new Date(1699284007851)
+                    }
+                },
+                {
+                    ObjectID: 14202,
+                    Resources: {
+                        0: 99,
+                        1: 4.179,
+                        2: 0,
+                        3: 25.7,
+                        99: new Date(1699049685992)
+                    }
+                }
+            ]
+        ],
+        [
+            "./shadow/example-5.json",
+            [
+                {
+                    ObjectID: 14202,
+                    Resources: {
+                        0: 89,
+                        1: 4.161,
+                        99: new Date(1701900277007)
+                    }
+                }
+            ]
+        ]
+    ]; _i < _iter.length; _i++)_loop(_i, _iter);
+});
+/**
+ * Very simple implementation of a converter.
+ */ var transformShadowUpdateToLwM2M = function(transforms) {
+    // Turn the JSONata in the transforms into executable functions
+    var transformFns = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = transforms[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _step.value, matchExpression = _step_value.match, transformExpression = _step_value.transform;
+            var match = void 0;
+            var transform = void 0;
+            try {
+                match = jsonata(matchExpression);
+            } catch (e) {
+                throw new Error("Failed to parse match expression '".concat(matchExpression, "'"));
+            }
+            try {
+                transform = jsonata(transformExpression);
+            } catch (e) {
+                throw new Error("Failed to parse match expression '".concat(transformExpression, "'"));
+            }
+            transformFns.push({
+                match: match,
+                matchExpression: matchExpression,
+                transform: transform,
+                transformExpression: transformExpression
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return function() {
+        var _ref = _async_to_generator(function(input) {
+            return _ts_generator(this, function(_state) {
+                return [
+                    2,
+                    Promise.all(transformFns.map(function() {
+                        var _ref = _async_to_generator(function(param) {
+                            var match, matchExpression, transform, transformExpression, matched, err, err1;
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        match = param.match, matchExpression = param.matchExpression, transform = param.transform, transformExpression = param.transformExpression;
+                                        _state.label = 1;
+                                    case 1:
+                                        _state.trys.push([
+                                            1,
+                                            3,
+                                            ,
+                                            4
+                                        ]);
+                                        return [
+                                            4,
+                                            match.evaluate(input)
+                                        ];
+                                    case 2:
+                                        matched = _state.sent();
+                                        if (typeof matched !== "boolean") return [
+                                            2,
+                                            null
+                                        ];
+                                        if (matched === false) return [
+                                            2,
+                                            null
+                                        ];
+                                        return [
+                                            3,
+                                            4
+                                        ];
+                                    case 3:
+                                        err = _state.sent();
+                                        console.error(err);
+                                        console.error("Failed to match ".concat(JSON.stringify(input), " using expression '").concat(matchExpression, "'!"));
+                                        return [
+                                            2,
+                                            false
+                                        ];
+                                    case 4:
+                                        _state.trys.push([
+                                            4,
+                                            6,
+                                            ,
+                                            7
+                                        ]);
+                                        return [
+                                            4,
+                                            transform.evaluate(input)
+                                        ];
+                                    case 5:
+                                        return [
+                                            2,
+                                            _state.sent()
+                                        ];
+                                    case 6:
+                                        err1 = _state.sent();
+                                        console.error(err1);
+                                        console.error("Failed to transform ".concat(JSON.stringify(input), " using expression '").concat(transformExpression, "'!"));
+                                        return [
+                                            2,
+                                            null
+                                        ];
+                                    case 7:
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        });
+                        return function(_) {
+                            return _ref.apply(this, arguments);
+                        };
+                    }())).then(function(result) {
+                        return result.flat();
+                    })// Ignore unmatched transforms
+                    .then(function(result) {
+                        return result.filter(function(item) {
+                            return item !== null;
+                        });
+                    })// Convert it to LwM2M
+                    .then(senMLtoLwM2M)
+                ];
+            });
+        });
+        return function(input) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+};

package/dist/models/check-model-rules.js

@@ -0,0 +1,137 @@
+import chalk from "chalk";
+import jsonata from "jsonata";
+import assert from "node:assert/strict";
+import { readFile, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { FrontMatter, ModelIDRegExp } from "./types.js";
+import { senMLtoLwM2M } from "../senml/senMLtoLwM2M.js";
+import { getCodeBlock } from "../markdown/getCodeBlock.js";
+import { getFrontMatter } from "../markdown/getFrontMatter.js";
+import { validateSenML } from "../senml/validateSenML.js";
+import { isRegisteredLwM2MObject } from "../lwm2m/isRegisteredLwM2MObject.js";
+import { hasValue } from "../senml/hasValue.js";
+import { parseREADME } from "markdown/parseREADME.js";
+console.log(chalk.gray("Models rules check"));
+console.log("");
+var modelsDir = path.join(process.cwd(), "models");
+var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+try {
+    for(var _iterator = (await readdir(modelsDir))[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+        var model = _step.value;
+        var modelDir = path.join(modelsDir, model);
+        if (!(await stat(modelDir)).isDirectory()) continue;
+        console.log(chalk.white("\xb7"), chalk.white.bold(model));
+        assert.match(model, ModelIDRegExp, "Model identifiers must consist of numbers, letters, dash, plus, and underscore only");
+        console.log(chalk.green("✔"), chalk.gray("Model name is correct"));
+        // A README.md should exist
+        try {
+            await stat(path.join(modelDir, "README.md"));
+        } catch (e) {
+            throw new Error("No README.md defined for model ".concat(model, "!"));
+        }
+        console.log(chalk.green("✔"), chalk.gray("README.md exists"));
+        try {
+            parseREADME(await readFile(path.join(modelDir, "README.md"), "utf-8"));
+        } catch (err) {
+            console.error(err);
+            throw new Error("README is not valid for ".concat(model, "!"));
+        }
+        console.log(chalk.green("✔"), chalk.gray("README.md is valid"));
+        // Validate jsonata expressions
+        var hasTransforms = false;
+        var transformsFolder = path.join(modelDir, "transforms");
+        try {
+            await stat(transformsFolder);
+            hasTransforms = true;
+            console.log(" ", chalk.gray("Transforms:"));
+        } catch (e) {
+            console.log(" ", chalk.gray("No transforms found."));
+        }
+        if (hasTransforms) {
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = (await readdir(transformsFolder)).filter(function(f) {
+                    return f.endsWith(".md");
+                })[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var transform = _step1.value;
+                    console.log(" ", chalk.white("\xb7"), chalk.white.bold(transform));
+                    var markdown = await readFile(path.join(modelDir, "transforms", transform), "utf-8");
+                    // Validate front-matter
+                    var type = getFrontMatter(markdown, FrontMatter).type;
+                    console.log(" ", chalk.green("✔"), chalk.gray("Type ".concat(type, " is valid")));
+                    var findBlock = getCodeBlock(markdown);
+                    var matchExpression = findBlock("jsonata", "Match Expression");
+                    var transformExpression = findBlock("jsonata", "Transform Expression");
+                    var inputExample = JSON.parse(findBlock("json", "Input Example"));
+                    var resultExample = JSON.parse(findBlock("json", "Result Example"));
+                    var selectResult = await jsonata(matchExpression).evaluate(inputExample);
+                    if (selectResult !== true) {
+                        throw new Error("The select expression did not evaluate to true with the given example.");
+                    }
+                    console.log(" ", chalk.green("✔"), chalk.gray("Select expression evaluated to true for the example input"));
+                    var transformResult = await jsonata(// For testing purposes this function call result is hardcoded
+                    transformExpression.replace("$millis()", "1699999999999")).evaluate(inputExample);
+                    var maybeValidSenML = validateSenML(transformResult.filter(hasValue));
+                    if ("errors" in maybeValidSenML) {
+                        console.error(maybeValidSenML.errors);
+                        throw new Error("The JSONata expression must produce valid SenML");
+                    }
+                    assert.deepEqual(maybeValidSenML.value, resultExample);
+                    console.log(" ", chalk.green("✔"), chalk.gray("Transformation result is valid SenML"));
+                    assert.deepEqual(maybeValidSenML.value, resultExample);
+                    console.log(" ", chalk.green("✔"), chalk.gray("The transformation result matches the example"));
+                    var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                    try {
+                        // Validate
+                        for(var _iterator2 = senMLtoLwM2M(maybeValidSenML.value)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                            var object = _step2.value;
+                            if (!isRegisteredLwM2MObject(object, console.error)) {
+                                throw new Error("The LwM2M object must follow LwM2M schema definition");
+                            }
+                            console.log(" ", chalk.green("✔"), chalk.gray("SenML object is valid LwM2M"));
+                        }
+                    } catch (err) {
+                        _didIteratorError2 = true;
+                        _iteratorError2 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                _iterator2.return();
+                            }
+                        } finally{
+                            if (_didIteratorError2) {
+                                throw _iteratorError2;
+                            }
+                        }
+                    }
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+        }
+    }
+} catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+} finally{
+    try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
+        }
+    } finally{
+        if (_didIteratorError) {
+            throw _iteratorError;
+        }
+    }
+}