@wise/dynamic-flow-client 0.1.1 → 0.1.3

package/build/common/validation/valid-model/spec.js

@@ -0,0 +1,605 @@
+import { getValidModelParts } from '.';
+describe('Given a library for returning the valid parts of a model based on a schema', function () {
+    describe('when cleaning a string schema', function () {
+        var schema = { type: 'string' };
+        describe('with a string model', function () {
+            it('should return the original string', function () {
+                var result = getValidModelParts('string', schema);
+                expect(result).toBe('string');
+            });
+        });
+        describe('with a non string model', function () {
+            it('should return null', function () {
+                expect(getValidModelParts(null, schema)).toBeNull();
+                expect(getValidModelParts(123, schema)).toBeNull();
+                expect(getValidModelParts(true, schema)).toBeNull();
+                expect(getValidModelParts(false, schema)).toBeNull();
+                expect(getValidModelParts([123, 456], schema)).toBeNull();
+                expect(getValidModelParts(['a', 'b'], schema)).toBeNull();
+                expect(getValidModelParts([true, false], schema)).toBeNull();
+                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
+            });
+        });
+    });
+    describe('when cleaning a number schema', function () {
+        var schema = { type: 'number' };
+        describe('with an integer model', function () {
+            it('should return the original integer', function () {
+                var result = getValidModelParts(12345, schema);
+                expect(result).toBe(12345);
+            });
+        });
+        describe('with any float model', function () {
+            it('should return the original model', function () {
+                var result = getValidModelParts(12.34, schema);
+                expect(result).toBe(12.34);
+            });
+        });
+        describe('with any non number model', function () {
+            it('should return null', function () {
+                expect(getValidModelParts(null, schema)).toBeNull();
+                expect(getValidModelParts('abc', schema)).toBeNull();
+                expect(getValidModelParts(true, schema)).toBeNull();
+                expect(getValidModelParts(false, schema)).toBeNull();
+                expect(getValidModelParts([123, 456], schema)).toBeNull();
+                expect(getValidModelParts(['a', 'b'], schema)).toBeNull();
+                expect(getValidModelParts([true, false], schema)).toBeNull();
+                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
+            });
+        });
+    });
+    describe('when cleaning an integer schema', function () {
+        var schema = { type: 'integer' };
+        describe('with an integer model', function () {
+            it('should return the original integer', function () {
+                var result = getValidModelParts(12345, schema);
+                expect(result).toBe(12345);
+            });
+        });
+        describe('with any float model', function () {
+            it('should return the original model', function () {
+                var result = getValidModelParts(12.34, schema);
+                expect(result).toBe(12.34);
+            });
+        });
+        describe('with any non number model', function () {
+            it('should return null', function () {
+                expect(getValidModelParts(null, schema)).toBeNull();
+                expect(getValidModelParts('abc', schema)).toBeNull();
+                expect(getValidModelParts(true, schema)).toBeNull();
+                expect(getValidModelParts(false, schema)).toBeNull();
+                expect(getValidModelParts([123, 456], schema)).toBeNull();
+                expect(getValidModelParts(['a', 'b'], schema)).toBeNull();
+                expect(getValidModelParts([true, false], schema)).toBeNull();
+                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
+            });
+        });
+    });
+    describe('when cleaning a boolean schema', function () {
+        var schema = { type: 'boolean' };
+        describe('with a boolean model', function () {
+            it('should return the original boolean', function () {
+                expect(getValidModelParts(true, schema)).toBe(true);
+                expect(getValidModelParts(false, schema)).toBe(false);
+            });
+        });
+        describe('with any non boolean model', function () {
+            it('should return null', function () {
+                expect(getValidModelParts(null, schema)).toBeNull();
+                expect(getValidModelParts('abc', schema)).toBeNull();
+                expect(getValidModelParts(123, schema)).toBeNull();
+                expect(getValidModelParts([123, 456], schema)).toBeNull();
+                expect(getValidModelParts(['a', 'b'], schema)).toBeNull();
+                expect(getValidModelParts([true, false], schema)).toBeNull();
+                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
+            });
+        });
+    });
+    describe('when cleaning a const schema', function () {
+        describe('when the const is a number', function () {
+            var schema = { "const": 1 };
+            describe('if the model matches the const', function () {
+                it('should return the original model', function () {
+                    var result = getValidModelParts(1, schema);
+                    expect(result).toBe(1);
+                });
+            });
+            describe('if the model does not match the const', function () {
+                it('should return null', function () {
+                    expect(getValidModelParts(2, schema)).toBeNull();
+                    expect(getValidModelParts(null, schema)).toBeNull();
+                    expect(getValidModelParts('abc', schema)).toBeNull();
+                    expect(getValidModelParts(true, schema)).toBeNull();
+                    expect(getValidModelParts(false, schema)).toBeNull();
+                    expect(getValidModelParts([123, 456], schema)).toBeNull();
+                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
+                    expect(getValidModelParts([true, false], schema)).toBeNull();
+                    expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
+                });
+            });
+            describe('if the const evaluates to false', function () {
+                it('should still return matches', function () {
+                    var result = getValidModelParts(0, { "const": 0 });
+                    expect(result).toBe(0);
+                });
+            });
+        });
+        describe('when the const is a string', function () {
+            var schema = { "const": 'one' };
+            describe('if the model matches the const', function () {
+                it('should return the original model', function () {
+                    var result = getValidModelParts('one', schema);
+                    expect(result).toBe('one');
+                });
+            });
+            describe('if the model does not match the const', function () {
+                it('should return null', function () {
+                    expect(getValidModelParts('two', schema)).toBeNull();
+                    expect(getValidModelParts(null, schema)).toBeNull();
+                    expect(getValidModelParts(123, schema)).toBeNull();
+                    expect(getValidModelParts(true, schema)).toBeNull();
+                    expect(getValidModelParts(false, schema)).toBeNull();
+                    expect(getValidModelParts([123, 456], schema)).toBeNull();
+                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
+                    expect(getValidModelParts([true, false], schema)).toBeNull();
+                    expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
+                });
+            });
+            describe('if the const evaluates to false', function () {
+                it('should still return matches', function () {
+                    var result = getValidModelParts('', { "const": '' });
+                    expect(result).toBe('');
+                });
+            });
+        });
+        describe('when the const is a boolean', function () {
+            var schema = { "const": true };
+            describe('if the model matches the const', function () {
+                it('should return the original model', function () {
+                    var result = getValidModelParts(true, schema);
+                    expect(result).toBe(true);
+                });
+            });
+            describe('if the model does not match the const', function () {
+                it('should return null', function () {
+                    expect(getValidModelParts(false, schema)).toBeNull();
+                    expect(getValidModelParts('abc', schema)).toBeNull();
+                    expect(getValidModelParts(null, schema)).toBeNull();
+                    expect(getValidModelParts(123, schema)).toBeNull();
+                    expect(getValidModelParts([123, 456], schema)).toBeNull();
+                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
+                    expect(getValidModelParts([true, false], schema)).toBeNull();
+                    expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
+                });
+            });
+            describe('if the const evaluates to false', function () {
+                it('should still return matches', function () {
+                    var result = getValidModelParts(false, { "const": false });
+                    expect(result).toBe(false);
+                });
+            });
+        });
+    });
+    describe('when cleaning a simple object schema', function () {
+        var schema = {
+            type: 'object',
+            properties: {
+                a: {
+                    type: 'number'
+                }
+            },
+            displayOrder: ['a']
+        };
+        describe('if the model has a property with the correct name and the correct type', function () {
+            it('should return the property', function () {
+                var result = getValidModelParts({ a: 1 }, schema);
+                expect(result).toStrictEqual({ a: 1 });
+            });
+        });
+        describe('if the model has a property with the correct name but an incorrect type', function () {
+            it('should return an empty object', function () {
+                var result = getValidModelParts({ a: 'one' }, schema);
+                expect(result).toStrictEqual({});
+            });
+        });
+        describe('if the model contains properties not in the schema', function () {
+            it('should return the object without those properties', function () {
+                var result = getValidModelParts({ a: 1, b: 2 }, schema);
+                expect(result).toStrictEqual({ a: 1 });
+            });
+        });
+        describe('if the model is not an object', function () {
+            it('should return null', function () {
+                expect(getValidModelParts(false, schema)).toBeNull();
+                expect(getValidModelParts('abc', schema)).toBeNull();
+                expect(getValidModelParts(null, schema)).toBeNull();
+                expect(getValidModelParts(123, schema)).toBeNull();
+                expect(getValidModelParts([123, 456], schema)).toBeNull();
+                expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
+                expect(getValidModelParts([true, false], schema)).toBeNull();
+            });
+        });
+    });
+    describe('when cleaning an object schema with nested objects', function () {
+        var schema = {
+            type: 'object',
+            properties: {
+                a: {
+                    type: 'number'
+                },
+                b: {
+                    type: 'object',
+                    properties: {
+                        c: {
+                            type: 'number'
+                        }
+                    },
+                    displayOrder: ['c']
+                }
+            },
+            displayOrder: ['a', 'b']
+        };
+        describe('if the nested model is valid', function () {
+            it('should be returned', function () {
+                var result = getValidModelParts({ a: 1, b: { c: 2 } }, schema);
+                expect(result).toStrictEqual({ a: 1, b: { c: 2 } });
+            });
+        });
+        describe('if the nested model contains invalid properties', function () {
+            it('should remove them', function () {
+                var result = getValidModelParts({ a: 1, b: { c: 2, d: 3 }, e: 4 }, schema);
+                expect(result).toStrictEqual({ a: 1, b: { c: 2 } });
+            });
+        });
+    });
+    describe('when cleaning a oneOf schema of object schemas', function () {
+        var schema = {
+            oneOf: [
+                {
+                    type: 'object',
+                    properties: {
+                        a: {
+                            type: 'number'
+                        }
+                    },
+                    displayOrder: ['a']
+                },
+                {
+                    type: 'object',
+                    properties: {
+                        b: {
+                            type: 'number'
+                        }
+                    },
+                    displayOrder: ['b']
+                },
+            ]
+        };
+        describe('if all of the properties are valid', function () {
+            it('should return them', function () {
+                var result = getValidModelParts({ a: 1, b: 2 }, schema);
+                expect(result).toStrictEqual({ a: 1, b: 2 });
+            });
+        });
+        describe('if the nested model contains invalid properties', function () {
+            it('should remove them', function () {
+                var result = getValidModelParts({ a: 1, b: 'two' }, schema);
+                expect(result).toStrictEqual({ a: 1 });
+            });
+        });
+        describe('if the nested model contains ALL invalid properties', function () {
+            it('should remove them', function () {
+                var result = getValidModelParts({ a: 'one', b: 'two' }, schema);
+                expect(result).toStrictEqual({});
+            });
+        });
+        describe('if the model contains undocumented properties', function () {
+            it('should remove them', function () {
+                var result = getValidModelParts({ a: 1, b: 2, c: 3 }, schema);
+                expect(result).toStrictEqual({ a: 1, b: 2 });
+            });
+        });
+        describe('if the model is not an object', function () {
+            it('should return null', function () {
+                expect(getValidModelParts(false, schema)).toBeNull();
+                expect(getValidModelParts('abc', schema)).toBeNull();
+                expect(getValidModelParts(null, schema)).toBeNull();
+                expect(getValidModelParts(123, schema)).toBeNull();
+                expect(getValidModelParts([123, 456], schema)).toBeNull();
+                expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
+                expect(getValidModelParts([true, false], schema)).toBeNull();
+            });
+        });
+    });
+    describe('when cleaning a oneOf schema of const', function () {
+        describe('when the consts are numbers', function () {
+            var schema = {
+                oneOf: [{ "const": 0 }, { "const": 1 }, { "const": 2 }]
+            };
+            describe('when the value is in the const collection', function () {
+                it('should return the value', function () {
+                    expect(getValidModelParts(0, schema)).toBe(0);
+                    expect(getValidModelParts(1, schema)).toBe(1);
+                    expect(getValidModelParts(2, schema)).toBe(2);
+                });
+            });
+            describe('when the value is not in the const collection', function () {
+                it('should return null', function () {
+                    expect(getValidModelParts(3, schema)).toBeNull();
+                    expect(getValidModelParts(null, schema)).toBeNull();
+                    expect(getValidModelParts(true, schema)).toBeNull();
+                    expect(getValidModelParts(false, schema)).toBeNull();
+                    expect(getValidModelParts('abc', schema)).toBeNull();
+                    expect(getValidModelParts(123, schema)).toBeNull();
+                    expect(getValidModelParts([123, 456], schema)).toBeNull();
+                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
+                    expect(getValidModelParts([true, false], schema)).toBeNull();
+                    expect(getValidModelParts({}, schema)).toBeNull();
+                });
+            });
+        });
+        describe('when the consts are strings', function () {
+            var schema = {
+                oneOf: [{ "const": 'zero' }, { "const": 'one' }, { "const": 'two' }]
+            };
+            describe('when the value is in the const collection', function () {
+                it('should return the value', function () {
+                    expect(getValidModelParts('zero', schema)).toBe('zero');
+                    expect(getValidModelParts('one', schema)).toBe('one');
+                    expect(getValidModelParts('two', schema)).toBe('two');
+                });
+            });
+            describe('when the value is not in the const collection', function () {
+                it('should return null', function () {
+                    expect(getValidModelParts('three', schema)).toBeNull();
+                    expect(getValidModelParts(null, schema)).toBeNull();
+                    expect(getValidModelParts(true, schema)).toBeNull();
+                    expect(getValidModelParts(false, schema)).toBeNull();
+                    expect(getValidModelParts(123, schema)).toBeNull();
+                    expect(getValidModelParts([123, 456], schema)).toBeNull();
+                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
+                    expect(getValidModelParts([true, false], schema)).toBeNull();
+                    expect(getValidModelParts({}, schema)).toBeNull();
+                });
+            });
+        });
+        describe('when the consts are booleans', function () {
+            var schema = {
+                oneOf: [{ "const": false }, { "const": true }]
+            };
+            describe('when the value is in the const collection', function () {
+                it('should return the value', function () {
+                    expect(getValidModelParts(false, schema)).toBe(false);
+                    expect(getValidModelParts(true, schema)).toBe(true);
+                });
+            });
+            describe('when the value is not in the const collection', function () {
+                it('should return null', function () {
+                    expect(getValidModelParts(null, schema)).toBeNull();
+                    expect(getValidModelParts('abc', schema)).toBeNull();
+                    expect(getValidModelParts(123, schema)).toBeNull();
+                    expect(getValidModelParts([123, 456], schema)).toBeNull();
+                    expect(getValidModelParts(['one', 'two'], schema)).toBeNull();
+                    expect(getValidModelParts([true, false], schema)).toBeNull();
+                    expect(getValidModelParts({}, schema)).toBeNull();
+                });
+            });
+        });
+    });
+    describe('when cleaning a oneOf schema of array schemas', function () {
+        var schema = {
+            oneOf: [
+                {
+                    type: 'array',
+                    items: { type: 'string' }
+                },
+                {
+                    type: 'array',
+                    items: { type: 'number' }
+                },
+            ]
+        };
+        describe('when the model is valid for one of the one-ofs', function () {
+            it('should return the model', function () {
+                expect(getValidModelParts(['a', 'b', 'c'], schema)).toStrictEqual(['a', 'b', 'c']);
+                expect(getValidModelParts([1, 2, 3], schema)).toStrictEqual([1, 2, 3]);
+            });
+        });
+        describe('when the model is NOT valid for any of the one-ofs', function () {
+            it('should return null', function () {
+                expect(getValidModelParts([true, false, true], schema)).toStrictEqual([null, null, null]);
+                expect(getValidModelParts(['a', 'b', 123], schema)).toStrictEqual([null, null, null]);
+                expect(getValidModelParts([123, 456, 'abc'], schema)).toStrictEqual([null, null, null]);
+                expect(getValidModelParts(null, schema)).toBeNull();
+                expect(getValidModelParts('abc', schema)).toBeNull();
+                expect(getValidModelParts(123, schema)).toBeNull();
+                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
+            });
+        });
+    });
+    describe('when cleaning an allOf schema of object schemas', function () {
+        var schema = {
+            allOf: [
+                {
+                    type: 'object',
+                    properties: {
+                        a: {
+                            type: 'number'
+                        }
+                    },
+                    displayOrder: ['a']
+                },
+                {
+                    type: 'object',
+                    properties: {
+                        b: {
+                            type: 'number'
+                        }
+                    },
+                    displayOrder: ['b']
+                },
+            ]
+        };
+        describe('if all of the properties are valid', function () {
+            it('should return them', function () {
+                var result = getValidModelParts({ a: 1, b: 2 }, schema);
+                expect(result).toStrictEqual({ a: 1, b: 2 });
+            });
+        });
+        describe('if the model contains invalid properties', function () {
+            it('should remove them', function () {
+                var result = getValidModelParts({ a: 1, b: '2' }, schema);
+                expect(result).toStrictEqual({ a: 1 });
+            });
+        });
+        describe('if the model contains undocumented properties', function () {
+            it('should remove them', function () {
+                var result = getValidModelParts({ a: 1, b: 2, c: 3 }, schema);
+                expect(result).toStrictEqual({ a: 1, b: 2 });
+            });
+        });
+        describe('if the models is not an object', function () {
+            it('should return null', function () {
+                expect(getValidModelParts(null, schema)).toBeNull();
+                expect(getValidModelParts(true, schema)).toBeNull();
+                expect(getValidModelParts(false, schema)).toBeNull();
+                expect(getValidModelParts('abc', schema)).toBeNull();
+                expect(getValidModelParts(123, schema)).toBeNull();
+                expect(getValidModelParts(['a', 'b', 123], schema)).toBeNull();
+                expect(getValidModelParts([true, false], schema)).toBeNull();
+            });
+        });
+    });
+    describe('when schemas both contain the same nested object', function () {
+        var schema = {
+            oneOf: [
+                {
+                    type: 'object',
+                    properties: {
+                        nested: {
+                            type: 'object',
+                            properties: {
+                                a: { type: 'string' }
+                            },
+                            displayOrder: ['a']
+                        }
+                    },
+                    displayOrder: ['nested']
+                },
+                {
+                    type: 'object',
+                    properties: {
+                        nested: {
+                            type: 'object',
+                            properties: {
+                                b: { type: 'string' }
+                            },
+                            displayOrder: ['b']
+                        }
+                    },
+                    displayOrder: ['nested']
+                },
+            ]
+        };
+        it('should deep merge the content of the nested objects', function () {
+            var model = { nested: { a: 'one', b: 'two' } };
+            var result = getValidModelParts(model, schema);
+            expect(result).toStrictEqual(model);
+        });
+    });
+    describe('when cleaning file array schema', function () {
+        var schema = {
+            type: 'array',
+            items: {
+                type: 'string',
+                persistAsync: {
+                    url: 'http://localhost:3001/v1/save-file/',
+                    method: 'POST',
+                    param: 'bodyAttribute',
+                    idProperty: 'responseKey',
+                    schema: {
+                        type: 'string',
+                        format: 'base64url',
+                        maxSize: 5242000,
+                        title: 'Invoice (optional)'
+                    }
+                }
+            }
+        };
+        it('should deep merge the content of the nested objects', function () {
+            var result = getValidModelParts(['file-123', 'file-234'], schema);
+            expect(result).toStrictEqual(['file-123', 'file-234']);
+        });
+    });
+    describe('when cleaning an array schema of number schemas', function () {
+        var schema = {
+            type: 'array',
+            items: { type: 'number' }
+        };
+        describe('when the model is an array of numbers', function () {
+            var model = [1, 2, 3];
+            it('should return the model', function () {
+                var result = getValidModelParts(model, schema);
+                expect(result).toStrictEqual(model);
+            });
+        });
+        describe('when the model is NOT and array of numbers', function () {
+            it('should return null', function () {
+                expect(getValidModelParts(['a', 'b', 'c'], schema)).toStrictEqual([null, null, null]);
+                expect(getValidModelParts([true, false], schema)).toStrictEqual([null, null]);
+                expect(getValidModelParts(['a', 'b', 123], schema)).toStrictEqual([null, null, null]);
+                expect(getValidModelParts(null, schema)).toBeNull();
+                expect(getValidModelParts('abc', schema)).toBeNull();
+                expect(getValidModelParts(123, schema)).toBeNull();
+                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
+            });
+        });
+    });
+    describe('when cleaning an array schema of string schemas', function () {
+        var schema = {
+            type: 'array',
+            items: { type: 'string' }
+        };
+        describe('when the model is an array of strings', function () {
+            var model = ['a', 'b', 'c'];
+            it('should return the model', function () {
+                var result = getValidModelParts(model, schema);
+                expect(result).toStrictEqual(model);
+            });
+        });
+        describe('when the model is NOT and array of strings', function () {
+            it('should return null', function () {
+                expect(getValidModelParts(['a', 'b', 123], schema)).toStrictEqual([null, null, null]);
+                expect(getValidModelParts([true, false], schema)).toStrictEqual([null, null]);
+                expect(getValidModelParts([1, 2, 3], schema)).toStrictEqual([null, null, null]);
+                expect(getValidModelParts(null, schema)).toBeNull();
+                expect(getValidModelParts('abc', schema)).toBeNull();
+                expect(getValidModelParts(123, schema)).toBeNull();
+                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
+            });
+        });
+    });
+    describe('when cleaning an array schema of boolean schemas', function () {
+        var schema = {
+            type: 'array',
+            items: { type: 'boolean' }
+        };
+        describe('when the model is an array of booleans', function () {
+            var model = [true, false, true];
+            it('should return the model', function () {
+                var result = getValidModelParts(model, schema);
+                expect(result).toStrictEqual(model);
+            });
+        });
+        describe('when the model is NOT and array of booleans', function () {
+            it('should return null', function () {
+                expect(getValidModelParts(['a', 'b', 123], schema)).toStrictEqual([null, null, null]);
+                expect(getValidModelParts([1, 2, 3], schema)).toStrictEqual([null, null, null]);
+                expect(getValidModelParts(null, schema)).toBeNull();
+                expect(getValidModelParts('abc', schema)).toBeNull();
+                expect(getValidModelParts(123, schema)).toBeNull();
+                expect(getValidModelParts({ a: 1 }, schema)).toBeNull();
+            });
+        });
+    });
+});

