@hestia-earth/schema-validation 37.0.0 → 37.2.0

package/esm/index.js

@@ -0,0 +1,2 @@
+export * from './validate';
+export * from './validate-jsonld';

package/esm/validate-jsonld.js

@@ -0,0 +1,56 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { readdirSync, readFileSync, lstatSync } from 'fs';
+import { join } from 'path';
+import { validator } from './validate';
+const [folder, strictMode] = process.argv.slice(2);
+const domain = 'https://www.hestia.earth';
+const loadFile = (filename) => JSON.parse(readFileSync(filename, 'utf8'));
+const extensions = ['jsonld', 'json', 'hestia'];
+const findFiles = (directory) => readdirSync(directory)
+    .map(path => {
+    const isDirectory = lstatSync(join(directory, path)).isDirectory();
+    return isDirectory
+        ? findFiles(join(directory, path))
+        : extensions.includes(path.split('.')[1])
+            ? join(directory, path)
+            : null;
+})
+    .flat()
+    .filter(Boolean);
+export const run = () => __awaiter(void 0, void 0, void 0, function* () {
+    const contentValidator = validator(domain, strictMode === 'true');
+    const jsonldFiles = findFiles(folder);
+    const results = [];
+    for (const filepath of jsonldFiles) {
+        console.log('Validating', filepath);
+        const content = loadFile(filepath);
+        const nodes = (Array.isArray(content) ? content : 'nodes' in content ? content.nodes : [content])
+            .map(node => (node['@type'] || node.type ? node : null))
+            .filter(Boolean);
+        const allErrors = [];
+        for (const node of nodes) {
+            const { errors } = yield contentValidator(node);
+            allErrors.push(errors);
+        }
+        const success = !allErrors.some(v => v.length);
+        if (!success) {
+            results.push({
+                filepath,
+                success,
+                errors: allErrors
+            });
+        }
+    }
+    if (results.length) {
+        results.map(value => console.error(JSON.stringify(value, null, 2)));
+        throw new Error('Validation errors: see above for more details');
+    }
+});

package/esm/validate.js

@@ -0,0 +1,82 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as Ajv from 'ajv';
+import { isTypeNode } from '@hestia-earth/schema';
+import { loadSchemas } from '@hestia-earth/json-schema';
+import { init as initValidators } from './validators';
+const draft4 = require('ajv/lib/refs/json-schema-draft-04.json');
+const existingNodeRequired = Object.freeze({ required: ['@id', '@type'] });
+const validateSchemaType = (schemas, content) => {
+    const type = content['@type'] || content.type;
+    if (!(type in schemas)) {
+        throw new Error(`Unknown or invalid type "${type}"`);
+    }
+    return true;
+};
+const schemaData = ({ required, properties }) => (Object.assign(Object.assign({}, ((required === null || required === void 0 ? void 0 : required.length) ? { required } : {})), (properties ? { properties } : {})));
+// using `verbose: true` includes data which we don't need
+const cleanErrors = (errors) => errors.map((_a) => {
+    var { data, schema, parentSchema } = _a, error = __rest(_a, ["data", "schema", "parentSchema"]);
+    return (Object.assign(Object.assign(Object.assign({}, error), (schema ? { schema: schemaData(schema) } : {})), (error.message === 'should NOT be valid' ? { schema } : {})));
+});
+/**
+ * Validate a single node. Function is asynchronous to return a list of `success` and a list of `errors`.
+ *
+ * @param ajv The AJV object. Use `initAjv()` or pass your own.
+ * @param schemas The schema definitions. Use `loadSchemas` from `@hestia-earth/json-schema`  or pass your own.
+ * @returns
+ */
+export const validateContent = (ajv, schemas) => (content) => __awaiter(void 0, void 0, void 0, function* () {
+    return validateSchemaType(schemas, content) && {
+        success: yield ajv.validate(schemas[content['@type'] || content.type], content),
+        errors: cleanErrors(ajv.errors || [])
+    };
+});
+export const initAjv = () => {
+    const ajv = new Ajv({
+        schemaId: 'auto',
+        allErrors: true,
+        verbose: true
+    });
+    ajv.addMetaSchema(draft4);
+    initValidators(ajv);
+    return ajv;
+};
+/**
+ * Create a validator instance. Call with a Node to validate it.
+ *
+ * @param domain The domain of the validator (defaults to Hestia's website)
+ * @param strictMode Allow validating non-existing nodes, i.e. without unique `@id`.
+ * @returns Function to validate a Node. Use `await validator()(node)`
+ */
+export const validator = (domain = 'https://www.hestia.earth', strictMode = true) => {
+    const ajv = initAjv();
+    const schemas = loadSchemas();
+    Object.keys(schemas).map(schemaName => {
+        const schema = schemas[schemaName];
+        schema.properties = Object.assign({ '@context': {
+                type: 'string'
+            } }, schema.properties);
+        schema.oneOf = strictMode && isTypeNode(schemaName) ? [existingNodeRequired] : schema.oneOf;
+        ajv.addSchema(schema, `${domain}/schema/json-schema/${schemaName}#`);
+    });
+    return validateContent(ajv, schemas);
+};

