sanitize-data/dist/index.d.ts

🧼 A lightweight utility for sanitization, redacting, masking, and randomizing sensitive or structured data in JavaScript/TypeScript.

type SanitizerMode = "mask" | "redact" | "random" | "preserve";
interface SanitizerRules {
    [key: string]: SanitizerMode;
}
interface SanitizeOptions {
    /**
     * A map of keys to sanitization modes.
     * Keys can be dot-paths, shallow keys, or glob patterns.
     *
     * Examples:
     *   { email: "redact" } // redact any "email" key at any level (see keyMatchAnyLevel)
     *   { "user.email": "mask" } // mask only user.email
     *   { "user.*": "mask" } // mask all direct children of user
     *   { "user.**": "redact" } // redact all nested keys under user
     */
    rules?: {
        [key: string]: SanitizerMode;
    };
    /**
     * Optional fallback mode if no rule matches a key.
     * @default "preserve"
     *
     * Example:
     *   { defaultMode: "mask" }
     */
    defaultMode?: SanitizerMode;
    /**
     * Optional string to use for redacted values.
     * @default "[REDACTED]"
     *
     * Example:
     *   { redactString: "<REMOVED>" }
     */
    redactString?: string;
    /**
     * Optional string to use for random values.
     * Used for objects/arrays or unknown types.
     * @default "[random]"
     *
     * Example:
     *   { randomString: "<RANDOM>" }
     */
    randomString?: string;
    /**
     * Optional custom random value generators per type.
     * Keys: "number" | "string" | "boolean" | "array" | "object"
     *
     * Example:
     *   {
     *     randomGenerators: {
     *       number: () => 42,
     *       string: () => "RANDOM",
     *       array: arr => arr.map(() => "X")
     *     }
     *   }
     */
    randomGenerators?: Partial<{
        number: () => unknown;
        string: () => unknown;
        boolean: () => unknown;
        array: (arr: any[]) => unknown;
        object: (obj: object) => unknown;
    }>;
    /**
     * Optional custom random value generators for specific fields (by path or key).
     * Keys: field name or dot-path, value: function (value, path) => unknown
     *
     * Example:
     *   {
     *     randomFieldGenerators: {
     *       name: () => "RANDOM_NAME",
     *       "user.surname": () => "RANDOM_SURNAME"
     *     }
     *   }
     */
    randomFieldGenerators?: Record<string, (value: unknown, path: string) => unknown>;
    /**
     * If true, randomFieldGenerators keys are matched case-insensitively (default: false)
     *
     * Example:
     *   { randomFieldGeneratorsCaseInsensitive: true }
     */
    randomFieldGeneratorsCaseInsensitive?: boolean;
    /**
     * If true, rules with a plain key (e.g. "email") match at any level (default: true).
     * If false, such rules only match top-level keys.
     *
     * Example:
     *   { keyMatchAnyLevel: false }
     */
    keyMatchAnyLevel?: boolean;
}
declare function sanitize(input: any, options: SanitizeOptions): any;

export { SanitizeOptions, SanitizerMode, SanitizerRules, sanitize };