package/build/common/validation/valid-model/utils.d.ts

@@ -0,0 +1,11 @@
+import { AllOfSchema, ArrayModel, ArraySchema, BasicModel, Model, ObjectModel, ObjectSchema, OneOfSchema } from '../../../dynamic-flow-types';
+export declare function cleanBasicModelWithOneOfSchema(model: BasicModel, schema: OneOfSchema): BasicModel | null;
+export declare function cleanArrayModelWithOneOfSchema(model: ArrayModel, schema: OneOfSchema): ArrayModel | null;
+export declare function cleanModelWithStringSchema(model: Model): string | null;
+export declare function cleanModelWithNumberSchema(model: Model): number | null;
+export declare function cleanModelWithBooleanSchema(model: Model): boolean | null;
+export declare function cleanModelWithArraySchema(model: Model, schema: ArraySchema): ArrayModel | null;
+export declare function cleanObjectModelWithObjectSchema(model: ObjectModel, schema: ObjectSchema): ObjectModel;
+export declare function cleanObjectModelWithAllOfSchema(model: ObjectModel, schema: AllOfSchema): ObjectModel;
+export declare function cleanObjectModelWithOneOfSchema(model: ObjectModel, schema: OneOfSchema): ObjectModel | null;
+export declare function filterOutNull<T>(array: (T | null)[]): T[];