package/esm/validators/arraySameSize.js

@@ -0,0 +1,27 @@
+export const keyword = 'arraySameSize';
+export const validate = (schema, data, _parentSchema, dataPath, parentData) => {
+    const current = data.length;
+    const errors = schema
+        .filter(key => key in parentData)
+        .map(key => {
+        const expected = parentData[key].length;
+        return current !== expected
+            ? {
+                dataPath,
+                keyword,
+                schemaPath: '#/invalid',
+                message: `must contain as many items as ${key}s`,
+                params: { keyword, current, expected }
+            }
+            : null;
+    })
+        .filter(Boolean);
+    // only return the first 100 errors to limit the memory footprint
+    validate.errors = errors.slice(0, 100);
+    return errors.length === 0;
+};
+export const init = (ajv) => ajv.addKeyword(keyword, {
+    type: 'array',
+    errors: 'full',
+    validate
+});

package/esm/validators/datePattern.js

@@ -0,0 +1,57 @@
+const formatDate = (date) => new Date(`${new Date(date).toJSON().substring(0, 10)}T12:00:00.000Z`);
+const validLength = (value, length) => !value || value.length === length;
+/**
+ * JavaScript does a lenient parsing of dates, so even `2000-30-30` will return a date.
+ * This makes sure the parse date is the date as the given date.
+ *
+ * @param value
+ * @returns
+ */
+const isValidDateRange = (value) => {
+    const values = value.substring(0, 10).split('-');
+    const year = Number(values[0]) || 1970;
+    const month = Number(values[1]) || 1;
+    const day = Number(values[2]) || 1;
+    const date = new Date(year, month - 1, day, 12); // Months are 0-indexed
+    return [
+        validLength(values[0], 4),
+        validLength(values[1], 2),
+        validLength(values[2], 2),
+        date.getFullYear() === year,
+        date.getMonth() === month - 1,
+        date.getDate() === day
+    ].every(Boolean);
+};
+export const isFutureDate = (date) => formatDate(date) > formatDate(new Date());
+export const isValidDate = (date, withTime = true) => (date.length <= 10 || withTime) && isFinite(new Date(date).getTime()) && isValidDateRange(date);
+export const keyword = 'datePattern';
+export const validate = (_schema, value, _parentSchema, dataPath) => {
+    const values = Array.isArray(value) ? value : [value];
+    const errors = values
+        .map((v, index) => isValidDate(v, false)
+        ? isFutureDate(v)
+            ? {
+                dataPath: `${dataPath}${Array.isArray(value) ? `[${index}]` : ''}`,
+                keyword,
+                schemaPath: '#/invalid',
+                message: 'date cannot be in the future',
+                params: {}
+            }
+            : null
+        : {
+            dataPath: `${dataPath}${Array.isArray(value) ? `[${index}]` : ''}`,
+            keyword,
+            schemaPath: '#/invalid',
+            message: 'not a valid date',
+            params: {}
+        })
+        .filter(Boolean);
+    // only return the first 10 errors to limit the memory footprint
+    validate.errors = errors.slice(0, 10);
+    return errors.length === 0;
+};
+export const init = (ajv) => ajv.addKeyword(keyword, {
+    type: ['string', 'array'],
+    errors: 'full',
+    validate
+});

package/esm/validators/dateTimePattern.js

@@ -0,0 +1,32 @@
+import { isValidDate, isFutureDate } from './datePattern';
+export const keyword = 'dateTimePattern';
+export const validate = (_schema, value, _parentSchema, dataPath) => {
+    const values = Array.isArray(value) ? value : [value];
+    const errors = values
+        .map((v, index) => isValidDate(v)
+        ? isFutureDate(v)
+            ? {
+                dataPath: `${dataPath}${Array.isArray(value) ? `[${index}]` : ''}`,
+                keyword,
+                schemaPath: '#/invalid',
+                message: 'date cannot be in the future',
+                params: {}
+            }
+            : null
+        : {
+            dataPath: `${dataPath}${Array.isArray(value) ? `[${index}]` : ''}`,
+            keyword,
+            schemaPath: '#/invalid',
+            message: 'not a valid date',
+            params: {}
+        })
+        .filter(Boolean);
+    // only return the first 10 errors to limit the memory footprint
+    validate.errors = errors.slice(0, 10);
+    return errors.length === 0;
+};
+export const init = (ajv) => ajv.addKeyword(keyword, {
+    type: ['string', 'array'],
+    errors: 'full',
+    validate
+});

