@microsoft/1ds-core-js 3.2.12 → 4.0.1

package/src/ValueSanitizer.ts

@@ -1,285 +0,0 @@
-import { isNullOrUndefined, isString, objForEachKey } from "@microsoft/applicationinsights-core-js";
-import {
-    FieldValueSanitizerFunc, FieldValueSanitizerTypes, IEventProperty, IFieldSanitizerDetails, IFieldValueSanitizerProvider, IValueSanitizer
-} from "./DataModels";
-import { FieldValueSanitizerType } from "./Enums";
-import { STR_EMPTY } from "./InternalConstants";
-import { getFieldValueType, isValueAssigned, isValueKind } from "./Utils";
-
-interface ISanitizerMapValue {
-    canHandle: boolean;
-    handler?: IValueSanitizer;
-    fieldHandler?: IFieldValueSanitizerProvider;
-}
-
-export class ValueSanitizer implements IValueSanitizer {
-
-    public static getFieldType = getFieldValueType;
-
-    /**
-     * Add a value sanitizer as a fallback sanitizer if this sanitizer can't handle the path/name.
-     */
-    public addSanitizer: (sanitizer: IValueSanitizer) => void;
-
-    /**
-     * Adds a field sanitizer to the evaluation list
-     */
-    public addFieldSanitizer: (fieldSanitizer: IFieldValueSanitizerProvider) => void;
-
-    /**
-     * Does this field value sanitizer handle this path / field combination
-     * @param path - The field path
-     * @param name - The name of the field
-     */
-    public handleField: (path: string, name: string) => boolean;
-
-    /**
-     * Sanitizes the value. It checks the that the property name and value are valid. It also
-     * checks/populates the correct type and pii of the property value.
-     * @param path - The root path of the property
-     * @param name - The property name.
-     * @param value - The property value or an IEventProperty containing value, type ,pii and customer content.
-     * @param stringifyObjects - If supplied tells the sanitizer that it should JSON stringify() objects
-     * @returns IEventProperty containing valid name, value, pii and type or null if invalid.
-     */
-    public value: (path: string, name: string, value: FieldValueSanitizerTypes, stringifyObjects?: boolean) => IEventProperty | null;
-
-    /**
-     * Sanitizes the Property. It checks the that the property name and value are valid. It also
-     * checks/populates the correct type and pii of the property value.
-     * @param path - The root path of the property
-     * @param name - The property name.
-     * @param property - The property value or an IEventProperty containing value, type ,pii and customer content.
-     * @param stringifyObjects - If supplied tells the sanitizer that it should JSON stringify() objects
-     * @returns IEventProperty containing valid name, value, pii and type or null if invalid.
-     */
-    public property: (path: string, name: string, property: IEventProperty, stringifyObjects?: boolean) => IEventProperty | null;
-
-    constructor(fieldSanitizerProvider?: IFieldValueSanitizerProvider) {
-        let _self = this;
-
-        // To aid with performance this is a lookup map to check if the field value sanitizer supports this field
-        let _sanitizerMap: { [path: string]: { [field: string]: ISanitizerMapValue } } = {};
-        let _sanitizers: IValueSanitizer[] = [];
-        let _fieldSanitizers: IFieldValueSanitizerProvider[] = [];
-        if (fieldSanitizerProvider) {
-            _fieldSanitizers.push(fieldSanitizerProvider);
-        }
-
-        function _getFieldSanitizer(path: string, name: string): ISanitizerMapValue {
-            let result: ISanitizerMapValue;
-            let fieldLookup = _sanitizerMap[path];
-            if (fieldLookup) {
-                result = fieldLookup[name];
-            }
-
-            if (!result && result !== null) {
-                // Null is a valid result indicating that the value sanitizer does not support this field
-                if (isString(path) && isString(name)) {
-                    if (_fieldSanitizers.length > 0) {
-                        for (let lp = 0; lp < _fieldSanitizers.length; lp++) {
-                            if (_fieldSanitizers[lp].handleField(path, name)) {
-                                result = {
-                                    canHandle: true, // This instance will handle so we won't assign the handler
-                                    fieldHandler: _fieldSanitizers[lp]
-                                };
-                                break;
-                            }
-                        }
-                    } else if (_sanitizers.length === 0) {
-                        // Special use-case where there is no sanitizer to pass on to, so just resolving the field
-                        // and returning the resulting value (same as sanitizeProperty())
-                        result = {
-                            canHandle: true
-                        };
-                    }
-                }
-
-                // We still don't have a handler so lets lookup the providers
-                if (!result && result !== null) {
-                    // Setting the result to null -- which means we and any contained sanitizers can't handle this field
-                    result = null;
-                    for (let lp = 0; lp < _sanitizers.length; lp++) {
-                        if (_sanitizers[lp].handleField(path, name)) {
-                            result = {
-                                canHandle: true,
-                                handler: _sanitizers[lp],
-                                fieldHandler: null
-                            };
-                            break;
-                        }
-                    }
-                }
-
-                if (!fieldLookup) {
-                    fieldLookup = _sanitizerMap[path] = {};
-                }
-
-                fieldLookup[name] = result;
-            }
-
-            return result;
-        }
-
-        _self.addSanitizer = (newSanitizer: IValueSanitizer) => {
-            if (newSanitizer) {
-                _sanitizers.push(newSanitizer);
-                // Invalidate any previously mapped fields
-                _sanitizerMap = {};
-            }
-        };
-
-        _self.addFieldSanitizer = (fieldSanitizer: IFieldValueSanitizerProvider) => {
-            if (fieldSanitizer) {
-                _fieldSanitizers.push(fieldSanitizer);
-                // Invalidate any previously mapped fields
-                _sanitizerMap = {};
-            }
-        };
-
-        _self.handleField = (path: string, name: string): boolean => {
-            let mapValue: ISanitizerMapValue = _getFieldSanitizer(path, name);
-            return mapValue ? mapValue.canHandle : false;
-        };
-
-        _self.value = (path: string, name: string, value: FieldValueSanitizerTypes, stringifyObjects?: boolean): IEventProperty | null => {
-            let mapValue: ISanitizerMapValue = _getFieldSanitizer(path, name);
-            if (mapValue && mapValue.canHandle) {
-                if (!mapValue || !mapValue.canHandle) {
-                    return null;
-                }
-
-                if (mapValue.handler) {
-                    // This value sanitizer can't handle this field so pass it only the next one
-                    return mapValue.handler.value(path, name, value, stringifyObjects);
-                }
-
-                // Check that property is valid
-                if (!isString(name) || isNullOrUndefined(value) || (value as any) === STR_EMPTY) {
-                    return null;
-                }
-
-                let property = null;
-                let fieldType = getFieldValueType(value);
-
-                if ((fieldType & FieldValueSanitizerType.EventProperty) === FieldValueSanitizerType.EventProperty) {
-                    let subType = fieldType & ~FieldValueSanitizerType.EventProperty;
-                    property = value as IEventProperty;
-                    if (!isValueAssigned(property.value) ||
-                        (subType !== FieldValueSanitizerType.String &&
-                        subType !== FieldValueSanitizerType.Number &&
-                        subType !== FieldValueSanitizerType.Boolean &&
-                        (subType & FieldValueSanitizerType.Array) !== FieldValueSanitizerType.Array)) {
-
-                        // Not a supported IEventProperty type to be able to sanitize
-                        return null;
-                    }
-                } else if (fieldType === FieldValueSanitizerType.String ||
-                        fieldType === FieldValueSanitizerType.Number ||
-                        fieldType === FieldValueSanitizerType.Boolean ||
-                        (fieldType & FieldValueSanitizerType.Array) === FieldValueSanitizerType.Array) {
-                    // If the property isn't IEventProperty (and is either string, number, boolean or array), convert it into one.
-                    property = _convertToProperty(path, name, value);
-                } else if (fieldType === FieldValueSanitizerType.Object) {
-                    property = _convertToProperty(path, name, !!stringifyObjects ? JSON.stringify(value) : value);
-                }
-
-                if (property) {
-                    return _handleProperty(mapValue, path, name, fieldType, property, stringifyObjects);
-                }
-            }
-
-            return null;
-        };
-
-        _self.property = (path: string, name: string, property: IEventProperty, stringifyObjects?: boolean): IEventProperty | null => {
-            let mapValue: ISanitizerMapValue = _getFieldSanitizer(path, name);
-            if (!mapValue || !mapValue.canHandle) {
-                return null;
-            }
-
-            // Check that property is valid
-            if (!isString(name) || isNullOrUndefined(property) || !isValueAssigned(property.value)) {
-                return null;
-            }
-
-            let fieldType: FieldValueSanitizerType = getFieldValueType(property.value);
-            if (fieldType === FieldValueSanitizerType.NotSet) {
-                // Not a supported field that we can sanitize or serialize
-                return null;
-            }
-
-            return _handleProperty(mapValue, path, name, fieldType, property, stringifyObjects);
-        };
-
-        function _handleProperty(mapValue: ISanitizerMapValue, path: string, name: string, fieldType: FieldValueSanitizerType,
-                                 property: IEventProperty, stringifyObjects?: boolean): IEventProperty | null {
-
-            if (mapValue.handler) {
-                // This value sanitizer can't handle this field so pass it only the next one
-                return mapValue.handler.property(path, name, property, stringifyObjects);
-            }
-
-            // If either pii or cc is set convert value to string (since only string pii/cc is allowed).
-            // If the value is a complex type like an array that can't be converted to string we will drop
-            // the property.
-            if (!isNullOrUndefined(property.kind)) {
-                if ((fieldType & FieldValueSanitizerType.Array) === FieldValueSanitizerType.Array || !isValueKind(property.kind)) {
-                    return null;
-                }
-
-                // Convert the value to a string and assign back to the original value
-                property.value = property.value.toString();
-            }
-
-            return _callFieldSanitizer(mapValue.fieldHandler, path, name, fieldType, property);
-        }
-
-        function _convertToProperty(path: string, name: string, value: any): IEventProperty | null {
-            if (isValueAssigned(value)) {
-                return { value: value } as IEventProperty;
-            }
-
-            return null;
-        }
-
-        function _callFieldSanitizer(fieldProvider: IFieldValueSanitizerProvider, path: string, name: string, theType: FieldValueSanitizerType, property: IEventProperty) {
-            if (property && fieldProvider) {
-                let sanitizer: FieldValueSanitizerFunc = fieldProvider.getSanitizer(path, name, theType, property.kind, property.propertyType);
-                if (sanitizer) {
-                    // This is where we the field will call the handler to "scrub" the value. This the primary hook for the ClientHashing Plugin to
-                    // be able to apply the hashFunc() / Sha256 conversion of the properties value
-                    if (theType === FieldValueSanitizerType.Object) {
-                        // Special case of an embedded object (ext.metadata, data.properties)
-                        let newValue: any = { };
-                        let propValue = property.value;
-                        objForEachKey(propValue, (propKey, theValue) => {
-                            let newPath = path + "." + name;
-                            if (isValueAssigned(theValue)) {
-                                let newProp = _convertToProperty(newPath, propKey, theValue);
-                                newProp = _callFieldSanitizer(fieldProvider, newPath, propKey, getFieldValueType(theValue), newProp);
-                                if (newProp) {
-                                    newValue[propKey] = newProp.value;
-                                }
-                            }
-                        });
-
-                        property.value = newValue;
-                    } else {
-                        let details: IFieldSanitizerDetails = {
-                            path: path,
-                            name: name,
-                            type: theType,
-                            prop: property,
-                            sanitizer: _self
-                        };
-
-                        property = sanitizer.call(_self, details);
-                    }
-                }
-            }
-
-            return property;
-        }
-    }
-}