@wise/dynamic-flow-client 0.4.0-beta-0489d0.8 → 0.4.0

package/build/common/validators/models/models.utils.js

@@ -0,0 +1,130 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+exports.cleanObjectModelWithOneOfSchema = exports.cleanObjectModelWithAllOfSchema = exports.cleanObjectModelWithObjectSchema = exports.cleanModelWithArraySchema = exports.cleanModelWithBooleanSchema = exports.cleanModelWithNumberSchema = exports.cleanModelWithStringSchema = exports.cleanArrayModelWithOneOfSchema = exports.cleanBasicModelWithOneOfSchema = void 0;
+var types_1 = require("../../../types");
+var type_validators_1 = require("../types/type-validators");
+var value_validators_1 = require("../values/value-validators");
+var model_validators_1 = require("./model-validators");
+function cleanBasicModelWithOneOfSchema(model, schema) {
+    return schema.oneOf.some(function (nestedSchema) { return (0, model_validators_1.getValidBasicModelOrNull)(model, nestedSchema) === model; })
+        ? model
+        : null;
+}
+exports.cleanBasicModelWithOneOfSchema = cleanBasicModelWithOneOfSchema;
+function cleanArrayModelWithOneOfSchema(model, schema) {
+    var _a;
+    var validModels = schema.oneOf
+        .map(function (nestedSchema) { return getValidArrayModelOrNull(model, nestedSchema); })
+        .filter(function (item) { return item !== null; });
+    if (validModels.length === 0) {
+        return null;
+    }
+    return (_a = validModels.find(function (model) { return model.some(function (item) { return item !== null; }); })) !== null && _a !== void 0 ? _a : validModels[0];
+}
+exports.cleanArrayModelWithOneOfSchema = cleanArrayModelWithOneOfSchema;
+function getValidArrayModelOrNull(model, schema) {
+    if (!(0, types_1.isArraySchema)(schema)) {
+        return null;
+    }
+    if (!(0, types_1.isListArraySchema)(schema)) {
+        return null; // we don't support tuples at the moment
+    }
+    return cleanModelWithArraySchema(model, schema);
+}
+function cleanModelWithStringSchema(model) {
+    return (0, type_validators_1.isString)(model) && !(0, value_validators_1.isEmpty)(model) ? model : null;
+}
+exports.cleanModelWithStringSchema = cleanModelWithStringSchema;
+function cleanModelWithNumberSchema(model) {
+    return (0, type_validators_1.isNumber)(model) ? model : null;
+}
+exports.cleanModelWithNumberSchema = cleanModelWithNumberSchema;
+function cleanModelWithBooleanSchema(model) {
+    return (0, type_validators_1.isBoolean)(model) ? model : null;
+}
+exports.cleanModelWithBooleanSchema = cleanModelWithBooleanSchema;
+function cleanModelWithArraySchema(model, schema) {
+    if (!(0, type_validators_1.isArray)(model)) {
+        return null;
+    }
+    if (!(0, types_1.isListArraySchema)(schema)) {
+        return null; // we don't support tuples at the moment
+    }
+    if (model.length > 0) {
+        var expectedType_1 = typeof model[0];
+        if (!model.every(function (item) { return typeof item === expectedType_1; })) {
+            return new Array(model.length).fill(null);
+        }
+    }
+    return model.map(function (childModel) { return (0, model_validators_1.getValidBasicModelOrNull)(childModel, schema.items); });
+}
+exports.cleanModelWithArraySchema = cleanModelWithArraySchema;
+function cleanObjectModelWithObjectSchema(model, schema) {
+    return Object.keys(schema.properties).reduce(function (cleanedModel, property) {
+        var _a;
+        // If the property exists in the model, clean it, and add it
+        if (model && !(0, type_validators_1.isUndefined)(model[property])) {
+            var subModel = model[property];
+            var subSchema = schema.properties[property];
+            var newValue = (0, model_validators_1.getValidModelParts)(subModel, subSchema);
+            if (!(0, type_validators_1.isNull)(newValue)) {
+                return __assign(__assign({}, cleanedModel), (_a = {}, _a[property] = newValue, _a));
+            }
+        }
+        return cleanedModel;
+    }, {});
+}
+exports.cleanObjectModelWithObjectSchema = cleanObjectModelWithObjectSchema;
+function cleanObjectModelWithAllOfSchema(model, schema) {
+    return schema.allOf.reduce(function (cleanObjectModel, nestedSchema) {
+        var validSubsetOfModel = (0, model_validators_1.getValidObjectModelParts)(model, nestedSchema);
+        if ((0, types_1.isObjectModel)(validSubsetOfModel)) {
+            // Extend model with valid subset
+            return __assign(__assign({}, cleanObjectModel), validSubsetOfModel);
+        }
+        return cleanObjectModel;
+    }, {});
+}
+exports.cleanObjectModelWithAllOfSchema = cleanObjectModelWithAllOfSchema;
+function cleanObjectModelWithOneOfSchema(model, schema) {
+    return schema.oneOf
+        .map(function (nestedSchema) { return (0, model_validators_1.getValidObjectModelParts)(model, nestedSchema); })
+        .reduce(function (combined, current) {
+        // If we didn't find anything valid yet, and current is good, return it
+        if ((0, type_validators_1.isNull)(combined)) {
+            return current;
+        }
+        // If we're dealing with two objects, deep merge them into one
+        if ((0, types_1.isObjectModel)(combined) && (0, types_1.isObjectModel)(current)) {
+            return deepMergeObject(combined, current);
+        }
+        // If the current one is null, return what we already had
+        if ((0, type_validators_1.isNull)(current)) {
+            return combined;
+        }
+        return current;
+    }, null);
+}
+exports.cleanObjectModelWithOneOfSchema = cleanObjectModelWithOneOfSchema;
+function deepMergeObject(object1, object2) {
+    return Object.keys(object2).reduce(function (acc, property) {
+        var _a, _b;
+        var object1Property = object1[property];
+        var object2Property = object2[property];
+        if ((0, types_1.isObjectModel)(object1Property) && (0, types_1.isObjectModel)(object2Property)) {
+            return __assign(__assign({}, acc), (_a = {}, _a[property] = deepMergeObject(object1Property, object2Property), _a));
+        }
+        return __assign(__assign({}, acc), (_b = {}, _b[property] = object2[property], _b));
+    }, __assign({}, object1));
+}

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