package/esm/validators/geojson.js

@@ -0,0 +1,28 @@
+import * as gjv from 'geojson-validation';
+export const keyword = 'geojson';
+const invalidCoordinatesError = 'invalid coordinates';
+const maxLongitude = 180;
+const maxLatitude = 90;
+gjv.define('Position', ([longitude, latitude]) => [longitude < maxLongitude, longitude > -maxLongitude, latitude < maxLatitude, latitude > -maxLatitude].every(Boolean) || [invalidCoordinatesError]);
+export const validate = (_schema, value, _parentSchema, dataPath) => {
+    const validationErrors = gjv.valid(value, true);
+    const isInvalidCoordinates = validationErrors.every(error => error.includes(invalidCoordinatesError));
+    const errors = [
+        validationErrors.length === 0
+            ? null
+            : {
+                dataPath,
+                keyword,
+                schemaPath: '#/invalid',
+                message: 'not a valid GeoJSON',
+                params: Object.assign({}, (isInvalidCoordinates ? { invalidCoordinates: true } : {}))
+            }
+    ].filter(Boolean);
+    validate.errors = errors;
+    return validationErrors.length === 0;
+};
+export const init = (ajv) => ajv.addKeyword(keyword, {
+    type: 'object',
+    errors: 'full',
+    validate
+});

package/esm/validators/index.js

@@ -0,0 +1,21 @@
+import { keyword as arraySameSize, init as arraySameSizeInit } from './arraySameSize';
+import { keyword as datePattern, init as datePatternInit } from './datePattern';
+import { keyword as dateTimePattern, init as dateTimePatternInit } from './dateTimePattern';
+import { keyword as geojson, init as geojsonInit } from './geojson';
+import { keyword as matrixSameSize, init as matrixSameSizeInit } from './matrixSameSize';
+import { keyword as sumIs100, init as sumIs100Init } from './sumIs100';
+import { keyword as sumMax100, init as sumMax100Init } from './sumMax100';
+import { keyword as uniqueArrayItem, init as uniqueArrayItemInit } from './uniqueArrayItem';
+import { keyword as uniquePrimaryItem, init as uniquePrimaryItemInit } from './uniquePrimaryItem';
+export { arraySameSize, datePattern, dateTimePattern, geojson, matrixSameSize, sumIs100, sumMax100, uniqueArrayItem, uniquePrimaryItem };
+export const init = (ajv) => {
+    arraySameSizeInit(ajv);
+    datePatternInit(ajv);
+    dateTimePatternInit(ajv);
+    geojsonInit(ajv);
+    matrixSameSizeInit(ajv);
+    sumIs100Init(ajv);
+    sumMax100Init(ajv);
+    uniqueArrayItemInit(ajv);
+    uniquePrimaryItemInit(ajv);
+};

package/esm/validators/matrixSameSize.js

@@ -0,0 +1,23 @@
+export const keyword = 'matrixSameSize';
+export const validate = (schema, data, _parentSchema, dataPath, parentData) => {
+    const matrixFields = parentData[schema];
+    const matrixLength = matrixFields.length;
+    const isLengthCorrect = data.length === matrixLength && data.every(value => value.length === matrixLength);
+    validate.errors = [
+        isLengthCorrect
+            ? null
+            : {
+                dataPath,
+                keyword,
+                schemaPath: '#/invalid',
+                message: `must contain as many items as ${schema}`,
+                params: { keyword, expected: matrixLength }
+            }
+    ].filter(Boolean);
+    return validate.errors.length === 0;
+};
+export const init = (ajv) => ajv.addKeyword(keyword, {
+    type: 'array',
+    errors: 'full',
+    validate
+});

package/esm/validators/sumIs100.js

@@ -0,0 +1,25 @@
+export const keyword = 'sumIs100';
+const parseValue = (value) => (typeof value === 'string' || typeof value == 'number' ? +value : 0);
+export const validate = (schema, data, _parentSchema, dataPath = '') => {
+    const totals = Object.fromEntries(schema.map(key => [schema, data.reduce((prev, item) => prev + parseValue(item[key]), -1)]));
+    validate.errors = Object.entries(totals)
+        .map(([key, total]) => total === -1 || (total >= 98 && total <= 100)
+        ? null
+        : {
+            dataPath,
+            keyword,
+            schemaPath: '#/invalid',
+            message: `sum of ${key} must be 100`,
+            params: {
+                current: total + 1,
+                expected: 100
+            }
+        })
+        .filter(Boolean);
+    return validate.errors.length === 0;
+};
+export const init = (ajv) => ajv.addKeyword(keyword, {
+    type: 'array',
+    errors: 'full',
+    validate
+});

