@hackylabs/deep-redact 3.0.5 → 4.0.0

package/dist/utils/index.mjs

@@ -1,467 +0,0 @@
-import { standardTransformers } from './standardTransformers/index.mjs';
-import { TransformerRegistry } from './TransformerRegistry.mjs';
-const defaultConfig = {
-    stringTests: [],
-    blacklistedKeys: [],
-    fuzzyKeyMatch: false,
-    caseSensitiveKeyMatch: true,
-    retainStructure: false,
-    remove: false,
-    replaceStringByLength: false,
-    replacement: '[REDACTED]',
-    types: ['string'],
-    transformers: standardTransformers,
-};
-class RedactorUtils {
-    /**
-     * The configuration for the redaction.
-     * @private
-     */
-    config = defaultConfig;
-    /**
-     * The transformed blacklist keys of flat regex patterns and complex config objects
-     * @private
-     */
-    blacklistedKeysTransformed = [];
-    /**
-     * The transformer registry for efficient transformer lookup
-     * @private
-     */
-    transformerRegistry = new TransformerRegistry();
-    constructor(customConfig) {
-        this.config = {
-            ...defaultConfig,
-            ...customConfig,
-        };
-        this.blacklistedKeysTransformed = (customConfig.blacklistedKeys ?? []).map((key) => this.createTransformedBlacklistedKey(key, customConfig));
-        this.setupTransformerRegistry(this.config.transformers);
-    }
-    /**
-     * Sets up the transformer registry based on the configuration
-     * @param transformers - The transformer configuration
-     * @private
-     */
-    setupTransformerRegistry(transformers) {
-        if (Array.isArray(transformers)) {
-            transformers.forEach(transformer => { this.transformerRegistry.addFallbackTransformer(transformer); });
-        }
-        else {
-            const organised = transformers;
-            if (organised.byType) {
-                Object.entries(organised.byType).forEach(([type, typeTransformers]) => {
-                    if (typeTransformers) {
-                        typeTransformers.forEach(transformer => {
-                            this.transformerRegistry.addTypeTransformer(type, transformer);
-                        });
-                    }
-                });
-            }
-            if (organised.byConstructor) {
-                Object.entries(organised.byConstructor).forEach(([constructorName, constructorTransformers]) => {
-                    if (constructorTransformers) {
-                        const constructorMap = {
-                            Date,
-                            Error,
-                            Map,
-                            Set,
-                            RegExp,
-                            URL,
-                        };
-                        const constructor = constructorMap[constructorName];
-                        if (constructor) {
-                            constructorTransformers.forEach(transformer => {
-                                this.transformerRegistry.addConstructorTransformer(constructor, transformer);
-                            });
-                        }
-                    }
-                });
-            }
-        }
-    }
-    createTransformedBlacklistedKey = (key, customConfig) => {
-        if (key instanceof RegExp) {
-            return {
-                key,
-                fuzzyKeyMatch: customConfig.fuzzyKeyMatch ?? defaultConfig.fuzzyKeyMatch,
-                caseSensitiveKeyMatch: customConfig.caseSensitiveKeyMatch ?? defaultConfig.caseSensitiveKeyMatch,
-                retainStructure: customConfig.retainStructure ?? defaultConfig.retainStructure,
-                replacement: customConfig.replacement ?? defaultConfig.replacement,
-                replaceStringByLength: customConfig.replaceStringByLength ?? defaultConfig.replaceStringByLength,
-                remove: customConfig.remove ?? defaultConfig.remove,
-            };
-        }
-        if (typeof key === 'string') {
-            return {
-                key,
-                fuzzyKeyMatch: customConfig.fuzzyKeyMatch ?? defaultConfig.fuzzyKeyMatch,
-                caseSensitiveKeyMatch: customConfig.caseSensitiveKeyMatch ?? defaultConfig.caseSensitiveKeyMatch,
-                retainStructure: customConfig.retainStructure ?? defaultConfig.retainStructure,
-                replacement: customConfig.replacement ?? defaultConfig.replacement,
-                replaceStringByLength: customConfig.replaceStringByLength ?? defaultConfig.replaceStringByLength,
-                remove: customConfig.remove ?? defaultConfig.remove,
-            };
-        }
-        return {
-            fuzzyKeyMatch: key.fuzzyKeyMatch ?? customConfig.fuzzyKeyMatch ?? defaultConfig.fuzzyKeyMatch,
-            caseSensitiveKeyMatch: key.caseSensitiveKeyMatch ?? customConfig.caseSensitiveKeyMatch ?? defaultConfig.caseSensitiveKeyMatch,
-            retainStructure: key.retainStructure ?? customConfig.retainStructure ?? defaultConfig.retainStructure,
-            replacement: key.replacement ?? customConfig.replacement ?? defaultConfig.replacement,
-            replaceStringByLength: key.replaceStringByLength ?? customConfig.replaceStringByLength ?? defaultConfig.replaceStringByLength,
-            remove: key.remove ?? customConfig.remove ?? defaultConfig.remove,
-            key: key.key,
-        };
-    };
-    /**
-     * Applies transformers to a value
-     * @param value - The value to transform
-     * @param key - The key to check
-     * @returns The transformed value
-     * @private
-     */
-    applyTransformers = (value, key, referenceMap) => {
-        return this.transformerRegistry.applyTransformers(value, key, referenceMap);
-    };
-    /**
-     * Checks if a key should be redacted
-     * @param key - The key to check
-     * @returns Whether the key should be redacted
-     * @private
-     */
-    shouldRedactKey = (key) => {
-        return this.blacklistedKeysTransformed.some(config => {
-            const pattern = config.key;
-            if (pattern instanceof RegExp)
-                return pattern.test(key);
-            if (!config.fuzzyKeyMatch && !config.caseSensitiveKeyMatch)
-                return key.toLowerCase().trim().replace(/[_-]/g, '') === pattern.toLowerCase().trim().replace(/[_-]/g, '');
-            if (config.fuzzyKeyMatch && !config.caseSensitiveKeyMatch)
-                return key.toLowerCase().trim().replace(/[_-]/g, '').includes(pattern.toLowerCase().trim().replace(/[_-]/g, ''));
-            if (config.fuzzyKeyMatch && config.caseSensitiveKeyMatch)
-                return key.includes(pattern);
-            if (!config.fuzzyKeyMatch && config.caseSensitiveKeyMatch)
-                return key === pattern;
-        });
-    };
-    /**
-     * Checks if a value should be redacted
-     * @param value - The value to check
-     * @param key - The key to check
-     * @returns Whether the value should be redacted
-     * @private
-     */
-    shouldRedactValue = (value, valueKey) => {
-        if (!this.config.types.includes(typeof value))
-            return false;
-        return this.shouldRedactKey(valueKey);
-    };
-    /**
-     * Redacts a value based on the key-specific config
-     * @param value - The value to redact
-     * @param key - The key to check
-     * @param redactingParent - Whether the parent is being redacted
-     * @returns The redacted value
-     * @private
-     */
-    redactValue = (value, redactingParent, keyConfig) => {
-        if (!this.config.types.includes(typeof value))
-            return { transformed: value, redactingParent };
-        const remove = keyConfig?.remove ?? this.config.remove;
-        const replacement = keyConfig?.replacement ?? this.config.replacement;
-        const replaceStringByLength = keyConfig?.replaceStringByLength ?? this.config.replaceStringByLength;
-        const retainStructure = keyConfig?.retainStructure ?? this.config.retainStructure;
-        if (retainStructure && typeof value === 'object' && value !== null)
-            return { transformed: value, redactingParent: true };
-        if (remove)
-            return { transformed: undefined, redactingParent };
-        if (typeof replacement === 'function')
-            return { transformed: replacement(value), redactingParent };
-        return {
-            redactingParent,
-            transformed: (typeof value === 'string' && replaceStringByLength)
-                ? replacement.toString().repeat(value.length)
-                : replacement,
-        };
-    };
-    /**
-     * Applies string transformations
-     * @param value - The value to transform
-     * @param key - The key to check
-     * @returns The transformed value
-     * @private
-     */
-    applyStringTransformations(value, amRedactingParent, keyConfig) {
-        if ((this.config.stringTests ?? []).length === 0)
-            return { transformed: value, redactingParent: amRedactingParent };
-        for (const test of this.config.stringTests) {
-            if (test instanceof RegExp) {
-                if (test.test(value)) {
-                    const { transformed, redactingParent } = this.redactValue(value, amRedactingParent, keyConfig);
-                    return { transformed: transformed, redactingParent };
-                }
-            }
-            else {
-                if (test.pattern.test(value)) {
-                    const transformed = test.replacer(value, test.pattern);
-                    return { transformed, redactingParent: amRedactingParent };
-                }
-            }
-        }
-        return { transformed: value, redactingParent: amRedactingParent };
-    }
-    /**
-     * Handles primitive values
-     * @param value - The value to handle
-     * @param key - The key to check
-     * @param redactingParent - Whether the parent is being redacted
-     * @param keyConfig - The key config
-     * @returns The transformed value
-     * @private
-     */
-    handlePrimitiveValue(value, valueKey, redactingParent, keyConfig) {
-        let transformed = value;
-        if (redactingParent) {
-            if (valueKey === '_transformer' || !this.config.types.includes(typeof value)) {
-                return { transformed: value, redactingParent };
-            }
-            const { transformed: transformedValue } = this.redactValue(value, redactingParent, keyConfig);
-            return { transformed: transformedValue, redactingParent };
-        }
-        if (keyConfig || this.shouldRedactValue(value, valueKey)) {
-            return this.redactValue(value, redactingParent, keyConfig);
-        }
-        if (typeof value === 'string') {
-            return this.applyStringTransformations(value, redactingParent, keyConfig);
-        }
-        return { transformed, redactingParent };
-    }
-    /**
-     * Handles object values
-     * @param value - The value to handle
-     * @param key - The key to check
-     * @param path - The path to the value
-     * @param redactingParent - Whether the parent is being redacted
-     * @param referenceMap - The reference map
-     * @returns The transformed value and stack
-     * @private
-     */
-    handleObjectValue(value, key, path, amRedactingParent, referenceMap, keyConfig) {
-        const fullPath = path.join('.');
-        const shouldRedact = amRedactingParent || Boolean(keyConfig) || this.shouldRedactValue(value, key);
-        referenceMap.set(value, fullPath);
-        if (shouldRedact && !(keyConfig?.retainStructure ?? this.config.retainStructure)) {
-            const { transformed, redactingParent } = this.redactValue(value, amRedactingParent, keyConfig);
-            return { transformed, redactingParent, stack: [] };
-        }
-        return this.handleRetainStructure(value, path, shouldRedact);
-    }
-    /**
-     * Handles object values
-     * @param value - The value to handle
-     * @param path - The path to the value
-     * @param redactingParent - Whether the parent is being redacted
-     * @returns The transformed value and stack
-     * @private
-     */
-    handleRetainStructure(value, path, redactingParent) {
-        const newValue = Array.isArray(value) ? [] : {};
-        const stack = [];
-        if (Array.isArray(value)) {
-            for (let i = value.length - 1; i >= 0; i--) {
-                stack.push({
-                    parent: newValue,
-                    key: i.toString(),
-                    value: value[i],
-                    path: [...path, i],
-                    redactingParent,
-                    keyConfig: this.findMatchingKeyConfig(i.toString()),
-                });
-            }
-        }
-        else {
-            for (const [propKey, propValue] of Object.entries(value).reverse()) {
-                stack.push({
-                    parent: newValue,
-                    key: propKey,
-                    value: propValue,
-                    path: [...path, propKey],
-                    redactingParent,
-                    keyConfig: this.findMatchingKeyConfig(propKey),
-                });
-            }
-        }
-        return { transformed: newValue, redactingParent, stack };
-    }
-    /**
-     * Finds the matching key config
-     * @param key - The key to find
-     * @returns The matching key config
-     * @private
-     */
-    findMatchingKeyConfig(key) {
-        return this.blacklistedKeysTransformed.find(config => {
-            const pattern = config.key;
-            if (pattern instanceof RegExp)
-                return pattern.test(key);
-            const normalisedKey = key.toLowerCase().trim().replace(/[_-]/g, '');
-            const normalisedPattern = pattern.toLowerCase().trim().replace(/[_-]/g, '');
-            if (config.fuzzyKeyMatch) {
-                const compareKey = config.caseSensitiveKeyMatch ? key : normalisedKey;
-                const comparePattern = config.caseSensitiveKeyMatch ? pattern : normalisedPattern;
-                return compareKey.includes(comparePattern);
-            }
-            return config.caseSensitiveKeyMatch ? key === pattern : normalisedKey === normalisedPattern;
-        });
-    }
-    /**
-     * Initialises the traversal
-     * @param raw - The raw value to traverse
-     * @returns The output and stack
-     * @private
-     */
-    initialiseTraversal(raw) {
-        const output = Array.isArray(raw) ? [] : {};
-        const stack = [];
-        if (typeof raw === 'object' && raw !== null) {
-            if (Array.isArray(raw)) {
-                for (let i = raw.length - 1; i >= 0; i--) {
-                    stack.push({
-                        parent: output,
-                        key: i.toString(),
-                        value: raw[i],
-                        path: [i],
-                        redactingParent: false,
-                        keyConfig: this.findMatchingKeyConfig(i.toString()),
-                    });
-                }
-            }
-            else {
-                for (const [propKey, propValue] of Object.entries(raw).reverse()) {
-                    stack.push({
-                        parent: output,
-                        key: propKey,
-                        value: propValue,
-                        path: [propKey],
-                        redactingParent: false,
-                        keyConfig: this.findMatchingKeyConfig(propKey),
-                    });
-                }
-            }
-        }
-        return { output, stack };
-    }
-    /**
-     * Pre-processes the input to replace circular references with transformer objects
-     * @param raw - The raw value to process
-     * @returns The processed value with circular references replaced
-     * @private
-     */
-    replaceCircularReferences(raw) {
-        if (typeof raw !== 'object' || raw === null)
-            return raw;
-        const visiting = new WeakSet();
-        const pathMap = new WeakMap();
-        const processValue = (value, path) => {
-            if (typeof value !== 'object' || value === null)
-                return value;
-            if (visiting.has(value)) {
-                const originalPath = pathMap.get(value) || '';
-                return {
-                    _transformer: 'circular',
-                    value: originalPath,
-                    path: path
-                };
-            }
-            visiting.add(value);
-            pathMap.set(value, path);
-            let result;
-            if (Array.isArray(value)) {
-                let hasCircular = false;
-                const newArray = value.map((item, index) => {
-                    const itemPath = path ? `${path}.${index}` : index.toString();
-                    const processed = processValue(item, itemPath);
-                    if (processed !== item)
-                        hasCircular = true;
-                    return processed;
-                });
-                result = hasCircular ? newArray : value;
-            }
-            else {
-                let hasCircular = false;
-                const newObj = {};
-                for (const [key, val] of Object.entries(value)) {
-                    const valuePath = path ? `${path}.${key}` : key;
-                    const processed = processValue(val, valuePath);
-                    newObj[key] = processed;
-                    if (processed !== val)
-                        hasCircular = true;
-                }
-                result = hasCircular ? newObj : value;
-            }
-            visiting.delete(value);
-            return result;
-        };
-        return processValue(raw, '');
-    }
-    /**
-     * Checks if a non-traversable value requires transformers
-     * @param value - The value to check
-     * @returns Whether the value requires transformers
-     * @private
-     */
-    requiresTransformers(value) {
-        if (typeof value === 'bigint')
-            return true;
-        if (value instanceof Date)
-            return true;
-        if (value instanceof Error)
-            return true;
-        if (value instanceof Map)
-            return true;
-        if (value instanceof RegExp)
-            return true;
-        if (value instanceof Set)
-            return true;
-        if (value instanceof URL)
-            return true;
-        return false;
-    }
-    /**
-     * Traverses the raw value
-     * @param raw - The raw value to traverse
-     * @returns The transformed value
-     */
-    traverse = (raw) => {
-        if (typeof raw === 'string') {
-            const { transformed } = this.applyStringTransformations(raw, false);
-            return transformed;
-        }
-        if (typeof raw !== 'object' || raw === null || this.requiresTransformers(raw))
-            return this.applyTransformers(raw);
-        const referenceMap = new WeakMap();
-        const cleanedInput = this.replaceCircularReferences(raw);
-        const { output, stack } = this.initialiseTraversal(cleanedInput);
-        if (typeof cleanedInput === 'object' && cleanedInput !== null)
-            referenceMap.set(cleanedInput, '');
-        while (stack.length > 0) {
-            const { parent, key, value, path, redactingParent: amRedactingParent, keyConfig } = stack.pop();
-            let transformed = this.applyTransformers(value, key, referenceMap);
-            let redactingParent = amRedactingParent;
-            if (typeof transformed !== 'object' || transformed === null) {
-                const primitiveResult = this.handlePrimitiveValue(transformed, key, amRedactingParent, keyConfig);
-                redactingParent = primitiveResult.redactingParent;
-                transformed = primitiveResult.transformed;
-                if (typeof transformed === 'undefined')
-                    continue;
-            }
-            else {
-                const objectResult = this.handleObjectValue(transformed, key, path, redactingParent, referenceMap, keyConfig);
-                transformed = objectResult.transformed;
-                stack.push(...objectResult.stack);
-            }
-            if (parent !== null && key !== null)
-                parent[key] = transformed;
-        }
-        return output;
-    };
-}
-export default RedactorUtils;

