field-redactor 1.5.0 → 1.6.1

package/dist/objectRedactorTraversal.js

@@ -1,575 +1,200 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectRedactorTraversal = void 0;
 const types_1 = require("./types");
 const objectRedactorMutation_1 = require("./objectRedactorMutation");
 const objectRedactorHelpers_1 = require("./objectRedactorHelpers");
-const objectRedactorCustomObject_1 = require("./objectRedactorCustomObject");
+const ruleResolver_1 = require("./ruleResolver");
+const maybeAsync_1 = require("./maybeAsync");
+const arrayRedaction_1 = require("./arrayRedaction");
+const customObjectFieldHandler_1 = require("./customObjectFieldHandler");
 /**
  * Unified JSON traversal for in-place and copy-on-write redaction.
- * Sync paths avoid Promise allocation; async paths use the same ContainerMutation adapter.
+ * Sync and async paths share one implementation; async mode propagates Promises only when configured.
  */
 class ObjectRedactorTraversal {
-    constructor(primitiveRedactor, secretManager, customObjManager, valuePatternMatcher) {
+    constructor(primitiveRedactor, secretManager, customObjManager, valuePatternMatcher, pathRuleMatcher) {
         this.primitiveRedactor = primitiveRedactor;
         this.secretManager = secretManager;
-        this.customObjManager = customObjManager;
         this.valuePatternMatcher = valuePatternMatcher;
+        this.ruleResolver = new ruleResolver_1.RuleResolver(secretManager, pathRuleMatcher, valuePatternMatcher, customObjManager);
+        this.services = {
+            get asyncMode() {
+                return primitiveRedactor.usesAsyncRedactor();
+            },
+            ruleResolver: this.ruleResolver,
+            secretManager,
+            valuePatternMatcher,
+            setPrimitive: (container, key, primitive) => this.setPrimitive(container, key, primitive),
+            setPrimitiveFromValue: (container, key, value) => this.setPrimitiveFromValue(container, key, value),
+            setPrimitiveValueIfSecret: (container, key, secretKey, value, forceDeepRedaction) => this.setPrimitiveValueIfSecret(container, key, secretKey, value, forceDeepRedaction),
+            redactSecretFields: (container, forceDeepRedaction, pathSegments) => this.redactSecretFields(container, forceDeepRedaction, pathSegments),
+            handleCustomObject: (container, customObject) => this.handleCustomObject(container, customObject),
+            redactArrayInObject: (array, key, forceDeepRedaction, parent, pathSegments) => this.redactArrayInObject(array, key, forceDeepRedaction, parent, pathSegments),
+            redactAllArrayValues: (array, forceDeepRedaction, copyOnWrite, pathSegments) => this.redactAllArrayValues(array, forceDeepRedaction, copyOnWrite, pathSegments)
+        };
+        this.arrayRedactor = new arrayRedaction_1.ArrayRedactor(this.services);
+        this.customObjectHandler = new customObjectFieldHandler_1.CustomObjectFieldHandler(this.services);
     }
     usesAsyncRedactor() {
         return this.primitiveRedactor.usesAsyncRedactor();
     }
     redactInPlace(value) {
-        return this.redact(value, false);
+        const result = this.traverseRedact(value, false);
+        if (result instanceof Promise) {
+            throw new Error('Unexpected async work on sync traversal path');
+        }
+        return result;
     }
     redactCopyOnWrite(value) {
-        return this.redact(value, true);
+        const result = this.traverseRedact(value, true);
+        if (result instanceof Promise) {
+            throw new Error('Unexpected async work on sync traversal path');
+        }
+        return result;
     }
     redactInPlaceAsync(value) {
-        return this.redactAsync(value, false);
+        return Promise.resolve(this.traverseRedact(value, false));
     }
-    redact(value, copyOnWrite) {
-        const container = (0, objectRedactorMutation_1.createContainerMutation)(value, copyOnWrite);
-        const customObject = this.customObjManager.getMatchingCustomObject(value);
-        if (customObject && (0, types_1.isJsonObject)(value)) {
-            this.handleCustomObject(container, customObject);
-        }
-        else {
-            this.redactSecretFields(container, false);
-        }
-        return (copyOnWrite ? container.result() : value);
+    get asyncMode() {
+        return this.primitiveRedactor.usesAsyncRedactor();
     }
-    redactSecretFields(container, forceDeepRedaction) {
-        const record = container.source;
-        for (const key of Object.keys(record)) {
-            const value = record[key];
-            const customObject = (0, types_1.isJsonObject)(value) ? this.customObjManager.getMatchingCustomObject(value) : undefined;
-            if (customObject && (0, types_1.isJsonObject)(value)) {
-                const child = (0, objectRedactorMutation_1.createContainerMutation)(value, container.copyOnWrite);
-                this.handleCustomObject(child, customObject);
-                if (container.copyOnWrite) {
-                    container.set(key, child.result());
-                }
-            }
-            else if (this.secretManager.isDeleteSecretKey(key)) {
-                container.remove(key);
-            }
-            else if (this.secretManager.isFullSecretKey(key)) {
-                container.set(key, this.redactPrimitive((0, objectRedactorHelpers_1.getStringValue)(value)));
-            }
-            else if (Array.isArray(value)) {
-                this.redactArrayInObject(value, key, forceDeepRedaction, container);
-            }
-            else if ((0, types_1.isJsonObject)(value)) {
-                this.redactNestedObject(value, key, forceDeepRedaction, container);
-            }
-            else {
-                container.set(key, this.redactPrimitiveValueIfSecret(key, value, forceDeepRedaction));
-            }
-        }
+    traverseRedact(value, copyOnWrite) {
+        const container = (0, objectRedactorMutation_1.createContainerMutation)(value, copyOnWrite);
+        const customObject = this.ruleResolver.getMatchingSchema(value);
+        const work = customObject && (0, types_1.isJsonObject)(value)
+            ? this.handleCustomObject(container, customObject)
+            : this.redactSecretFields(container, false, []);
+        return (0, maybeAsync_1.finalizeMaybeAsync)(work, () => (copyOnWrite ? container.result() : value), this.asyncMode);
     }
-    redactArrayInObject(array, key, forceDeepRedaction, parent) {
-        const deepSecretKey = this.secretManager.isDeepSecretKey(key);
-        const result = this.secretManager.isSecretKey(key) || deepSecretKey || forceDeepRedaction
-            ? this.redactAllArrayValues(array, forceDeepRedaction || deepSecretKey, parent.copyOnWrite)
-            : this.redactObjectsInArray(array, parent.copyOnWrite);
-        parent.set(key, result);
+    handleCustomObject(container, customObject) {
+        return this.customObjectHandler.handleCustomObject(container, customObject);
     }
-    redactObjectsInArray(array, copyOnWrite) {
-        const container = (0, objectRedactorMutation_1.createContainerMutation)(array, copyOnWrite);
-        for (let index = 0; index < array.length; index++) {
-            const value = array[index];
-            if ((0, types_1.isJsonObject)(value)) {
-                const customObject = this.customObjManager.getMatchingCustomObject(value);
-                const child = (0, objectRedactorMutation_1.createContainerMutation)(value, copyOnWrite);
-                if (customObject) {
-                    this.handleCustomObject(child, customObject);
-                }
-                else {
-                    this.redactSecretFields(child, false);
-                }
-                container.set(String(index), child.result());
-            }
-        }
-        return container.result();
+    redactArrayInObject(array, key, forceDeepRedaction, parent, pathSegments) {
+        return this.arrayRedactor.redactArrayInObject(array, key, forceDeepRedaction, parent, pathSegments);
     }
-    redactAllArrayValues(array, forceDeepRedaction, copyOnWrite) {
-        const container = (0, objectRedactorMutation_1.createContainerMutation)(array, copyOnWrite);
-        for (let index = 0; index < array.length; index++) {
-            const value = array[index];
-            const key = String(index);
-            if (Array.isArray(value)) {
-                container.set(key, this.redactAllArrayValues(value, forceDeepRedaction, copyOnWrite));
-            }
-            else if (!(0, types_1.isJsonObject)(value)) {
-                container.set(key, this.redactPrimitive((0, objectRedactorHelpers_1.toRedactablePrimitive)(value)));
-            }
-            else {
-                const customObject = this.customObjManager.getMatchingCustomObject(value);
-                const child = (0, objectRedactorMutation_1.createContainerMutation)(value, copyOnWrite);
-                if (customObject) {
-                    this.handleCustomObject(child, customObject);
-                }
-                else {
-                    this.redactSecretFields(child, forceDeepRedaction);
-                }
-                container.set(key, child.result());
-            }
-        }
-        return container.result();
+    redactAllArrayValues(array, forceDeepRedaction, copyOnWrite, pathSegments) {
+        return this.arrayRedactor.redactAllArrayValues(array, forceDeepRedaction, copyOnWrite, pathSegments);
     }
-    redactNestedObject(value, key, forceDeepRedaction, parent) {
-        const child = (0, objectRedactorMutation_1.createContainerMutation)(value, parent.copyOnWrite);
-        const customObject = this.customObjManager.getMatchingCustomObject(value);
-        if (customObject) {
-            this.handleCustomObject(child, customObject);
-        }
-        else {
-            this.redactSecretFields(child, forceDeepRedaction || this.secretManager.isDeepSecretKey(key));
-        }
-        if (parent.copyOnWrite) {
-            parent.set(key, child.result());
-        }
+    redactPrimitive(value) {
+        return this.asyncMode ? this.primitiveRedactor.redactValue(value) : this.primitiveRedactor.redactValueSync(value);
     }
-    handleCustomObject(container, customObject) {
-        for (const key of Object.keys(customObject)) {
-            const fieldValue = container.source[key];
-            if (Array.isArray(fieldValue)) {
-                this.handleCustomObjectValueIfArray(container, key, customObject);
-            }
-            else if ((0, types_1.isJsonObject)(fieldValue)) {
-                this.handleCustomObjectValueIfObject(container, key, customObject);
-            }
-            else {
-                this.handleCustomObjectValueIfPrimitive(container, customObject, key);
-            }
+    setPrimitive(container, key, primitive) {
+        const redacted = this.redactPrimitive(primitive);
+        if (redacted instanceof Promise) {
+            return redacted.then((result) => {
+                container.set(key, result);
+            });
         }
+        container.set(key, redacted);
     }
-    handleCustomObjectValueIfArray(container, key, customObject) {
-        const stringKey = (0, objectRedactorHelpers_1.getStringSpecifiedCustomObjectSecretKeyValueIfExists)(container.source, customObject, key);
-        if (stringKey !== undefined) {
-            this.handleCustomObjectArrayValueIfStringKeySpecified(container, key, stringKey);
-        }
-        else {
-            this.handleCustomObjectArrayValueIfMatchTypeSpecified(container, key, customObject[key]);
-        }
+    setPrimitiveFromValue(container, key, value) {
+        return this.setPrimitive(container, key, (0, objectRedactorHelpers_1.getStringValue)(value));
     }
-    handleCustomObjectArrayValueIfStringKeySpecified(container, key, stringKey) {
-        const fieldValue = container.source[key];
-        if (!Array.isArray(fieldValue)) {
-            return;
-        }
-        if (this.secretManager.isDeleteSecretKey(stringKey)) {
-            container.remove(key);
-        }
-        else if (this.secretManager.isFullSecretKey(stringKey)) {
-            container.set(key, this.redactPrimitive((0, objectRedactorHelpers_1.getStringValue)(fieldValue)));
-        }
-        else {
-            const isDeepSecretKey = this.secretManager.isDeepSecretKey(stringKey);
-            if (isDeepSecretKey || this.secretManager.isSecretKey(stringKey)) {
-                container.set(key, this.redactAllArrayValues(fieldValue, isDeepSecretKey, container.copyOnWrite));
-            }
+    chainHandled(work) {
+        if (work instanceof Promise) {
+            return work.then(() => 'handled');
         }
+        return 'handled';
     }
-    handleCustomObjectArrayValueIfMatchTypeSpecified(container, key, matchType) {
-        const fieldValue = container.source[key];
-        if (!Array.isArray(fieldValue)) {
-            return;
+    applyFieldDisposition(disposition, value, key, fieldPath, container) {
+        switch (disposition.action) {
+            case 'skip':
+                return 'handled';
+            case 'remove':
+                container.remove(key);
+                return 'handled';
+            case 'opaque':
+                return this.chainHandled(this.setPrimitiveFromValue(container, key, value));
+            case 'deep':
+                return this.chainHandled(this.redactFieldValue(value, key, true, container, fieldPath));
+            case 'shallow':
+                if (Array.isArray(value) || (0, types_1.isJsonObject)(value)) {
+                    return this.chainHandled(this.redactFieldValue(value, key, false, container, fieldPath));
+                }
+                return this.chainHandled(this.setPrimitive(container, key, (0, objectRedactorHelpers_1.toRedactablePrimitive)(value)));
+            case 'pass-key-recurse':
+                if (Array.isArray(value) || (0, types_1.isJsonObject)(value)) {
+                    return this.chainHandled(this.redactFieldValue(value, key, false, container, fieldPath));
+                }
+                return 'handled';
+            default:
+                return 'default';
         }
-        (0, objectRedactorCustomObject_1.applyCustomObjectArrayMatchType)(matchType, {
-            deleteKey: () => container.remove(key),
-            redactFull: () => container.set(key, this.redactPrimitive((0, objectRedactorHelpers_1.getStringValue)(fieldValue))),
-            redactDeep: () => container.set(key, this.redactAllArrayValues(fieldValue, true, container.copyOnWrite)),
-            redactShallow: () => container.set(key, this.redactAllArrayValues(fieldValue, false, container.copyOnWrite)),
-            passThrough: () => {
-                this.redactArrayInObject(fieldValue, key, false, container);
-            }
-        });
     }
-    handleCustomObjectValueIfObject(container, key, customObject) {
-        const stringKey = (0, objectRedactorHelpers_1.getStringSpecifiedCustomObjectSecretKeyValueIfExists)(container.source, customObject, key);
-        if (stringKey !== undefined) {
-            this.handleCustomObjectObjectValueIfStringKeySpecified(container, key, stringKey);
+    redactFieldValue(value, key, forceDeepRedaction, container, fieldPath) {
+        if (Array.isArray(value)) {
+            return this.redactArrayInObject(value, key, forceDeepRedaction, container, fieldPath);
         }
-        else {
-            this.handleCustomObjectObjectValueIfMatchTypeSpecified(container, key, customObject[key]);
+        if ((0, types_1.isJsonObject)(value)) {
+            return this.redactNestedObject(value, key, forceDeepRedaction, container, fieldPath);
         }
+        return this.setPrimitiveValueIfSecret(container, key, key, value, forceDeepRedaction);
     }
-    handleCustomObjectObjectValueIfStringKeySpecified(container, key, stringKey) {
-        const fieldValue = container.source[key];
-        if (!(0, types_1.isJsonObject)(fieldValue)) {
-            return;
-        }
-        const customObject = this.customObjManager.getMatchingCustomObject(fieldValue);
-        if (customObject) {
-            const child = (0, objectRedactorMutation_1.createContainerMutation)(fieldValue, container.copyOnWrite);
-            this.handleCustomObject(child, customObject);
-            container.set(key, child.result());
-        }
-        else if (this.secretManager.isDeleteSecretKey(stringKey)) {
-            container.remove(key);
-        }
-        else if (this.secretManager.isFullSecretKey(stringKey)) {
-            container.set(key, this.redactPrimitive((0, objectRedactorHelpers_1.getStringValue)(fieldValue)));
-        }
-        else if (this.secretManager.isDeepSecretKey(stringKey)) {
+    redactSecretFields(container, forceDeepRedaction, pathSegments) {
+        const record = container.source;
+        return (0, maybeAsync_1.runSequential)(Object.keys(record), (key) => this.processSecretField(record, key, forceDeepRedaction, pathSegments, container), this.asyncMode);
+    }
+    processSecretField(record, key, forceDeepRedaction, pathSegments, container) {
+        const fieldValue = record[key];
+        const fieldPath = [...pathSegments, key];
+        const customObject = (0, types_1.isJsonObject)(fieldValue) ? this.ruleResolver.getMatchingSchema(fieldValue) : undefined;
+        if (customObject && (0, types_1.isJsonObject)(fieldValue)) {
             const child = (0, objectRedactorMutation_1.createContainerMutation)(fieldValue, container.copyOnWrite);
-            this.redactSecretFields(child, true);
-            container.set(key, child.result());
+            return (0, maybeAsync_1.finalizeMaybeAsync)(this.handleCustomObject(child, customObject), () => {
+                if (container.copyOnWrite) {
+                    container.set(key, child.result());
+                }
+            }, this.asyncMode);
         }
-        else if (this.secretManager.isSecretKey(stringKey)) {
-            const child = (0, objectRedactorMutation_1.createContainerMutation)(fieldValue, container.copyOnWrite);
-            this.redactSecretFields(child, false);
-            container.set(key, child.result());
+        const disposition = this.ruleResolver.resolvePathDisposition(pathSegments, key, forceDeepRedaction);
+        const dispositionResult = this.applyFieldDisposition(disposition, fieldValue, key, fieldPath, container);
+        if (dispositionResult instanceof Promise) {
+            return dispositionResult.then((handled) => handled === 'handled'
+                ? undefined
+                : this.applyDefaultSecretRules(fieldValue, key, forceDeepRedaction, container, fieldPath));
         }
-    }
-    handleCustomObjectObjectValueIfMatchTypeSpecified(container, key, matchType) {
-        const fieldValue = container.source[key];
-        if (!(0, types_1.isJsonObject)(fieldValue)) {
+        if (dispositionResult === 'handled') {
             return;
         }
-        (0, objectRedactorCustomObject_1.applyCustomObjectObjectMatchType)(matchType, {
-            deleteKey: () => container.remove(key),
-            redactFull: () => container.set(key, this.redactPrimitive((0, objectRedactorHelpers_1.getStringValue)(fieldValue))),
-            redactDeep: () => {
-                const child = (0, objectRedactorMutation_1.createContainerMutation)(fieldValue, container.copyOnWrite);
-                this.redactSecretFields(child, true);
-                container.set(key, child.result());
-            },
-            redactShallowOrPass: () => {
-                const child = (0, objectRedactorMutation_1.createContainerMutation)(fieldValue, container.copyOnWrite);
-                this.redactSecretFields(child, false);
-                container.set(key, child.result());
-            },
-            ignore: () => undefined
-        });
+        return this.applyDefaultSecretRules(fieldValue, key, forceDeepRedaction, container, fieldPath);
     }
-    handleCustomObjectValueIfPrimitive(container, customObject, key) {
-        if (typeof customObject[key] === 'number') {
-            this.handleCustomObjectPrimitiveValueIfMatchTypeSpecified(container, key, customObject[key]);
+    applyDefaultSecretRules(fieldValue, key, forceDeepRedaction, container, fieldPath) {
+        if (this.ruleResolver.shouldRemoveByKey(key)) {
+            container.remove(key);
             return;
         }
-        const secretKey = (0, objectRedactorHelpers_1.getStringSpecifiedCustomObjectSecretKeyValueIfExists)(container.source, customObject, key);
-        if (secretKey === undefined) {
-            return;
+        if (this.ruleResolver.shouldOpaqueByKey(key)) {
+            return this.setPrimitiveFromValue(container, key, fieldValue);
         }
-        this.handleCustomObjectPrimitiveValueIfStringKeySpecified(container, secretKey, key);
-    }
-    handleCustomObjectPrimitiveValueIfMatchTypeSpecified(container, key, matchValue) {
-        (0, objectRedactorCustomObject_1.applyCustomObjectPrimitiveMatchType)(matchValue, {
-            deleteKey: () => container.remove(key),
-            redactFull: () => container.set(key, this.redactPrimitive((0, objectRedactorHelpers_1.getStringValue)(container.source[key]))),
-            redactScalar: () => container.set(key, this.redactPrimitive(container.source[key])),
-            passThrough: () => undefined
-        });
-    }
-    handleCustomObjectPrimitiveValueIfStringKeySpecified(container, secretKey, key) {
-        if (this.secretManager.isDeleteSecretKey(secretKey)) {
-            container.remove(key);
+        if (Array.isArray(fieldValue)) {
+            return this.redactArrayInObject(fieldValue, key, forceDeepRedaction, container, fieldPath);
         }
-        else {
-            container.set(key, this.redactPrimitiveValueIfSecret(secretKey, container.source[key], false));
+        if ((0, types_1.isJsonObject)(fieldValue)) {
+            return this.redactNestedObject(fieldValue, key, forceDeepRedaction, container, fieldPath);
         }
+        return this.setPrimitiveValueIfSecret(container, key, key, fieldValue, forceDeepRedaction);
     }
-    redactPrimitiveValueIfSecret(key, value, forceDeepRedaction) {
-        return (0, objectRedactorHelpers_1.redactPrimitiveValueIfSecret)(this.secretManager, this.valuePatternMatcher, (primitive) => this.redactPrimitive(primitive), key, value, forceDeepRedaction);
-    }
-    redactPrimitive(value) {
-        return this.primitiveRedactor.redactValueSync(value);
-    }
-    redactAsync(value, copyOnWrite) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const container = (0, objectRedactorMutation_1.createContainerMutation)(value, copyOnWrite);
-            const customObject = this.customObjManager.getMatchingCustomObject(value);
-            if (customObject && (0, types_1.isJsonObject)(value)) {
-                yield this.handleCustomObjectAsync(container, customObject);
-            }
-            else {
-                yield this.redactSecretFieldsAsync(container, false);
-            }
-            return (copyOnWrite ? container.result() : value);
-        });
-    }
-    redactSecretFieldsAsync(container, forceDeepRedaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const record = container.source;
-            for (const key of Object.keys(record)) {
-                const fieldValue = record[key];
-                const customObject = (0, types_1.isJsonObject)(fieldValue) ? this.customObjManager.getMatchingCustomObject(fieldValue) : undefined;
-                if (customObject && (0, types_1.isJsonObject)(fieldValue)) {
-                    const child = (0, objectRedactorMutation_1.createContainerMutation)(fieldValue, container.copyOnWrite);
-                    yield this.handleCustomObjectAsync(child, customObject);
-                    if (container.copyOnWrite) {
-                        container.set(key, child.result());
-                    }
-                }
-                else if (this.secretManager.isDeleteSecretKey(key)) {
-                    container.remove(key);
-                }
-                else if (this.secretManager.isFullSecretKey(key)) {
-                    container.set(key, yield this.redactPrimitiveAsync((0, objectRedactorHelpers_1.getStringValue)(fieldValue)));
-                }
-                else if (Array.isArray(fieldValue)) {
-                    yield this.redactArrayInObjectAsync(fieldValue, key, forceDeepRedaction, container);
-                }
-                else if ((0, types_1.isJsonObject)(fieldValue)) {
-                    yield this.redactNestedObjectAsync(fieldValue, key, forceDeepRedaction, container);
-                }
-                else {
-                    container.set(key, yield this.redactPrimitiveValueIfSecretAsync(key, fieldValue, forceDeepRedaction));
-                }
-            }
-        });
-    }
-    redactArrayInObjectAsync(array, key, forceDeepRedaction, parent) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deepSecretKey = this.secretManager.isDeepSecretKey(key);
-            const result = this.secretManager.isSecretKey(key) || deepSecretKey || forceDeepRedaction
-                ? yield this.redactAllArrayValuesAsync(array, forceDeepRedaction || deepSecretKey, parent.copyOnWrite)
-                : yield this.redactObjectsInArrayAsync(array, parent.copyOnWrite);
-            parent.set(key, result);
-        });
-    }
-    redactObjectsInArrayAsync(array, copyOnWrite) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const container = (0, objectRedactorMutation_1.createContainerMutation)(array, copyOnWrite);
-            for (let index = 0; index < array.length; index++) {
-                const item = array[index];
-                if ((0, types_1.isJsonObject)(item)) {
-                    const customObject = this.customObjManager.getMatchingCustomObject(item);
-                    const child = (0, objectRedactorMutation_1.createContainerMutation)(item, copyOnWrite);
-                    if (customObject) {
-                        yield this.handleCustomObjectAsync(child, customObject);
-                    }
-                    else {
-                        yield this.redactSecretFieldsAsync(child, false);
-                    }
-                    container.set(String(index), child.result());
-                }
-            }
-            return container.result();
-        });
-    }
-    redactAllArrayValuesAsync(array, forceDeepRedaction, copyOnWrite) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const container = (0, objectRedactorMutation_1.createContainerMutation)(array, copyOnWrite);
-            for (let index = 0; index < array.length; index++) {
-                const item = array[index];
-                const key = String(index);
-                if (Array.isArray(item)) {
-                    container.set(key, yield this.redactAllArrayValuesAsync(item, forceDeepRedaction, copyOnWrite));
-                }
-                else if (!(0, types_1.isJsonObject)(item)) {
-                    container.set(key, yield this.redactPrimitiveAsync((0, objectRedactorHelpers_1.toRedactablePrimitive)(item)));
-                }
-                else {
-                    const customObject = this.customObjManager.getMatchingCustomObject(item);
-                    const child = (0, objectRedactorMutation_1.createContainerMutation)(item, copyOnWrite);
-                    if (customObject) {
-                        yield this.handleCustomObjectAsync(child, customObject);
-                    }
-                    else {
-                        yield this.redactSecretFieldsAsync(child, forceDeepRedaction);
-                    }
-                    container.set(key, child.result());
-                }
-            }
-            return container.result();
-        });
-    }
-    redactNestedObjectAsync(value, key, forceDeepRedaction, parent) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const child = (0, objectRedactorMutation_1.createContainerMutation)(value, parent.copyOnWrite);
-            const customObject = this.customObjManager.getMatchingCustomObject(value);
-            if (customObject) {
-                yield this.handleCustomObjectAsync(child, customObject);
-            }
-            else {
-                yield this.redactSecretFieldsAsync(child, forceDeepRedaction || this.secretManager.isDeepSecretKey(key));
-            }
+    redactNestedObject(value, key, forceDeepRedaction, parent, pathSegments) {
+        const child = (0, objectRedactorMutation_1.createContainerMutation)(value, parent.copyOnWrite);
+        const customObject = this.ruleResolver.getMatchingSchema(value);
+        const work = customObject
+            ? this.handleCustomObject(child, customObject)
+            : this.redactSecretFields(child, this.ruleResolver.nestedObjectForceDeepRedaction(key, forceDeepRedaction), pathSegments);
+        return (0, maybeAsync_1.finalizeMaybeAsync)(work, () => {
             if (parent.copyOnWrite) {
                 parent.set(key, child.result());
             }
-        });
-    }
-    handleCustomObjectAsync(container, customObject) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const key of Object.keys(customObject)) {
-                const fieldValue = container.source[key];
-                if (Array.isArray(fieldValue)) {
-                    yield this.handleCustomObjectValueIfArrayAsync(container, key, customObject);
-                }
-                else if ((0, types_1.isJsonObject)(fieldValue)) {
-                    yield this.handleCustomObjectValueIfObjectAsync(container, key, customObject);
-                }
-                else {
-                    yield this.handleCustomObjectValueIfPrimitiveAsync(container, customObject, key);
-                }
-            }
-        });
-    }
-    handleCustomObjectValueIfArrayAsync(container, key, customObject) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stringKey = (0, objectRedactorHelpers_1.getStringSpecifiedCustomObjectSecretKeyValueIfExists)(container.source, customObject, key);
-            if (stringKey !== undefined) {
-                yield this.handleCustomObjectArrayValueIfStringKeySpecifiedAsync(container, key, stringKey);
-            }
-            else {
-                yield this.handleCustomObjectArrayValueIfMatchTypeSpecifiedAsync(container, key, customObject[key]);
-            }
-        });
+        }, this.asyncMode);
     }
-    handleCustomObjectArrayValueIfStringKeySpecifiedAsync(container, key, stringKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fieldValue = container.source[key];
-            if (!Array.isArray(fieldValue)) {
-                return;
-            }
-            if (this.secretManager.isDeleteSecretKey(stringKey)) {
-                container.remove(key);
-            }
-            else if (this.secretManager.isFullSecretKey(stringKey)) {
-                container.set(key, yield this.redactPrimitiveAsync((0, objectRedactorHelpers_1.getStringValue)(fieldValue)));
-            }
-            else {
-                const isDeepSecretKey = this.secretManager.isDeepSecretKey(stringKey);
-                if (isDeepSecretKey || this.secretManager.isSecretKey(stringKey)) {
-                    container.set(key, yield this.redactAllArrayValuesAsync(fieldValue, isDeepSecretKey, container.copyOnWrite));
-                }
-            }
-        });
-    }
-    handleCustomObjectArrayValueIfMatchTypeSpecifiedAsync(container, key, matchType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fieldValue = container.source[key];
-            if (!Array.isArray(fieldValue)) {
-                return;
-            }
-            yield (0, objectRedactorCustomObject_1.applyCustomObjectArrayMatchTypeAsync)(matchType, {
-                deleteKey: () => __awaiter(this, void 0, void 0, function* () { return container.remove(key); }),
-                redactFull: () => __awaiter(this, void 0, void 0, function* () { return container.set(key, yield this.redactPrimitiveAsync((0, objectRedactorHelpers_1.getStringValue)(fieldValue))); }),
-                redactDeep: () => __awaiter(this, void 0, void 0, function* () { return container.set(key, yield this.redactAllArrayValuesAsync(fieldValue, true, container.copyOnWrite)); }),
-                redactShallow: () => __awaiter(this, void 0, void 0, function* () { return container.set(key, yield this.redactAllArrayValuesAsync(fieldValue, false, container.copyOnWrite)); }),
-                passThrough: () => __awaiter(this, void 0, void 0, function* () {
-                    yield this.redactArrayInObjectAsync(fieldValue, key, false, container);
-                })
-            });
-        });
-    }
-    handleCustomObjectValueIfObjectAsync(container, key, customObject) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stringKey = (0, objectRedactorHelpers_1.getStringSpecifiedCustomObjectSecretKeyValueIfExists)(container.source, customObject, key);
-            if (stringKey !== undefined) {
-                yield this.handleCustomObjectObjectValueIfStringKeySpecifiedAsync(container, key, stringKey);
-            }
-            else {
-                yield this.handleCustomObjectObjectValueIfMatchTypeSpecifiedAsync(container, key, customObject[key]);
-            }
-        });
-    }
-    handleCustomObjectObjectValueIfStringKeySpecifiedAsync(container, key, stringKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fieldValue = container.source[key];
-            if (!(0, types_1.isJsonObject)(fieldValue)) {
-                return;
-            }
-            const customObject = this.customObjManager.getMatchingCustomObject(fieldValue);
-            if (customObject) {
-                const child = (0, objectRedactorMutation_1.createContainerMutation)(fieldValue, container.copyOnWrite);
-                yield this.handleCustomObjectAsync(child, customObject);
-                container.set(key, child.result());
-            }
-            else if (this.secretManager.isDeleteSecretKey(stringKey)) {
-                container.remove(key);
-            }
-            else if (this.secretManager.isFullSecretKey(stringKey)) {
-                container.set(key, yield this.redactPrimitiveAsync((0, objectRedactorHelpers_1.getStringValue)(fieldValue)));
-            }
-            else if (this.secretManager.isDeepSecretKey(stringKey)) {
-                const child = (0, objectRedactorMutation_1.createContainerMutation)(fieldValue, container.copyOnWrite);
-                yield this.redactSecretFieldsAsync(child, true);
-                container.set(key, child.result());
-            }
-            else if (this.secretManager.isSecretKey(stringKey)) {
-                const child = (0, objectRedactorMutation_1.createContainerMutation)(fieldValue, container.copyOnWrite);
-                yield this.redactSecretFieldsAsync(child, false);
-                container.set(key, child.result());
-            }
-        });
-    }
-    handleCustomObjectObjectValueIfMatchTypeSpecifiedAsync(container, key, matchType) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fieldValue = container.source[key];
-            if (!(0, types_1.isJsonObject)(fieldValue)) {
-                return;
-            }
-            yield (0, objectRedactorCustomObject_1.applyCustomObjectObjectMatchTypeAsync)(matchType, {
-                deleteKey: () => __awaiter(this, void 0, void 0, function* () { return container.remove(key); }),
-                redactFull: () => __awaiter(this, void 0, void 0, function* () { return container.set(key, yield this.redactPrimitiveAsync((0, objectRedactorHelpers_1.getStringValue)(fieldValue))); }),
-                redactDeep: () => __awaiter(this, void 0, void 0, function* () {
-                    const child = (0, objectRedactorMutation_1.createContainerMutation)(fieldValue, container.copyOnWrite);
-                    yield this.redactSecretFieldsAsync(child, true);
-                    container.set(key, child.result());
-                }),
-                redactShallowOrPass: () => __awaiter(this, void 0, void 0, function* () {
-                    const child = (0, objectRedactorMutation_1.createContainerMutation)(fieldValue, container.copyOnWrite);
-                    yield this.redactSecretFieldsAsync(child, false);
-                    container.set(key, child.result());
-                }),
-                ignore: () => __awaiter(this, void 0, void 0, function* () { return undefined; })
-            });
-        });
-    }
-    handleCustomObjectValueIfPrimitiveAsync(container, customObject, key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (typeof customObject[key] === 'number') {
-                yield this.handleCustomObjectPrimitiveValueIfMatchTypeSpecifiedAsync(container, key, customObject[key]);
-                return;
-            }
-            const secretKey = (0, objectRedactorHelpers_1.getStringSpecifiedCustomObjectSecretKeyValueIfExists)(container.source, customObject, key);
-            if (secretKey === undefined) {
-                return;
-            }
-            yield this.handleCustomObjectPrimitiveValueIfStringKeySpecifiedAsync(container, secretKey, key);
-        });
-    }
-    handleCustomObjectPrimitiveValueIfMatchTypeSpecifiedAsync(container, key, matchValue) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield (0, objectRedactorCustomObject_1.applyCustomObjectPrimitiveMatchTypeAsync)(matchValue, {
-                deleteKey: () => __awaiter(this, void 0, void 0, function* () { return container.remove(key); }),
-                redactFull: () => __awaiter(this, void 0, void 0, function* () { return container.set(key, yield this.redactPrimitiveAsync((0, objectRedactorHelpers_1.getStringValue)(container.source[key]))); }),
-                redactScalar: () => __awaiter(this, void 0, void 0, function* () { return container.set(key, yield this.redactPrimitiveAsync(container.source[key])); }),
-                passThrough: () => __awaiter(this, void 0, void 0, function* () { return undefined; })
+    setPrimitiveValueIfSecret(container, key, secretKey, value, forceDeepRedaction) {
+        const redacted = (0, objectRedactorHelpers_1.redactPrimitiveValueIfSecret)(this.secretManager, this.valuePatternMatcher, (primitive) => this.redactPrimitive(primitive), secretKey, value, forceDeepRedaction);
+        if (redacted instanceof Promise) {
+            return redacted.then((result) => {
+                container.set(key, result);
             });
-        });
-    }
-    handleCustomObjectPrimitiveValueIfStringKeySpecifiedAsync(container, secretKey, key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.secretManager.isDeleteSecretKey(secretKey)) {
-                container.remove(key);
-            }
-            else {
-                container.set(key, yield this.redactPrimitiveValueIfSecretAsync(secretKey, container.source[key], false));
-            }
-        });
-    }
-    redactPrimitiveValueIfSecretAsync(key, value, forceDeepRedaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (0, objectRedactorHelpers_1.redactPrimitiveValueIfSecret)(this.secretManager, this.valuePatternMatcher, (primitive) => this.redactPrimitiveAsync(primitive), key, value, forceDeepRedaction);
-        });
-    }
-    redactPrimitiveAsync(value) {
-        return this.primitiveRedactor.redactValue(value);
+        }
+        container.set(key, redacted);
     }
 }
 exports.ObjectRedactorTraversal = ObjectRedactorTraversal;