@wise/dynamic-flow-client 3.11.3 → 3.11.4-experiment-node20-aa45bc2

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

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,157 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,139 @@
+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, };