package/dist/utils/standardTransformers/bigint.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._bigint = void 0;
-const _bigint = (value) => {
-    if (typeof value !== 'bigint')
-        return value;
-    const radix = 10;
-    return { value: { radix, number: value.toString(radix) }, _transformer: 'bigint' };
-};
-exports._bigint = _bigint;

package/dist/utils/standardTransformers/bigint.mjs

@@ -1,6 +0,0 @@
-export const _bigint = (value) => {
-    if (typeof value !== 'bigint')
-        return value;
-    const radix = 10;
-    return { value: { radix, number: value.toString(radix) }, _transformer: 'bigint' };
-};

package/dist/utils/standardTransformers/date.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._date = void 0;
-const _date = (value) => {
-    if (value instanceof Date)
-        return { datetime: value.toISOString(), _transformer: 'date' };
-    return value;
-};
-exports._date = _date;

package/dist/utils/standardTransformers/date.mjs

@@ -1,5 +0,0 @@
-export const _date = (value) => {
-    if (value instanceof Date)
-        return { datetime: value.toISOString(), _transformer: 'date' };
-    return value;
-};

package/dist/utils/standardTransformers/error.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._error = void 0;
-const _error = (value) => {
-    if (!(value instanceof Error))
-        return value;
-    return {
-        _transformer: 'error',
-        value: {
-            type: value.constructor.name,
-            message: value.message,
-            stack: value.stack,
-        },
-    };
-};
-exports._error = _error;

