structured-elements/dist/validate/element.js

A TypeScript package for modelling and validating data

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateElement = void 0;
const elementPath_1 = require("../build/elementPath");
const failureReport_1 = require("../build/failureReport");
const referencedValidator_1 = require("../ensure/referencedValidator");
const array_1 = require("../is/array");
const date_1 = require("../is/date");
const recordSchema_1 = require("../is/recordSchema");
const referenceContainer_1 = require("../is/referenceContainer");
const stringKeyedRecord_1 = require("../is/stringKeyedRecord");
// This function validates an element against an expectation.
const validateElement = ({ api, element, expectation, key, subject, subjectName, elementName = (0, elementPath_1.buildElementPath)({ key, path: subjectName }), }) => {
    const failures = [];
    const expectations = (0, array_1.isArray)(expectation) ? expectation : [expectation];
    const elementValid = expectations.some((possibility) => {
        if (typeof possibility === `function`) {
            if (possibility(element) === true) {
                return true;
            }
            failures.push({
                element,
                expectation: possibility,
                key,
                name: elementName,
                reason: `${key}: functional expectation did not return true.`,
                subject,
            });
            return false;
        }
        if (typeof possibility === `string`) {
            const model = api.registeredModels().get(possibility);
            if (model) {
                const modelValidator = model.validators()[`item`];
                const modelFailures = modelValidator.getFailures(element, elementName);
                if (modelValidator.isValid(element, elementName)) {
                    return true;
                }
                failures.push({
                    element,
                    expectation,
                    failures: modelFailures,
                    key,
                    name: elementName,
                    reason: (0, failureReport_1.buildFailureReport)({
                        api,
                        element,
                        expectation,
                        failures: modelFailures,
                        path: key.toString(),
                    }),
                    subject,
                });
                return false;
            }
            if (possibility === `date`) {
                if ((0, date_1.isDate)(element)) {
                    return true;
                }
                failures.push({
                    element,
                    expectation,
                    key,
                    name: elementName,
                    reason: `${key}: expected a Date, got ${typeof element}`,
                    subject,
                });
                return false;
            }
            if (typeof element === possibility) {
                return true;
            }
            failures.push({
                element,
                expectation,
                key,
                name: elementName,
                reason: `${key}: expected typeof ${possibility}, got ${typeof element}`,
                subject,
            });
            return false;
        }
        if (possibility === null) {
            if (element === null) {
                return true;
            }
            failures.push({
                element,
                expectation,
                key,
                name: elementName,
                reason: `${key} is not null`,
                subject,
            });
            return false;
        }
        if (possibility === undefined) {
            if (element === undefined) {
                return true;
            }
            failures.push({
                element,
                expectation,
                key,
                name: elementName,
                reason: `${key} is not undefined`,
                subject,
            });
            return false;
        }
        if ((0, referenceContainer_1.isReferenceContainer)(api, possibility)) {
            const referencedValidator = (0, referencedValidator_1.ensureReferencedValidator)({
                api,
                container: possibility,
            });
            if (referencedValidator.isValid(element, elementName)) {
                return true;
            }
            const elementFailures = referencedValidator.getFailures(element, elementName);
            failures.push({
                element,
                expectation,
                failures: elementFailures,
                key,
                name: elementName,
                reason: (0, failureReport_1.buildFailureReport)({
                    api,
                    element,
                    expectation,
                    failures: elementFailures,
                    path: key.toString(),
                }),
                subject,
            });
            return false;
        }
        if ((0, recordSchema_1.isRecordSchema)(api, possibility)) {
            const recordValidator = api.validator(possibility, `item`);
            if (recordValidator.isValid(element, elementName)) {
                return true;
            }
            const recordFailures = recordValidator.getFailures(element, elementName);
            failures.push({
                element,
                expectation,
                failures: recordFailures,
                key,
                name: elementName,
                reason: (0, failureReport_1.buildFailureReport)({
                    api,
                    element,
                    expectation,
                    failures: recordFailures,
                    path: key.toString(),
                }),
                subject,
            });
            return false;
        }
        if (api.debugEnabled()) {
            api.privateFunctions.debug(`validateElement did not know how to validate subject:`, {
                expectations,
                elementName,
                name: subjectName,
                possibility,
                subject,
            }, {
                recordSchema: (0, recordSchema_1.isRecordSchema)(api, possibility),
                stringKeyedRecord: (0, stringKeyedRecord_1.isStringKeyedRecord)(possibility),
            });
        }
        return false;
    });
    if (elementValid) {
        return [];
    }
    return failures;
};
exports.validateElement = validateElement;
//# sourceMappingURL=element.js.map