package/esm/validators/sumMax100.js

@@ -0,0 +1,25 @@
+export const keyword = 'sumMax100';
+const parseValue = (value) => (typeof value === 'string' || typeof value == 'number' ? +value : 0);
+export const validate = (schema, data, _parentSchema, dataPath = '') => {
+    const totals = Object.fromEntries(schema.map(key => [schema, data.reduce((prev, item) => prev + parseValue(item[key]), 0)]));
+    validate.errors = Object.entries(totals)
+        .map(([key, total]) => total <= 100
+        ? null
+        : {
+            dataPath,
+            keyword,
+            schemaPath: '#/invalid',
+            message: `sum of ${key} must be 100`,
+            params: {
+                current: total,
+                expected: 100
+            }
+        })
+        .filter(Boolean);
+    return validate.errors.length === 0;
+};
+export const init = (ajv) => ajv.addKeyword(keyword, {
+    type: 'array',
+    errors: 'full',
+    validate
+});

package/esm/validators/uniqueArrayItem.js

@@ -0,0 +1,43 @@
+const getByKey = (prev, curr) => !curr || !prev
+    ? prev
+    : Array.isArray(prev)
+        ? prev.map(item => getItemValue(item, curr))
+        : prev
+            ? prev[curr]
+            : undefined;
+const getItemValue = (item, key) => key.split('.').reduce(getByKey, item);
+export const keyword = 'uniqueArrayItem';
+const findIdenticalIndexes = (values) => (value, index) => ({
+    index,
+    duplicatedIndexes: values
+        .map((otherValue, otherIndex) => [otherValue, otherIndex])
+        .filter(([otherValue, otherIndex]) => otherIndex !== index && otherValue === value)
+        .map(([_otherValue, otherIndex]) => otherIndex)
+});
+/**
+ * Make sure empty JSON are not set as `'{}'`.
+ *
+ * @param value
+ * @returns
+ */
+const toString = (value) => Object.values(value).filter(Boolean).length ? JSON.stringify(value) : null;
+export const validate = (schema, data, _parentSchema, dataPath = '') => {
+    const values = data.map(item => toString(schema.reduce((prev, key) => (Object.assign(Object.assign({}, prev), { [key]: getItemValue(item, key) })), {}))).filter(Boolean);
+    const indexes = values
+        .map(findIdenticalIndexes(values))
+        .filter(({ duplicatedIndexes }) => duplicatedIndexes.length > 0)
+        .sort();
+    validate.errors = indexes.map(({ index, duplicatedIndexes }) => ({
+        dataPath: `${dataPath}[${index}]`,
+        keyword,
+        schemaPath: '#/invalid',
+        message: 'every item in the list should be unique',
+        params: { keyword, keys: schema, duplicatedIndexes }
+    }));
+    return indexes.length === 0;
+};
+export const init = (ajv) => ajv.addKeyword(keyword, {
+    type: 'array',
+    errors: 'full',
+    validate
+});

package/esm/validators/uniquePrimaryItem.js

@@ -0,0 +1,24 @@
+export const keyword = 'uniquePrimaryItem';
+export const validate = (schema, data, _parentSchema, dataPath = '') => {
+    const primaryCount = data.filter(item => item.primary === true).length;
+    const errors = primaryCount <= 1
+        ? []
+        : data
+            .map((v, index) => v.primary !== true
+            ? null
+            : {
+                dataPath: `${dataPath}[${index}]`,
+                keyword,
+                schemaPath: '#/invalid',
+                message: 'can only contain one primary item',
+                params: {}
+            })
+            .filter(Boolean);
+    validate.errors = errors;
+    return errors.length === 0;
+};
+export const init = (ajv) => ajv.addKeyword(keyword, {
+    type: 'array',
+    errors: 'full',
+    validate
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hestia-earth/schema-validation",
-  "version": "37.0.0",
+  "version": "37.2.0",
   "description": "HESTIA Schema Validation",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -28,5 +28,21 @@
     "@hestia-earth/json-schema": "*",
     "ajv": "^6.12.6",
     "geojson-validation": "^1.0.2"
+  },
+  "sideEffects": false,
+  "module": "esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./index.js"
+    },
+    "./validate-jsonld": {
+      "import": "./esm/validate-jsonld.js",
+      "require": "./validate-jsonld.js"
+    },
+    "./validate": {
+      "import": "./esm/validate.js",
+      "require": "./validate.js"
+    }
   }
 }