package/dist/utils/standardTransformers/error.mjs

@@ -1,12 +0,0 @@
-export const _error = (value) => {
-    if (!(value instanceof Error))
-        return value;
-    return {
-        _transformer: 'error',
-        value: {
-            type: value.constructor.name,
-            message: value.message,
-            stack: value.stack,
-        },
-    };
-};

package/dist/utils/standardTransformers/index.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.organisedStandardTransformers = exports.standardTransformers = void 0;
-const bigint_js_1 = require("./bigint.js");
-const date_js_1 = require("./date.js");
-const error_js_1 = require("./error.js");
-const map_js_1 = require("./map.js");
-const regex_js_1 = require("./regex.js");
-const set_js_1 = require("./set.js");
-const url_js_1 = require("./url.js");
-/**
- * Standard transformers in array for legacy support
- */
-exports.standardTransformers = [
-    bigint_js_1._bigint,
-    date_js_1._date,
-    error_js_1._error,
-    map_js_1._map,
-    regex_js_1._regex,
-    set_js_1._set,
-    url_js_1._url,
-];
-/**
- * Standard transformers organised by type and constructor for performance reasons
- */
-exports.organisedStandardTransformers = {
-    byType: {
-        bigint: [bigint_js_1._bigint],
-    },
-    byConstructor: {
-        URL: [url_js_1._url],
-        Date: [date_js_1._date],
-        Error: [error_js_1._error],
-        Map: [map_js_1._map],
-        Set: [set_js_1._set],
-        RegExp: [regex_js_1._regex],
-    },
-};

