@hestia-earth/schema-validation 7.6.6 → 7.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hestia-earth/schema-validation",
-  "version": "7.6.6",
+  "version": "7.7.0",
   "description": "Hestia Schema Validation",
   "main": "index.js",
   "typings": "index.d.ts",

package/validate-jsonld.js

@@ -51,6 +51,17 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.run = void 0;
 var fs_1 = require("fs");
@@ -72,43 +83,64 @@ var findFiles = function (directory) { return fs_1.readdirSync(directory)
     .flat()
     .filter(Boolean); };
 exports.run = function () { return __awaiter(void 0, void 0, void 0, function () {
-    var contentValidator, jsonldFiles, results;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
+    var contentValidator, jsonldFiles, results, jsonldFiles_1, jsonldFiles_1_1, filepath, content, nodes, allErrors, success, e_1_1;
+    var e_1, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
             case 0:
                 contentValidator = validate_1.validator(domain, strictMode === 'true');
                 jsonldFiles = findFiles(folder);
-                return [4 /*yield*/, Promise.all(jsonldFiles.map(function (filepath) { return __awaiter(void 0, void 0, void 0, function () {
-                        var content, nodes, allErrors;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    content = loadFile(filepath);
-                                    nodes = Array.isArray(content) ? content : ('nodes' in content ? content.nodes : [content]);
-                                    return [4 /*yield*/, Promise.all(nodes
-                                            .map(function (node) { return node['@type'] || node.type ? node : null; })
-                                            .filter(Boolean)
-                                            .map(contentValidator))];
-                                case 1:
-                                    allErrors = (_a.sent())
-                                        .map(function (_a) {
-                                        var errors = _a.errors;
-                                        return errors;
-                                    });
-                                    return [2 /*return*/, {
-                                            filepath: filepath,
-                                            success: !allErrors.some(function (v) { return v.length; }),
-                                            errors: allErrors
-                                        }];
-                            }
-                        });
-                    }); }))];
+                results = [];
+                _b.label = 1;
             case 1:
-                results = (_a.sent())
-                    .filter(function (_a) {
-                    var success = _a.success;
-                    return !success;
+                _b.trys.push([1, 6, 7, 8]);
+                jsonldFiles_1 = __values(jsonldFiles), jsonldFiles_1_1 = jsonldFiles_1.next();
+                _b.label = 2;
+            case 2:
+                if (!!jsonldFiles_1_1.done) return [3 /*break*/, 5];
+                filepath = jsonldFiles_1_1.value;
+                console.log('Validating', filepath);
+                content = loadFile(filepath);
+                nodes = Array.isArray(content) ? content : ('nodes' in content ? content.nodes : [content]);
+                return [4 /*yield*/, Promise.all(nodes
+                        .map(function (node) { return node['@type'] || node.type ? node : null; })
+                        .filter(Boolean)
+                        .map(function (content) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, contentValidator(content)];
+                            case 1: return [2 /*return*/, _a.sent()];
+                        }
+                    }); }); }))];
+            case 3:
+                allErrors = (_b.sent())
+                    .map(function (_a) {
+                    var errors = _a.errors;
+                    return errors;
                 });
+                success = !allErrors.some(function (v) { return v.length; });
+                if (!success) {
+                    results.push({
+                        filepath: filepath,
+                        success: success,
+                        errors: allErrors
+                    });
+                }
+                _b.label = 4;
+            case 4:
+                jsonldFiles_1_1 = jsonldFiles_1.next();
+                return [3 /*break*/, 2];
+            case 5: return [3 /*break*/, 8];
+            case 6:
+                e_1_1 = _b.sent();
+                e_1 = { error: e_1_1 };
+                return [3 /*break*/, 8];
+            case 7:
+                try {
+                    if (jsonldFiles_1_1 && !jsonldFiles_1_1.done && (_a = jsonldFiles_1.return)) _a.call(jsonldFiles_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+                return [7 /*endfinally*/];
+            case 8:
                 if (results.length) {
                     throw new Error("Validation errors: " + JSON.stringify(results, null, 2));
                 }

package/validate.d.ts

@@ -12,8 +12,9 @@ export declare const validateContent: (ajv: Ajv.Ajv, schemas: definitions) => (c
     success: any;
     errors: Ajv.ErrorObject[];
 }>;
-declare function uniqueArrayItemValidate(keys: string[], items: any[], schema?: any, dataPath?: string): boolean;
-export { uniqueArrayItemValidate };
+declare function uniqueArrayItemValidate(keys: string[], items: any[], _schema?: any, dataPath?: string): boolean;
+declare function arraySameSizeValidate(keys: string[], items: any[], _schema: any, dataPath: any, item: any): boolean;
+export { uniqueArrayItemValidate, arraySameSizeValidate };
 export declare const initAjv: () => Ajv.Ajv;
 /**
  * Create a validator instance. Call with a Node to validate it.

package/validate.js

@@ -47,7 +47,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validator = exports.initAjv = exports.uniqueArrayItemValidate = exports.validateContent = void 0;
+exports.validator = exports.initAjv = exports.arraySameSizeValidate = exports.uniqueArrayItemValidate = exports.validateContent = void 0;
 var Ajv = require("ajv");
 var schema_1 = require("@hestia-earth/schema");
 var json_schema_1 = require("@hestia-earth/json-schema");
@@ -90,7 +90,7 @@ var getItemValue = function (item, key) {
     return key.split('.').reduce(getByKey, item);
 };
 var uniqueArrayItemKeyword = 'uniqueArrayItem';
-function uniqueArrayItemValidate(keys, items, schema, dataPath) {
+function uniqueArrayItemValidate(keys, items, _schema, dataPath) {
     if (dataPath === void 0) { dataPath = ''; }
     var values = items.map(function (item) { return JSON.stringify(keys.reduce(function (prev, key) {
         var _a;
@@ -111,6 +111,25 @@ function uniqueArrayItemValidate(keys, items, schema, dataPath) {
     return indexes.length === 0;
 }
 exports.uniqueArrayItemValidate = uniqueArrayItemValidate;
+var arraySameSizeKeyword = 'arraySameSize';
+function arraySameSizeValidate(keys, items, _schema, dataPath, item) {
+    var current = items.length;
+    var errors = keys
+        .filter(function (key) { return key in item; })
+        .map(function (key) {
+        var expected = item[key].length;
+        return current !== expected ? {
+            dataPath: dataPath,
+            keyword: arraySameSizeKeyword,
+            message: "must contain as many items as " + key + "s",
+            params: { keyword: arraySameSizeKeyword, current: current, expected: expected }
+        } : null;
+    })
+        .filter(Boolean);
+    arraySameSizeValidate.errors = errors;
+    return errors.length === 0;
+}
+exports.arraySameSizeValidate = arraySameSizeValidate;
 exports.initAjv = function () {
     var ajv = new Ajv({
         schemaId: 'auto',
@@ -123,6 +142,11 @@ exports.initAjv = function () {
         errors: 'full',
         validate: uniqueArrayItemValidate
     });
+    ajv.addKeyword(arraySameSizeKeyword, {
+        type: 'array',
+        errors: 'full',
+        validate: arraySameSizeValidate
+    });
     return ajv;
 };
 /**