@wise/dynamic-flow-client 3.9.2-experimental-535221d → 3.9.2

package/build/legacy/common/validators/schemas/schema-validators.js

@@ -1,101 +0,0 @@
-import { isListArraySchema } from '../../utils';
-import { isObject, isArray } from '../types/type-validators';
-import { getStringValidationFailures, getNumberValidationFailures, getIntegerValidationFailures, getBooleanValidationFailures, getConstValidationFailures, getArrayValidationFailures, getBlobValidationFailures, } from '../validationFailures/validation-failures';
-function isValidStringSchema(value, schema) {
-    return !getStringValidationFailures(value, schema).length;
-}
-function isValidNumberSchema(value, schema) {
-    return !getNumberValidationFailures(value, schema).length;
-}
-function isValidIntegerSchema(value, schema) {
-    return !getIntegerValidationFailures(value, schema).length;
-}
-function isValidBooleanSchema(value, schema) {
-    return !getBooleanValidationFailures(value, schema).length;
-}
-function isValidConstSchema(value, schema) {
-    return !getConstValidationFailures(value, schema).length;
-}
-function isValidObjectSchema(value, schema) {
-    if (!isObject(value) || schema.type !== 'object' || !isObject(schema.properties)) {
-        return false;
-    }
-    return Object.keys(schema.properties)
-        .map(function (propertyName) {
-        return isObjectPropertyValid(value[propertyName], schema.properties[propertyName], schema.required && schema.required.includes(propertyName));
-    })
-        .every(function (property) { return property; });
-}
-function isObjectPropertyValid(propertyValue, propertySchema, isRequired) {
-    if (propertySchema.hidden) {
-        return true;
-    }
-    if (typeof propertyValue === 'undefined') {
-        return !isRequired;
-    }
-    return isValidSchema(propertyValue, propertySchema);
-}
-function isValidArraySchema(value, schema) {
-    if (schema.type !== 'array' || !isObject(schema.items)) {
-        return false;
-    }
-    if (getArrayValidationFailures(value, schema).length > 0) {
-        return false;
-    }
-    return (Array.isArray(value) &&
-        isListArraySchema(schema) && // TupleArraySchema not yet supported
-        value.map(function (item) { return isValidSchema(item, schema.items); }).every(function (valid) { return valid; }));
-}
-function isValidOneOfSchema(value, schema) {
-    if (!isArray(schema.oneOf)) {
-        return false;
-    }
-    return schema.oneOf.some(function (childSchema) { return isValidSchema(value, childSchema); });
-}
-function isValidAllOfSchema(value, schema) {
-    if (!isArray(schema.allOf)) {
-        return false;
-    }
-    return schema.allOf
-        .map(function (childSchema) { return isValidSchema(value, childSchema); })
-        .every(function (valid) { return valid; });
-}
-function isValidBlobSchema(value, schema) {
-    return !getBlobValidationFailures(value, schema).length;
-}
-/**
- * Validate any value against a given schema
- *
- * @param value
- * @param schema
- */
-function isValidSchema(value, schema) {
-    if (schema.oneOf) {
-        return isValidOneOfSchema(value, schema);
-    }
-    if (schema.allOf) {
-        return isValidAllOfSchema(value, schema);
-    }
-    if (schema.const) {
-        return isValidConstSchema(value, schema);
-    }
-    switch (schema.type) {
-        case 'string':
-            return isValidStringSchema(value, schema);
-        case 'number':
-            return isValidNumberSchema(value, schema);
-        case 'integer':
-            return isValidIntegerSchema(value, schema);
-        case 'boolean':
-            return isValidBooleanSchema(value, schema);
-        case 'array':
-            return isValidArraySchema(value, schema);
-        case 'object':
-            return isValidObjectSchema(value, schema);
-        case 'blob':
-            return isValidBlobSchema(value, schema);
-        default:
-            return false;
-    }
-}
-export { isValidSchema };

package/build/legacy/common/validators/schemas/schema-validators.spec.js