package/dist/utils/standardTransformers/index.mjs

@@ -1,35 +0,0 @@
-import { _bigint } from "./bigint.mjs";
-import { _date } from "./date.mjs";
-import { _error } from "./error.mjs";
-import { _map } from "./map.mjs";
-import { _regex } from "./regex.mjs";
-import { _set } from "./set.mjs";
-import { _url } from "./url.mjs";
-/**
- * Standard transformers in array for legacy support
- */
-export const standardTransformers = [
-    _bigint,
-    _date,
-    _error,
-    _map,
-    _regex,
-    _set,
-    _url,
-];
-/**
- * Standard transformers organised by type and constructor for performance reasons
- */
-export const organisedStandardTransformers = {
-    byType: {
-        bigint: [_bigint],
-    },
-    byConstructor: {
-        URL: [_url],
-        Date: [_date],
-        Error: [_error],
-        Map: [_map],
-        Set: [_set],
-        RegExp: [_regex],
-    },
-};

package/dist/utils/standardTransformers/map.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._map = void 0;
-const _map = (value) => {
-    if (value instanceof Map)
-        return { value: Object.fromEntries(value.entries()), _transformer: 'map' };
-    return value;
-};
-exports._map = _map;

package/dist/utils/standardTransformers/map.mjs

@@ -1,5 +0,0 @@
-export const _map = (value) => {
-    if (value instanceof Map)
-        return { value: Object.fromEntries(value.entries()), _transformer: 'map' };
-    return value;
-};

