@hestia-earth/schema-validation 22.4.0 → 23.1.0

package/package.json

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

package/validate.d.ts

@@ -12,10 +12,6 @@ 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;
-declare function arraySameSizeValidate(keys: string[], items: any[], _schema: any, dataPath: string, item: any): boolean;
-declare function datePatternValidate(_enabled: boolean, value: string | string[], _schema: any, dataPath: string): boolean;
-export { uniqueArrayItemValidate, arraySameSizeValidate, datePatternValidate };
 export declare const initAjv: () => Ajv.Ajv;
 /**
  * Create a validator instance. Call with a Node to validate it.

package/validate.js

@@ -47,10 +47,11 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validator = exports.initAjv = exports.datePatternValidate = exports.arraySameSizeValidate = exports.uniqueArrayItemValidate = exports.validateContent = void 0;
+exports.validator = exports.initAjv = exports.validateContent = void 0;
 var Ajv = require("ajv");
 var schema_1 = require("@hestia-earth/schema");
 var json_schema_1 = require("@hestia-earth/json-schema");
+var validators_1 = require("./validators");
 var geojsonSchema = 'http://json.schemastore.org/geojson';
 var existingNodeRequired = Object.freeze({ required: ['@id', '@type'] });
 var validateSchemaType = function (schemas, content) {
@@ -87,66 +88,6 @@ var validateContent = function (ajv, schemas) { return function (content) { retu
     });
 }); }; };
 exports.validateContent = validateContent;
-var getByKey = function (prev, curr) { return !curr || !prev ? prev : (Array.isArray(prev) ? prev.map(function (item) { return getItemValue(item, curr); }) : (prev ? prev[curr] : undefined)); };
-var getItemValue = function (item, key) {
-    return key.split('.').reduce(getByKey, item);
-};
-var uniqueArrayItemKeyword = 'uniqueArrayItem';
-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;
-        return (__assign(__assign({}, prev), (_a = {}, _a[key] = getItemValue(item, key), _a)));
-    }, {})); });
-    var indexes = values
-        .map(function (value, index) { return values.findIndex(function (otherValue, otherValueIndex) {
-        return otherValueIndex !== index && otherValue === value;
-    }); })
-        .filter(function (index) { return index >= 0; })
-        .sort();
-    uniqueArrayItemValidate.errors = indexes.map(function (index) { return ({
-        dataPath: "".concat(dataPath, "[").concat(index, "]"),
-        keyword: uniqueArrayItemKeyword,
-        message: 'every item in the list should be unique',
-        params: { keyword: uniqueArrayItemKeyword, keys: keys }
-    }); });
-    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 ".concat(key, "s"),
-            params: { keyword: arraySameSizeKeyword, current: current, expected: expected }
-        } : null;
-    })
-        .filter(Boolean);
-    arraySameSizeValidate.errors = errors;
-    return errors.length === 0;
-}
-exports.arraySameSizeValidate = arraySameSizeValidate;
-var datePatternKeyword = 'datePattern';
-var isValidDate = function (date) { return isFinite(new Date(date).getTime()); };
-function datePatternValidate(_enabled, value, _schema, dataPath) {
-    var values = Array.isArray(value) ? value : [value];
-    var errors = values
-        .map(function (v, index) { return isValidDate(v) ? null : {
-        dataPath: "".concat(dataPath).concat(Array.isArray(value) ? "[".concat(index, "]") : ''),
-        keyword: datePatternKeyword,
-        message: 'not a valid date'
-    }; })
-        .filter(Boolean);
-    datePatternValidate.errors = errors;
-    return errors.length === 0;
-}
-exports.datePatternValidate = datePatternValidate;
 var initAjv = function () {
     var ajv = new Ajv({
         schemaId: 'auto',
@@ -154,21 +95,7 @@ var initAjv = function () {
     });
     ajv.addMetaSchema(require('ajv/lib/refs/json-schema-draft-04.json'));
     ajv.addSchema(require('./json-schema/geojson.json'), geojsonSchema);
-    ajv.addKeyword(uniqueArrayItemKeyword, {
-        type: 'array',
-        errors: 'full',
-        validate: uniqueArrayItemValidate
-    });
-    ajv.addKeyword(arraySameSizeKeyword, {
-        type: 'array',
-        errors: 'full',
-        validate: arraySameSizeValidate
-    });
-    ajv.addKeyword(datePatternKeyword, {
-        type: ['string', 'array'],
-        errors: 'full',
-        validate: datePatternValidate
-    });
+    (0, validators_1.init)(ajv);
     return ajv;
 };
 exports.initAjv = initAjv;

package/validators/arraySameSize.d.ts

@@ -0,0 +1,2 @@
+export declare const keyword = "arraySameSize";
+export declare function arraySameSizeValidate(keys: string[], items: any[], _schema: any, dataPath: string, item: any): boolean;

package/validators/arraySameSize.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arraySameSizeValidate = exports.keyword = void 0;
+exports.keyword = '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: exports.keyword,
+            message: "must contain as many items as ".concat(key, "s"),
+            params: { keyword: exports.keyword, current: current, expected: expected }
+        } : null;
+    })
+        .filter(Boolean);
+    arraySameSizeValidate.errors = errors;
+    return errors.length === 0;
+}
+exports.arraySameSizeValidate = arraySameSizeValidate;

package/validators/datePattern.d.ts

@@ -0,0 +1,2 @@
+export declare const keyword = "datePattern";
+export declare function datePatternValidate(_enabled: boolean, value: string | string[], _schema: any, dataPath: string): boolean;

package/validators/datePattern.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.datePatternValidate = exports.keyword = void 0;
+var isValidDate = function (date) { return isFinite(new Date(date).getTime()); };
+exports.keyword = 'datePattern';
+function datePatternValidate(_enabled, value, _schema, dataPath) {
+    var values = Array.isArray(value) ? value : [value];
+    var errors = values
+        .map(function (v, index) { return isValidDate(v) ? null : {
+        dataPath: "".concat(dataPath).concat(Array.isArray(value) ? "[".concat(index, "]") : ''),
+        keyword: exports.keyword,
+        message: 'not a valid date'
+    }; })
+        .filter(Boolean);
+    datePatternValidate.errors = errors;
+    return errors.length === 0;
+}
+exports.datePatternValidate = datePatternValidate;

package/validators/index.d.ts

@@ -0,0 +1,2 @@
+import { Ajv } from 'ajv';
+export declare const init: (ajv: Ajv) => void;

package/validators/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+var arraySameSize_1 = require("./arraySameSize");
+var datePattern_1 = require("./datePattern");
+var uniqueArrayItem_1 = require("./uniqueArrayItem");
+var init = function (ajv) {
+    ajv.addKeyword(arraySameSize_1.keyword, {
+        type: 'array',
+        errors: 'full',
+        validate: arraySameSize_1.arraySameSizeValidate
+    });
+    ajv.addKeyword(datePattern_1.keyword, {
+        type: ['string', 'array'],
+        errors: 'full',
+        validate: datePattern_1.datePatternValidate
+    });
+    ajv.addKeyword(uniqueArrayItem_1.keyword, {
+        type: 'array',
+        errors: 'full',
+        validate: uniqueArrayItem_1.uniqueArrayItemValidate
+    });
+};
+exports.init = init;

package/validators/uniqueArrayItem.d.ts

@@ -0,0 +1,2 @@
+export declare const keyword = "uniqueArrayItem";
+export declare function uniqueArrayItemValidate(keys: string[], items: any[], _schema?: any, dataPath?: string): boolean;

package/validators/uniqueArrayItem.js

@@ -0,0 +1,40 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueArrayItemValidate = exports.keyword = void 0;
+var getByKey = function (prev, curr) { return !curr || !prev ? prev : (Array.isArray(prev) ? prev.map(function (item) { return getItemValue(item, curr); }) : (prev ? prev[curr] : undefined)); };
+var getItemValue = function (item, key) {
+    return key.split('.').reduce(getByKey, item);
+};
+exports.keyword = 'uniqueArrayItem';
+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;
+        return (__assign(__assign({}, prev), (_a = {}, _a[key] = getItemValue(item, key), _a)));
+    }, {})); });
+    var indexes = values
+        .map(function (value, index) { return values.findIndex(function (otherValue, otherValueIndex) {
+        return otherValueIndex !== index && otherValue === value;
+    }); })
+        .filter(function (index) { return index >= 0; })
+        .sort();
+    uniqueArrayItemValidate.errors = indexes.map(function (index) { return ({
+        dataPath: "".concat(dataPath, "[").concat(index, "]"),
+        keyword: exports.keyword,
+        message: 'every item in the list should be unique',
+        params: { keyword: exports.keyword, keys: keys }
+    }); });
+    return indexes.length === 0;
+}
+exports.uniqueArrayItemValidate = uniqueArrayItemValidate;