@@ -1,157 +0,0 @@
-import { isValidSchema } from './schema-validators';
-describe('Given a library for validating json schema models', function () {
-    var schema;
-    describe('when validating an object schema', function () {
-        beforeEach(function () {
-            schema = {
-                type: 'object',
-                properties: {
-                    a: {
-                        type: 'number',
-                        minimum: 2,
-                    },
-                    b: {
-                        type: 'string',
-                        minLength: 3,
-                    },
-                    c: {
-                        const: true,
-                    },
-                },
-                required: ['a', 'c'],
-                displayOrder: ['a', 'b', 'c'],
-            };
-        });
-        it('should return false if the value is of an incorrect type', function () {
-            expect(isValidSchema([1], schema)).toBe(false);
-        });
-        it('should return false if a required property is missing', function () {
-            expect(isValidSchema({}, schema)).toBe(false);
-        });
-        it('should return false is a required property does not validate', function () {
-            expect(isValidSchema({ a: 1, c: true }, schema)).toBe(false);
-        });
-        it('should return false if an optional property is invalid', function () {
-            expect(isValidSchema({ a: 2, b: 'c', c: true }, schema)).toBe(false);
-        });
-        it('should return true if required properties validate and non-required fields are missing', function () {
-            expect(isValidSchema({ a: 2, c: true }, schema)).toBe(true);
-        });
-        it('should return true if all properties validate', function () {
-            expect(isValidSchema({ a: 2, b: 'cde', c: true }, schema)).toBe(true);
-        });
-    });
-    describe('when validating an array schema', function () {
-        beforeEach(function () {
-            schema = {
-                type: 'array',
-                addItemTitle: '',
-                editItemTitle: '',
-                items: {
-                    type: 'string',
-                    minLength: 2,
-                },
-                minItems: 2,
-                maxItems: 2,
-            };
-        });
-        it('should return false if not an array', function () {
-            expect(isValidSchema({ a: 1 }, schema)).toBe(false);
-        });
-        it('should return false if the array is too small', function () {
-            expect(isValidSchema(['ab'], schema)).toBe(false);
-        });
-        it('should return false if the array is too long', function () {
-            expect(isValidSchema(['ab', 'cd', 'ef'], schema)).toBe(false);
-        });
-        it('should return false if any of the items do not validate', function () {
-            expect(isValidSchema(['ab', 'c'], schema)).toBe(false);
-        });
-        it('should return true is the array is correct size and items are valid', function () {
-            expect(isValidSchema(['ab', 'cd'], schema)).toBe(true);
-        });
-    });
-    describe('when validating a oneOf schema', function () {
-        beforeEach(function () {
-            schema = {
-                oneOf: [
-                    {
-                        type: 'string',
-                        minLength: 2,
-                    },
-                    {
-                        type: 'number',
-                        minimum: 2,
-                    },
-                ],
-            };
-        });
-        it('should return false if neither schema validates', function () {
-            expect(isValidSchema(true, schema)).toBe(false);
-            expect(isValidSchema('a', schema)).toBe(false);
-            expect(isValidSchema(1, schema)).toBe(false);
-        });
-        it('should return true if either schema validates', function () {
-            expect(isValidSchema('ab', schema)).toBe(true);
-            expect(isValidSchema(2, schema)).toBe(true);
-        });
-    });
-    describe('when validating an allOf schema', function () {
-        beforeEach(function () {
-            schema = {
-                allOf: [
-                    {
-                        type: 'object',
-                        properties: {
-                            a: {
-                                type: 'string',
-                                minLength: 2,
-                            },
-                        },
-                        displayOrder: ['a'],
-                        required: ['a'],
-                    },
-                    {
-                        type: 'object',
-                        properties: {
-                            b: {
-                                type: 'number',
-                                minimum: 2,
-                            },
-                        },
-                        displayOrder: ['b'],
-                        required: ['b'],
-                    },
-                ],
-            };
-        });
-        it('should return false if only one schema is present', function () {
-            expect(isValidSchema({ a: 'bc' }, schema)).toBe(false);
-            expect(isValidSchema({ b: 2 }, schema)).toBe(false);
-        });
-        it('should return false if any schemas are invalid', function () {
-            expect(isValidSchema({ a: 'bc', b: 1 }, schema)).toBe(false);
-        });
-        it('should return true if both schemas validate', function () {
-            expect(isValidSchema({ a: 'bc', b: 2 }, schema)).toBe(true);
-        });
-    });
-    describe('when validating a hidden required schema', function () {
-        var schema = {
-            type: 'object',
-            properties: {
-                a: {
-                    hidden: true,
-                    type: 'number',
-                    minimum: 2,
-                },
-            },
-            required: ['a'],
-            displayOrder: ['a'],
-        };
-        it('should return true for both valid and invalid schemas', function () {
-            expect(isValidSchema({ a: 3 }, schema)).toBe(true);
-            expect(isValidSchema({}, schema)).toBe(true);
-        });
-    });
-});