package/dist/utils/standardTransformers/regex.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._regex = void 0;
-const _regex = (value) => {
-    if (!(value instanceof RegExp))
-        return value;
-    return {
-        _transformer: 'regex',
-        value: {
-            source: value.source,
-            flags: value.flags,
-        },
-    };
-};
-exports._regex = _regex;

package/dist/utils/standardTransformers/regex.mjs

@@ -1,11 +0,0 @@
-export const _regex = (value) => {
-    if (!(value instanceof RegExp))
-        return value;
-    return {
-        _transformer: 'regex',
-        value: {
-            source: value.source,
-            flags: value.flags,
-        },
-    };
-};

package/dist/utils/standardTransformers/set.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._set = void 0;
-const _set = (value) => {
-    if (value instanceof Set)
-        return { value: Array.from(value), _transformer: 'set' };
-    return value;
-};
-exports._set = _set;

package/dist/utils/standardTransformers/set.mjs

@@ -1,5 +0,0 @@
-export const _set = (value) => {
-    if (value instanceof Set)
-        return { value: Array.from(value), _transformer: 'set' };
-    return value;
-};

package/dist/utils/standardTransformers/url.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._url = void 0;
-const _url = (value) => {
-    if (value instanceof URL)
-        return { value: value.toString(), _transformer: 'url' };
-    return value;
-};
-exports._url = _url;