@@ -0,0 +1,101 @@
+"use strict";
+exports.__esModule = true;
+exports.isValidSchema = void 0;
+var types_1 = require("../../../types");
+var type_validators_1 = require("../types/type-validators");
+var validation_failures_1 = require("../validationFailures/validation-failures");
+function isValidStringSchema(value, schema) {
+    return !(0, validation_failures_1.getStringValidationFailures)(value, schema).length;
+}
+function isValidNumberSchema(value, schema) {
+    return !(0, validation_failures_1.getNumberValidationFailures)(value, schema).length;
+}
+function isValidIntegerSchema(value, schema) {
+    return !(0, validation_failures_1.getIntegerValidationFailures)(value, schema).length;
+}
+function isValidBooleanSchema(value, schema) {
+    return !(0, validation_failures_1.getBooleanValidationFailures)(value, schema).length;
+}
+function isValidConstSchema(value, schema) {
+    return !(0, validation_failures_1.getConstValidationFailures)(value, schema).length;
+}
+function isValidObjectSchema(value, schema) {
+    if (!(0, type_validators_1.isObject)(value) || schema.type !== 'object' || !(0, type_validators_1.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 (typeof propertyValue === 'undefined') {
+        return !isRequired;
+    }
+    return isValidSchema(propertyValue, propertySchema);
+}
+function isValidArraySchema(value, schema) {
+    if (schema.type !== 'array' || !(0, type_validators_1.isObject)(schema.items)) {
+        return false;
+    }
+    if ((0, validation_failures_1.getArrayValidationFailures)(value, schema).length > 0) {
+        return false;
+    }
+    return (Array.isArray(value) &&
+        (0, types_1.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 (!(0, type_validators_1.isArray)(schema.oneOf)) {
+        return false;
+    }
+    return schema.oneOf.some(function (childSchema) { return isValidSchema(value, childSchema); });
+}
+function isValidAllOfSchema(value, schema) {
+    if (!(0, type_validators_1.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 !(0, validation_failures_1.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;
+    }
+}
+exports.isValidSchema = isValidSchema;

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

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

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

@@ -0,0 +1,151 @@
+"use strict";
+exports.__esModule = true;
+exports.getBlobValidationFailures = exports.getObjectValidationFailures = exports.getArrayValidationFailures = exports.getConstValidationFailures = exports.getBooleanValidationFailures = exports.getIntegerValidationFailures = exports.getNumberValidationFailures = exports.getStringValidationFailures = exports.getValidationFailures = void 0;
+var types_1 = require("../../../types");
+var Schema_1 = require("../../../types/specification/Schema");
+var type_validators_1 = require("../types/type-validators");
+var validation_failures_utils_1 = require("./validation-failures.utils");
+function getValidationFailures(value, schema, isRequired) {
+    if (schema["const"]) {
+        return getConstValidationFailures(value, schema, isRequired);
+    }
+    if ((0, type_validators_1.isNull)(value)) {
+        return isRequired ? ['required'] : [];
+    }
+    if ((0, Schema_1.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 [];
+    }
+}
+exports.getValidationFailures = getValidationFailures;
+function getStringValidationFailures(value, schema, isRequired) {
+    if (!(0, type_validators_1.isString)(value) && !(0, type_validators_1.isNull)(value)) {
+        return ['type'];
+    }
+    if (value === '' && isRequired) {
+        return ['required'];
+    }
+    var failures = [];
+    if (!(0, validation_failures_utils_1.isValidRequired)(value, isRequired)) {
+        failures.push('required');
+    }
+    if (!(0, validation_failures_utils_1.isValidMinLength)(value, schema.minLength)) {
+        failures.push('minLength');
+    }
+    if (!(0, validation_failures_utils_1.isValidMaxLength)(value, schema.maxLength)) {
+        failures.push('maxLength');
+    }
+    if (!(0, validation_failures_utils_1.isValidPattern)(value, schema.pattern)) {
+        failures.push('pattern');
+    }
+    if (!(0, validation_failures_utils_1.isValidMinimum)(value, schema.minimum)) {
+        failures.push('minimum');
+    }
+    if (!(0, validation_failures_utils_1.isValidMaximum)(value, schema.maximum)) {
+        failures.push('maximum');
+    }
+    return failures;
+}
+exports.getStringValidationFailures = getStringValidationFailures;
+function getNumberValidationFailures(value, schema, isRequired) {
+    if (!(0, type_validators_1.isNumber)(value) && !(0, type_validators_1.isNull)(value)) {
+        return ['type'];
+    }
+    var failures = [];
+    if (!(0, validation_failures_utils_1.isValidRequired)(value, isRequired)) {
+        failures.push('required');
+    }
+    if (!(0, validation_failures_utils_1.isValidMinimum)(value, schema.minimum)) {
+        failures.push('minimum');
+    }
+    if (!(0, validation_failures_utils_1.isValidMaximum)(value, schema.maximum)) {
+        failures.push('maximum');
+    }
+    return failures;
+}
+exports.getNumberValidationFailures = getNumberValidationFailures;
+function getIntegerValidationFailures(value, schema, isRequired) {
+    if (!(0, type_validators_1.isInteger)(value)) {
+        return ['type'];
+    }
+    return getNumberValidationFailures(value, schema, isRequired);
+}
+exports.getIntegerValidationFailures = getIntegerValidationFailures;
+function getBooleanValidationFailures(value, _schema, isRequired) {
+    if (!(0, type_validators_1.isBoolean)(value) && !(0, type_validators_1.isNull)(value)) {
+        return ['type'];
+    }
+    var failures = [];
+    if (!(0, validation_failures_utils_1.isValidRequired)(value, isRequired)) {
+        failures.push('required');
+    }
+    return failures;
+}
+exports.getBooleanValidationFailures = getBooleanValidationFailures;
+function getConstValidationFailures(value, schema, isRequired) {
+    if (!(0, validation_failures_utils_1.isValidRequired)(value, isRequired)) {
+        return ['required'];
+    }
+    if (value !== schema["const"]) {
+        return ['const'];
+    }
+    return [];
+}
+exports.getConstValidationFailures = getConstValidationFailures;
+function getArrayValidationFailures(value, schema, isRequired) {
+    if (!(0, type_validators_1.isArray)(value) && !(0, type_validators_1.isNull)(value)) {
+        return ['type'];
+    }
+    if (!(0, validation_failures_utils_1.isValidRequiredArray)(value, isRequired)) {
+        return ['required'];
+    }
+    var failures = [];
+    if (!(0, validation_failures_utils_1.isValidMinItems)(value, schema.minItems)) {
+        failures.push('minItems');
+    }
+    if (!(0, validation_failures_utils_1.isValidMaxItems)(value, schema.maxItems)) {
+        failures.push('maxItems');
+    }
+    return failures;
+}
+exports.getArrayValidationFailures = getArrayValidationFailures;
+function getBlobValidationFailures(value, _schema) {
+    if ((0, type_validators_1.isNull)(value)) {
+        return ['type'];
+    }
+    return [];
+}
+exports.getBlobValidationFailures = getBlobValidationFailures;
+/**
+ * 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 (!(0, types_1.isObjectModel)(value)) {
+        return ['type'];
+    }
+    if (!(0, type_validators_1.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'];
+}
+exports.getObjectValidationFailures = getObjectValidationFailures;

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

@@ -0,0 +1,51 @@
+"use strict";
+exports.__esModule = true;
+exports.isValidRequiredArray = exports.isValidMaxItems = exports.isValidMinItems = exports.isValidMinimum = exports.isValidMaximum = exports.isValidPattern = exports.isValidMaxLength = exports.isValidMinLength = exports.isValidRequired = void 0;
+var validators_1 = require("../../validators");
+function isValidRequired(value, isRequired) {
+    if (isRequired === void 0) { isRequired = false; }
+    return !isRequired || !(0, validators_1.isUndefined)(value);
+}
+exports.isValidRequired = isValidRequired;
+function isValidRequiredArray(value, isRequired) {
+    if (isRequired === void 0) { isRequired = false; }
+    return !isRequired || (0, validators_1.isArray)(value);
+}
+exports.isValidRequiredArray = isValidRequiredArray;
+function isValidMinLength(value, minLength) {
+    return !(0, validators_1.isNumber)(minLength) || ((0, validators_1.isString)(value) && value.length >= minLength);
+}
+exports.isValidMinLength = isValidMinLength;
+function isValidMaxLength(value, maxLength) {
+    return !(0, validators_1.isNumber)(maxLength) || ((0, validators_1.isString)(value) && value.length <= maxLength);
+}
+exports.isValidMaxLength = isValidMaxLength;
+function isValidPattern(value, pattern) {
+    if (pattern === undefined) {
+        return true; // no pattern, therefore the value is valid
+    }
+    if (value === undefined || value === null) {
+        return false; // no value, but there's a pattern, therefore the value is NOT valid
+    }
+    var regex = new RegExp(pattern);
+    return !!regex.test(value);
+}
+exports.isValidPattern = isValidPattern;
+function isValidMaximum(value, maximum) {
+    return ((!(0, validators_1.isNumber)(maximum) && !(0, validators_1.isString)(maximum)) ||
+        (((0, validators_1.isNumber)(value) || (0, validators_1.isString)(value)) && value <= maximum));
+}
+exports.isValidMaximum = isValidMaximum;
+function isValidMinimum(value, minimum) {
+    return ((!(0, validators_1.isNumber)(minimum) && !(0, validators_1.isString)(minimum)) ||
+        (((0, validators_1.isNumber)(value) || (0, validators_1.isString)(value)) && value >= minimum));
+}
+exports.isValidMinimum = isValidMinimum;
+function isValidMinItems(value, minItems) {
+    return !(0, validators_1.isNumber)(minItems) || ((0, validators_1.isArray)(value) && value.length >= minItems);
+}
+exports.isValidMinItems = isValidMinItems;
+function isValidMaxItems(value, maxItems) {
+    return !(0, validators_1.isNumber)(maxItems) || ((0, validators_1.isArray)(value) && value.length <= maxItems);
+}
+exports.isValidMaxItems = isValidMaxItems;

package/build/common/validators/values/value-validators.js

@@ -0,0 +1,9 @@
+"use strict";
+exports.__esModule = true;
+exports.isEmpty = void 0;
+var type_validators_1 = require("../types/type-validators");
+var isEmpty = function (value) {
+    return ((0, type_validators_1.isString)(value) && value.length === 0) ||
+        (((0, type_validators_1.isObject)(value) || (0, type_validators_1.isArray)(value)) && Object.keys(value).length === 0);
+};
+exports.isEmpty = isEmpty;