package/build/legacy/common/validators/types/type-validators.js

@@ -1,14 +0,0 @@
-export var isString = function (value) { return typeof value === 'string'; };
-export var isNumber = function (value) {
-    return typeof value === 'number' && !Number.isNaN(value);
-};
-export var isInteger = function (value) {
-    return isNumber(value) && Math.floor(value) === value;
-};
-export var isBoolean = function (value) { return typeof value === 'boolean'; };
-export var isObject = function (value) {
-    return !isNull(value) && !isUndefined(value) && (value === null || value === void 0 ? void 0 : value.constructor) === Object;
-};
-export var isArray = function (value) { return Array.isArray(value); };
-export var isNull = function (value) { return value === null; };
-export var isUndefined = function (value) { return typeof value === 'undefined'; };

package/build/legacy/common/validators/types/type-validators.spec.js

@@ -1,147 +0,0 @@
-import { isString, isNumber, isInteger, isBoolean, isArray, isObject, isNull, isUndefined, } from './type-validators';
-describe('type-validators', function () {
-    describe('isString', function () {
-        it('should return true when the value is a string', function () {
-            expect(isString('a')).toBe(true);
-            expect(isString('')).toBe(true);
-        });
-        it('should return false when the value is a different primitive types', function () {
-            expect(isString(1)).toBe(false);
-            expect(isString(true)).toBe(false);
-            expect(isString(undefined)).toBe(false);
-            expect(isString(null)).toBe(false);
-            expect(isString(NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', function () {
-            expect(isString([])).toBe(false);
-            expect(isString({})).toBe(false);
-        });
-    });
-    describe('isNumber', function () {
-        it('should return true when the value is a number', function () {
-            expect(isNumber(1)).toBe(true);
-            expect(isNumber(0)).toBe(true);
-            expect(isNumber(1.23)).toBe(true);
-            expect(isNumber(-1)).toBe(true);
-        });
-        it('should return false when the value is a different primitive type', function () {
-            expect(isNumber('a')).toBe(false);
-            expect(isNumber(true)).toBe(false);
-            expect(isNumber(undefined)).toBe(false);
-            expect(isNumber(null)).toBe(false);
-            expect(isNumber(NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', function () {
-            expect(isNumber([])).toBe(false);
-            expect(isNumber({})).toBe(false);
-        });
-    });
-    describe('isInteger', function () {
-        it('should return true when the value is a integer', function () {
-            expect(isInteger(1)).toBe(true);
-            expect(isInteger(0)).toBe(true);
-            expect(isInteger(-1)).toBe(true);
-        });
-        it('should return false when the value is a float', function () {
-            expect(isInteger(1.23)).toBe(false);
-        });
-        it('should return false when the value is a different primitive type', function () {
-            expect(isInteger('a')).toBe(false);
-            expect(isInteger(true)).toBe(false);
-            expect(isInteger(undefined)).toBe(false);
-            expect(isInteger(null)).toBe(false);
-            expect(isInteger(NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', function () {
-            expect(isInteger([])).toBe(false);
-            expect(isInteger({})).toBe(false);
-        });
-    });
-    describe('isBoolean', function () {
-        it('should return true when the value is a boolean', function () {
-            expect(isBoolean(true)).toBe(true);
-            expect(isBoolean(false)).toBe(true);
-        });
-        it('should return false when the value is a different primitive type', function () {
-            expect(isBoolean(1)).toBe(false);
-            expect(isBoolean('a')).toBe(false);
-            expect(isBoolean(undefined)).toBe(false);
-            expect(isBoolean(null)).toBe(false);
-            expect(isBoolean(NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', function () {
-            expect(isBoolean([])).toBe(false);
-            expect(isBoolean({})).toBe(false);
-        });
-    });
-    describe('isArray', function () {
-        it('should return true when the value is an array', function () {
-            expect(isArray([1])).toBe(true);
-            expect(isArray([])).toBe(true);
-        });
-        it('should return false when the value is null or undefined', function () {
-            expect(isArray(undefined)).toBe(false);
-            expect(isArray(null)).toBe(false);
-        });
-        it('should return false when the value is a different primitive type', function () {
-            expect(isArray(1)).toBe(false);
-            expect(isArray('a')).toBe(false);
-            expect(isArray(true)).toBe(false);
-            expect(isArray(NaN)).toBe(false);
-        });
-        it('should return false when the value is an object', function () {
-            expect(isArray({})).toBe(false);
-        });
-    });
-    describe('isObject', function () {
-        it('should return true when the value is an object', function () {
-            expect(isObject({ a: 1 })).toBe(true);
-            expect(isObject({})).toBe(true);
-        });
-        it('should return false when the value is an array', function () {
-            expect(isObject([])).toBe(false);
-        });
-        it('should return false when the value is a primitive', function () {
-            expect(isObject(1)).toBe(false);
-            expect(isObject('a')).toBe(false);
-            expect(isObject(true)).toBe(false);
-            expect(isObject(NaN)).toBe(false);
-        });
-        it('should return false when the value is null or undefined', function () {
-            expect(isObject(undefined)).toBe(false);
-            expect(isObject(null)).toBe(false);
-        });
-    });
-    describe('isNull', function () {
-        it('should return true when the value is null', function () {
-            expect(isNull(null)).toBe(true);
-        });
-        it('should return false when the value is undefined', function () {
-            expect(isNull(undefined)).toBe(false);
-        });
-        it('should return false when the value is a primitive', function () {
-            expect(isNull(0)).toBe(false);
-            expect(isNull(false)).toBe(false);
-            expect(isNull(NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', function () {
-            expect(isNull([])).toBe(false);
-            expect(isNull({})).toBe(false);
-        });
-    });
-    describe('isUndefined', function () {
-        it('should return true when the value is undefined', function () {
-            expect(isUndefined(undefined)).toBe(true);
-        });
-        it('should return false when the value is a primitive', function () {
-            expect(isUndefined(0)).toBe(false);
-            expect(isUndefined(false)).toBe(false);
-            expect(isUndefined(null)).toBe(false);
-            expect(isUndefined(NaN)).toBe(false);
-        });
-        it('should return false when the value is a complex type', function () {
-            expect(isNull([])).toBe(false);
-            expect(isNull({})).toBe(false);
-        });
-    });
-});

package/build/legacy/common/validators/validationFailures/validation-failures.js

@@ -1,139 +0,0 @@
-import { isEqual, isObjectModel, isStringSchema } from '../../utils';
-import { isArray, isString, isNumber, isInteger, isBoolean, isNull, } from '../types/type-validators';
-import { isValidRequired, isValidMinLength, isValidMaxLength, isValidPattern, isValidMaximum, isValidMinimum, isValidMinItems, isValidMaxItems, isValidRequiredArray, } from './validation-failures.utils';
-function getValidationFailures(value, schema, isRequired) {
-    if (schema.const) {
-        return getConstValidationFailures(value, schema, isRequired);
-    }
-    if (isNull(value)) {
-        return isRequired ? ['required'] : [];
-    }
-    if (isStringSchema(schema)) {
-        return getStringValidationFailures(value, schema, isRequired);
-    }
-    switch (schema.type) {
-        case 'number':
-            return getNumberValidationFailures(value, schema, isRequired);
-        case 'integer':
-            return getIntegerValidationFailures(value, schema, isRequired);
-        case 'boolean':
-            return getBooleanValidationFailures(value, schema, isRequired);
-        case 'array':
-            return getArrayValidationFailures(value, schema, isRequired);
-        case 'object':
-            return getObjectValidationFailures(value, schema);
-        default:
-            return [];
-    }
-}
-function getStringValidationFailures(value, schema, isRequired) {
-    if (!isString(value) && !isNull(value)) {
-        return ['type'];
-    }
-    if (value === '' && isRequired) {
-        return ['required'];
-    }
-    var failures = [];
-    if (!isValidRequired(value, isRequired)) {
-        failures.push('required');
-    }
-    if (!isValidMinLength(value, schema.minLength)) {
-        failures.push('minLength');
-    }
-    if (!isValidMaxLength(value, schema.maxLength)) {
-        failures.push('maxLength');
-    }
-    if (!isValidPattern(value, schema.pattern)) {
-        failures.push('pattern');
-    }
-    if (!isValidMinimum(value, schema.minimum)) {
-        failures.push('minimum');
-    }
-    if (!isValidMaximum(value, schema.maximum)) {
-        failures.push('maximum');
-    }
-    return failures;
-}
-function getNumberValidationFailures(value, schema, isRequired) {
-    if (!isNumber(value) && !isNull(value)) {
-        return ['type'];
-    }
-    var failures = [];
-    if (!isValidRequired(value, isRequired)) {
-        failures.push('required');
-    }
-    if (!isValidMinimum(value, schema.minimum)) {
-        failures.push('minimum');
-    }
-    if (!isValidMaximum(value, schema.maximum)) {
-        failures.push('maximum');
-    }
-    return failures;
-}
-function getIntegerValidationFailures(value, schema, isRequired) {
-    if (!isInteger(value)) {
-        return ['type'];
-    }
-    return getNumberValidationFailures(value, schema, isRequired);
-}
-function getBooleanValidationFailures(value, _schema, isRequired) {
-    if (!isBoolean(value) && !isNull(value)) {
-        return ['type'];
-    }
-    var failures = [];
-    if (!isValidRequired(value, isRequired)) {
-        failures.push('required');
-    }
-    return failures;
-}
-function getConstValidationFailures(value, schema, isRequired) {
-    if (!isValidRequired(value, isRequired)) {
-        return ['required'];
-    }
-    if (!isEqual(value, schema.const)) {
-        return ['const'];
-    }
-    return [];
-}
-function getArrayValidationFailures(value, schema, isRequired) {
-    if (!isArray(value) && !isNull(value)) {
-        return ['type'];
-    }
-    if (!isValidRequiredArray(value, isRequired)) {
-        return ['required'];
-    }
-    var failures = [];
-    if (!isValidMinItems(value, schema.minItems)) {
-        failures.push('minItems');
-    }
-    if (!isValidMaxItems(value, schema.maxItems)) {
-        failures.push('maxItems');
-    }
-    return failures;
-}
-function getBlobValidationFailures(value, _schema) {
-    if (isNull(value)) {
-        return ['type'];
-    }
-    return [];
-}
-/**
- * When validating an object we only checking that it is an object and that it
- * has the required properties, we do not check if the properties are valid.
- *
- * @param value
- * @param schema
- */
-function getObjectValidationFailures(value, schema) {
-    if (!isObjectModel(value)) {
-        return ['type'];
-    }
-    if (!isArray(schema.required)) {
-        return [];
-    }
-    var allPresent = schema.required
-        .map(function (property) { return typeof value[property] !== 'undefined'; })
-        .reduce(function (propertyInModel, validSoFar) { return propertyInModel && validSoFar; }, true);
-    return allPresent ? [] : ['required'];
-}
-export { getValidationFailures, getStringValidationFailures, getNumberValidationFailures, getIntegerValidationFailures, getBooleanValidationFailures, getConstValidationFailures, getArrayValidationFailures, getObjectValidationFailures, getBlobValidationFailures, };