@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

package/fesm/modules/utils/utils.service.spec.js

@@ -1,165 +0,0 @@
-import { UtilsService } from './utils.service';
-describe('UtilsService', ()=>{
-    let service;
-    let mockCache;
-    beforeEach(()=>{
-        service = new UtilsService();
-        mockCache = {
-            get: jest.fn(),
-            set: jest.fn(),
-            del: jest.fn()
-        };
-    });
-    describe('getCacheKey', ()=>{
-        it('should build an "all" key from the entity name and params when no id is given', ()=>{
-            const key = service.getCacheKey('product', {
-                page: 1
-            });
-            expect(key).toBe('entity_product_all_{"page":1}');
-        });
-        it('should build a per-id key with a select suffix when params are given', ()=>{
-            const key = service.getCacheKey('product', {
-                fields: [
-                    'name'
-                ]
-            }, 'prod-1');
-            expect(key).toBe('entity_product_id_prod-1_select_{"fields":["name"]}');
-        });
-        it('should build a per-id key without a select suffix when params are falsy', ()=>{
-            const key = service.getCacheKey('product', null, 'prod-1');
-            expect(key).toBe('entity_product_id_prod-1');
-        });
-        it('should prefix the key with the tenant id when provided', ()=>{
-            const key = service.getCacheKey('product', {
-                page: 1
-            }, undefined, 'tenant-a');
-            expect(key).toBe('tenant_tenant-a_entity_product_all_{"page":1}');
-        });
-        it('should prefix a per-id key with the tenant id too', ()=>{
-            const key = service.getCacheKey('product', undefined, 'prod-1', 'tenant-a');
-            expect(key).toBe('tenant_tenant-a_entity_product_id_prod-1');
-        });
-    });
-    describe('trackCacheKey', ()=>{
-        it('should create a new tracking list when none exists yet', async ()=>{
-            mockCache.get.mockResolvedValue(undefined);
-            await service.trackCacheKey('cache-key-1', 'product', mockCache);
-            expect(mockCache.set).toHaveBeenCalledWith('entity_product_keys', [
-                'cache-key-1'
-            ]);
-        });
-        it('should append to an existing tracking list without duplicating entries', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'cache-key-1'
-            ]);
-            await service.trackCacheKey('cache-key-1', 'product', mockCache);
-            expect(mockCache.set).toHaveBeenCalledWith('entity_product_keys', [
-                'cache-key-1'
-            ]);
-        });
-        it('should append a new key alongside existing ones', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'cache-key-1'
-            ]);
-            await service.trackCacheKey('cache-key-2', 'product', mockCache);
-            expect(mockCache.set).toHaveBeenCalledWith('entity_product_keys', [
-                'cache-key-1',
-                'cache-key-2'
-            ]);
-        });
-        it('should scope the tracking key by entity id and tenant', async ()=>{
-            mockCache.get.mockResolvedValue(undefined);
-            await service.trackCacheKey('cache-key-1', 'product', mockCache, 'prod-1', 'tenant-a');
-            expect(mockCache.get).toHaveBeenCalledWith('tenant_tenant-a_entity_product_id_prod-1_keys');
-            expect(mockCache.set).toHaveBeenCalledWith('tenant_tenant-a_entity_product_id_prod-1_keys', [
-                'cache-key-1'
-            ]);
-        });
-        it('should swallow cache read errors without throwing', async ()=>{
-            mockCache.get.mockRejectedValue(new Error('cache down'));
-            await expect(service.trackCacheKey('k', 'product', mockCache)).resolves.toBeUndefined();
-            expect(mockCache.set).not.toHaveBeenCalled();
-        });
-        it('should swallow cache write errors without throwing', async ()=>{
-            mockCache.get.mockResolvedValue([]);
-            mockCache.set.mockRejectedValue(new Error('cache down'));
-            await expect(service.trackCacheKey('k', 'product', mockCache)).resolves.toBeUndefined();
-        });
-    });
-    describe('clearCache', ()=>{
-        it('should delete every tracked key plus the tracking key itself', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'k1',
-                'k2'
-            ]);
-            await service.clearCache('product', mockCache);
-            expect(mockCache.del).toHaveBeenCalledWith('k1');
-            expect(mockCache.del).toHaveBeenCalledWith('k2');
-            expect(mockCache.del).toHaveBeenCalledWith('entity_product_keys');
-            expect(mockCache.del).toHaveBeenCalledTimes(3);
-        });
-        it('should only delete the tracking key when no keys were tracked', async ()=>{
-            mockCache.get.mockResolvedValue(undefined);
-            await service.clearCache('product', mockCache);
-            expect(mockCache.del).toHaveBeenCalledTimes(1);
-            expect(mockCache.del).toHaveBeenCalledWith('entity_product_keys');
-        });
-        it('should continue deleting remaining keys even if one deletion rejects', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'k1',
-                'k2'
-            ]);
-            mockCache.del.mockImplementation((key)=>key === 'k1' ? Promise.reject(new Error('fail')) : Promise.resolve());
-            await service.clearCache('product', mockCache);
-            expect(mockCache.del).toHaveBeenCalledWith('k2');
-            expect(mockCache.del).toHaveBeenCalledWith('entity_product_keys');
-        });
-        it('should scope deletion by entity id and tenant', async ()=>{
-            mockCache.get.mockResolvedValue([
-                'k1'
-            ]);
-            await service.clearCache('product', mockCache, 'prod-1', 'tenant-a');
-            expect(mockCache.get).toHaveBeenCalledWith('tenant_tenant-a_entity_product_id_prod-1_keys');
-        });
-        it('should swallow errors from the initial cache read', async ()=>{
-            mockCache.get.mockRejectedValue(new Error('cache down'));
-            await expect(service.clearCache('product', mockCache)).resolves.toBeUndefined();
-            expect(mockCache.del).not.toHaveBeenCalled();
-        });
-    });
-    describe('transformToSlug', ()=>{
-        it('should lowercase and dash-separate a normal string', ()=>{
-            expect(service.transformToSlug('Hello World')).toBe('hello-world');
-        });
-        it('should collapse runs of non-alphanumeric characters into a single dash', ()=>{
-            expect(service.transformToSlug('Hello   World!!!')).toBe('hello-world-');
-        });
-        it('should trim leading/trailing whitespace before slugging', ()=>{
-            expect(service.transformToSlug('  Hello World  ')).toBe('hello-world');
-        });
-        it('should append a random numeric salt when requested', ()=>{
-            const randomSpy = jest.spyOn(service, 'getRandomInt').mockReturnValue(42);
-            expect(service.transformToSlug('Hello World', true)).toBe('hello-world-42');
-            randomSpy.mockRestore();
-        });
-        it('should handle an empty string', ()=>{
-            expect(service.transformToSlug('')).toBe('');
-        });
-        it('should handle strings that are entirely non-alphanumeric', ()=>{
-            expect(service.transformToSlug('!!!')).toBe('-');
-        });
-    });
-    describe('getRandomInt', ()=>{
-        it('should return the exact bound when min equals max', ()=>{
-            expect(service.getRandomInt(5, 5)).toBe(5);
-        });
-        it('should stay within an inclusive [min, max] range across many samples', ()=>{
-            for(let i = 0; i < 200; i++){
-                const value = service.getRandomInt(1, 10);
-                expect(value).toBeGreaterThanOrEqual(1);
-                expect(value).toBeLessThanOrEqual(10);
-                expect(Number.isInteger(value)).toBe(true);
-            }
-        });
-    });
-});

package/fesm/utils/date-time.util.js

@@ -1,70 +0,0 @@
-function getOffsetMinutes(utcDate, timezone) {
-    const extract = (tz)=>{
-        const parts = new Intl.DateTimeFormat('en-US', {
-            timeZone: tz,
-            year: 'numeric',
-            month: '2-digit',
-            day: '2-digit',
-            hour: '2-digit',
-            minute: '2-digit',
-            second: '2-digit',
-            hour12: false
-        }).formatToParts(utcDate);
-        const p = Object.fromEntries(parts.filter((x)=>x.type !== 'literal').map((x)=>[
-                x.type,
-                parseInt(x.value)
-            ]));
-        return Date.UTC(p['year'], p['month'] - 1, p['day'], p['hour'], p['minute'], p['second']);
-    };
-    return (extract(timezone) - extract('UTC')) / 60_000;
-}
-export function localToUtc(dateStr, timeStr, timezone) {
-    const [year, month, day] = dateStr.split('-').map(Number);
-    const [hours, minutes] = timeStr.split(':').map(Number);
-    const approx = new Date(Date.UTC(year, month - 1, day, hours, minutes, 0));
-    const offset = getOffsetMinutes(approx, timezone);
-    const utcDate = new Date(approx.getTime() - offset * 60_000);
-    // DST boundary guard: re-check offset after adjustment
-    const finalOffset = getOffsetMinutes(utcDate, timezone);
-    return finalOffset !== offset ? new Date(approx.getTime() - finalOffset * 60_000) : utcDate;
-}
-export function utcToLocal(utcDate, timezone) {
-    const d = typeof utcDate === 'string' ? new Date(utcDate) : utcDate;
-    const parts = new Intl.DateTimeFormat('en-CA', {
-        timeZone: timezone,
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-        hour: '2-digit',
-        minute: '2-digit',
-        hour12: false
-    }).formatToParts(d);
-    const p = Object.fromEntries(parts.filter((x)=>x.type !== 'literal').map((x)=>[
-            x.type,
-            x.value
-        ]));
-    // en-CA formats midnight hour as '24' — normalize to '00'
-    const hour = p['hour'] === '24' ? '00' : p['hour'];
-    return {
-        date: `${p['year']}-${p['month']}-${p['day']}`,
-        time: `${hour}:${p['minute']}`,
-        display: new Intl.DateTimeFormat('en-US', {
-            timeZone: timezone,
-            dateStyle: 'medium',
-            timeStyle: 'short'
-        }).format(d)
-    };
-}
-export function formatInTimezone(utcDate, timezone, options = {
-    dateStyle: 'medium',
-    timeStyle: 'short'
-}) {
-    const d = typeof utcDate === 'string' ? new Date(utcDate) : utcDate;
-    return new Intl.DateTimeFormat('en-US', {
-        ...options,
-        timeZone: timezone
-    }).format(d);
-}
-export function getTodayInTimezone(timezone) {
-    return utcToLocal(new Date(), timezone).date;
-}

package/fesm/utils/date-time.util.spec.js

@@ -1,80 +0,0 @@
-import { formatInTimezone, getTodayInTimezone, localToUtc, utcToLocal } from './date-time.util';
-describe('date-time.util', ()=>{
-    describe('localToUtc', ()=>{
-        it('should convert a local date/time in a fixed-offset timezone to UTC', ()=>{
-            // Asia/Dhaka is UTC+6, no DST
-            const result = localToUtc('2026-01-15', '10:00', 'Asia/Dhaka');
-            expect(result.toISOString()).toBe('2026-01-15T04:00:00.000Z');
-        });
-        it('should convert local time in UTC timezone unchanged', ()=>{
-            const result = localToUtc('2026-06-01', '12:30', 'UTC');
-            expect(result.toISOString()).toBe('2026-06-01T12:30:00.000Z');
-        });
-        it('should handle a negative UTC offset timezone (America/New_York in winter, no DST)', ()=>{
-            // America/New_York is UTC-5 in January (standard time, no DST)
-            const result = localToUtc('2026-01-15', '09:00', 'America/New_York');
-            expect(result.toISOString()).toBe('2026-01-15T14:00:00.000Z');
-        });
-        it('should account for DST when converting a summer date in America/New_York (UTC-4)', ()=>{
-            const result = localToUtc('2026-07-15', '09:00', 'America/New_York');
-            expect(result.toISOString()).toBe('2026-07-15T13:00:00.000Z');
-        });
-    });
-    describe('utcToLocal', ()=>{
-        it('should convert a UTC Date to local date/time/display parts', ()=>{
-            const result = utcToLocal(new Date('2026-01-15T04:00:00.000Z'), 'Asia/Dhaka');
-            expect(result.date).toBe('2026-01-15');
-            expect(result.time).toBe('10:00');
-            expect(result.display).toEqual(expect.any(String));
-        });
-        it('should accept a UTC date string as input', ()=>{
-            const result = utcToLocal('2026-01-15T04:00:00.000Z', 'Asia/Dhaka');
-            expect(result.date).toBe('2026-01-15');
-            expect(result.time).toBe('10:00');
-        });
-        it('should normalize midnight (en-CA "24") to "00"', ()=>{
-            // 00:00 Dhaka time == 18:00 UTC the previous day
-            const result = utcToLocal('2026-01-14T18:00:00.000Z', 'Asia/Dhaka');
-            expect(result.date).toBe('2026-01-15');
-            expect(result.time).toBe('00:00');
-        });
-    });
-    describe('formatInTimezone', ()=>{
-        it('should format a date in the given timezone with default options', ()=>{
-            const result = formatInTimezone('2026-01-15T04:00:00.000Z', 'Asia/Dhaka');
-            expect(typeof result).toBe('string');
-            expect(result.length).toBeGreaterThan(0);
-        });
-        it('should respect custom Intl.DateTimeFormatOptions', ()=>{
-            const result = formatInTimezone('2026-01-15T04:00:00.000Z', 'UTC', {
-                year: 'numeric'
-            });
-            expect(result).toBe('2026');
-        });
-        it('should accept a Date object as input', ()=>{
-            const result = formatInTimezone(new Date('2026-01-15T04:00:00.000Z'), 'UTC', {
-                year: 'numeric'
-            });
-            expect(result).toBe('2026');
-        });
-    });
-    describe('getTodayInTimezone', ()=>{
-        it('should return a date string in YYYY-MM-DD format', ()=>{
-            const result = getTodayInTimezone('UTC');
-            expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-        });
-        it('should match utcToLocal(now, timezone).date', ()=>{
-            const now = new Date();
-            const expected = utcToLocal(now, 'Asia/Dhaka').date;
-            expect(getTodayInTimezone('Asia/Dhaka')).toBe(expected);
-        });
-    });
-    describe('round-trip', ()=>{
-        it('should round-trip localToUtc -> utcToLocal for a fixed-offset zone', ()=>{
-            const utc = localToUtc('2026-03-10', '08:15', 'Asia/Dhaka');
-            const back = utcToLocal(utc, 'Asia/Dhaka');
-            expect(back.date).toBe('2026-03-10');
-            expect(back.time).toBe('08:15');
-        });
-    });
-});

package/fesm/utils/event-pattern.util.js

@@ -1,91 +0,0 @@
-const SENSITIVE_KEYS = [
-    'password',
-    'secret',
-    'token',
-    'apikey',
-    'authorization',
-    'salt',
-    'hash',
-    'credential',
-    'accesskey',
-    'accountkey',
-    'privatekey',
-    'connectionstring',
-    'passphrase'
-];
-/**
- * Matched whole, not as a substring - `pass` must be redacted without also
- * redacting `bypassCache`, and a storage row's `key` is a path, not a secret.
- *
- * `config` is the provider settings blob on the storage and email config rows:
- * S3, Azure, SFTP and SMTP credentials live in it, so it never leaves the
- * process, even though the row itself still publishes.
- */ const SENSITIVE_EXACT_KEYS = [
-    'pass',
-    'pwd',
-    'config'
-];
-const REDACTED = '[REDACTED]';
-const CIRCULAR = '[CIRCULAR]';
-const TRUNCATED = '[TRUNCATED]';
-const BINARY = '[BINARY]';
-const MAX_DEPTH = 8;
-/**
- * Matches a dot separated event name against a routing pattern.
- * `*` matches exactly one segment, `#` and `**` match zero or more segments.
- */ export function matchEventPattern(pattern, eventName) {
-    if (pattern === eventName) return true;
-    const patternSegments = pattern.split('.');
-    const nameSegments = eventName.split('.');
-    return matchSegments(patternSegments, 0, nameSegments, 0);
-}
-export function isMultiWildcard(segment) {
-    return segment === '#' || segment === '**';
-}
-function matchSegments(pattern, patternIndex, name, nameIndex) {
-    if (patternIndex === pattern.length) return nameIndex === name.length;
-    const segment = pattern[patternIndex];
-    if (isMultiWildcard(segment)) {
-        for(let skip = nameIndex; skip <= name.length; skip++){
-            if (matchSegments(pattern, patternIndex + 1, name, skip)) return true;
-        }
-        return false;
-    }
-    if (nameIndex === name.length) return false;
-    if (segment !== '*' && segment !== name[nameIndex]) return false;
-    return matchSegments(pattern, patternIndex + 1, name, nameIndex + 1);
-}
-/**
- * Strips credential-like fields before a row leaves the process on an event.
- *
- * Saved TypeORM rows routinely carry bidirectional relations, so the walk
- * tracks the current path and caps its depth - a cycle or a very deep graph
- * must never turn an event into a stack overflow.
- */ export function sanitizeEventPayload(value) {
-    return sanitizeValue(value, new WeakSet(), 0);
-}
-function sanitizeValue(value, ancestors, depth) {
-    if (value === null || typeof value !== 'object') return value;
-    if (value instanceof Date) return value;
-    if (Buffer.isBuffer(value)) return BINARY;
-    if (ancestors.has(value)) return CIRCULAR;
-    if (depth >= MAX_DEPTH) return TRUNCATED;
-    ancestors.add(value);
-    try {
-        if (Array.isArray(value)) {
-            return value.map((item)=>sanitizeValue(item, ancestors, depth + 1));
-        }
-        const sanitized = {};
-        for (const [key, entry] of Object.entries(value)){
-            sanitized[key] = isSensitiveKey(key) ? REDACTED : sanitizeValue(entry, ancestors, depth + 1);
-        }
-        return sanitized;
-    } finally{
-        ancestors.delete(value);
-    }
-}
-function isSensitiveKey(key) {
-    const lowered = key.toLowerCase();
-    if (SENSITIVE_EXACT_KEYS.includes(lowered)) return true;
-    return SENSITIVE_KEYS.some((sensitive)=>lowered.includes(sensitive));
-}

package/fesm/utils/event-pattern.util.spec.js

@@ -1,247 +0,0 @@
-import { isMultiWildcard, matchEventPattern, sanitizeEventPayload } from './event-pattern.util';
-describe('matchEventPattern', ()=>{
-    it('should match an exact event name', ()=>{
-        expect(matchEventPattern('storage.folder.created', 'storage.folder.created')).toBe(true);
-    });
-    it('should not match a different event name', ()=>{
-        expect(matchEventPattern('storage.folder.created', 'storage.folder.updated')).toBe(false);
-    });
-    it('should treat * as exactly one segment', ()=>{
-        expect(matchEventPattern('storage.*.created', 'storage.folder.created')).toBe(true);
-        expect(matchEventPattern('storage.*', 'storage.folder.created')).toBe(false);
-    });
-    it('should treat # and ** as any number of segments', ()=>{
-        expect(matchEventPattern('storage.#', 'storage.folder.created')).toBe(true);
-        expect(matchEventPattern('**', 'auth.appuser.deleted')).toBe(true);
-        expect(matchEventPattern('storage.**', 'storage.folder.created')).toBe(true);
-    });
-    it('should let a multi wildcard match zero segments', ()=>{
-        expect(matchEventPattern('storage.folder.created.#', 'storage.folder.created')).toBe(true);
-    });
-    it('should not match across a different module', ()=>{
-        expect(matchEventPattern('storage.#', 'auth.appuser.created')).toBe(false);
-    });
-});
-describe('isMultiWildcard', ()=>{
-    it.each([
-        [
-            '#',
-            true
-        ],
-        [
-            '**',
-            true
-        ],
-        [
-            '*',
-            false
-        ],
-        [
-            'folder',
-            false
-        ]
-    ])('should classify %s as %s', (segment, expected)=>{
-        expect(isMultiWildcard(segment)).toBe(expected);
-    });
-});
-describe('sanitizeEventPayload', ()=>{
-    it('should redact credential-like fields', ()=>{
-        const result = sanitizeEventPayload({
-            id: '1',
-            password: 'secret',
-            apiKey: 'k'
-        });
-        expect(result).toEqual({
-            id: '1',
-            password: '[REDACTED]',
-            apiKey: '[REDACTED]'
-        });
-    });
-    it('should redact the whole provider settings blob of a storage or email config row', ()=>{
-        const result = sanitizeEventPayload({
-            name: 'primary-s3',
-            provider: 's3',
-            isActive: true,
-            config: {
-                region: 'us-east-1',
-                bucket: 'assets',
-                accessKeyId: 'AKIA...',
-                secretAccessKey: 's3cr3t'
-            }
-        });
-        expect(result).toEqual({
-            name: 'primary-s3',
-            provider: 's3',
-            isActive: true,
-            config: '[REDACTED]'
-        });
-    });
-    it('should redact the credential keys used by the storage and email providers', ()=>{
-        const result = sanitizeEventPayload({
-            settings: {
-                region: 'us-east-1',
-                bucket: 'assets',
-                accessKeyId: 'AKIA...',
-                secretAccessKey: 's3cr3t',
-                accountKey: 'azure-key',
-                privateKey: '-----BEGIN...',
-                connectionString: 'DefaultEndpointsProtocol=...;AccountKey=abc',
-                auth: {
-                    user: 'mailer',
-                    pass: 'hunter2'
-                }
-            }
-        });
-        expect(result).toEqual({
-            settings: {
-                region: 'us-east-1',
-                bucket: 'assets',
-                accessKeyId: '[REDACTED]',
-                secretAccessKey: '[REDACTED]',
-                accountKey: '[REDACTED]',
-                privateKey: '[REDACTED]',
-                connectionString: '[REDACTED]',
-                auth: {
-                    user: 'mailer',
-                    pass: '[REDACTED]'
-                }
-            }
-        });
-    });
-    it('should not over-redact keys that merely contain a credential word', ()=>{
-        const result = sanitizeEventPayload({
-            key: 'uploads/2026/report.pdf',
-            bypassCache: true,
-            passengerCount: 4
-        });
-        expect(result).toEqual({
-            key: 'uploads/2026/report.pdf',
-            bypassCache: true,
-            passengerCount: 4
-        });
-    });
-    it('should redact nested fields', ()=>{
-        const result = sanitizeEventPayload({
-            user: {
-                name: 'Ada',
-                passwordHash: 'x'
-            }
-        });
-        expect(result).toEqual({
-            user: {
-                name: 'Ada',
-                passwordHash: '[REDACTED]'
-            }
-        });
-    });
-    it('should map over arrays', ()=>{
-        const result = sanitizeEventPayload([
-            {
-                token: 't'
-            },
-            {
-                token: 'u'
-            }
-        ]);
-        expect(result).toEqual([
-            {
-                token: '[REDACTED]'
-            },
-            {
-                token: '[REDACTED]'
-            }
-        ]);
-    });
-    it('should leave dates and primitives untouched', ()=>{
-        const date = new Date('2026-01-01T00:00:00.000Z');
-        expect(sanitizeEventPayload({
-            createdAt: date,
-            count: 3
-        })).toEqual({
-            createdAt: date,
-            count: 3
-        });
-    });
-    it('should mark a circular relation instead of recursing forever', ()=>{
-        const folder = {
-            id: 'folder-1',
-            name: 'Docs'
-        };
-        const file = {
-            id: 'file-1',
-            folder
-        };
-        folder.files = [
-            file
-        ];
-        expect(sanitizeEventPayload(folder)).toEqual({
-            id: 'folder-1',
-            name: 'Docs',
-            files: [
-                {
-                    id: 'file-1',
-                    folder: '[CIRCULAR]'
-                }
-            ]
-        });
-    });
-    it('should survive a self referencing row', ()=>{
-        const row = {
-            id: '1'
-        };
-        row.self = row;
-        expect(()=>sanitizeEventPayload(row)).not.toThrow();
-        expect(sanitizeEventPayload(row)).toEqual({
-            id: '1',
-            self: '[CIRCULAR]'
-        });
-    });
-    it('should repeat a shared row rather than calling the second one circular', ()=>{
-        const shared = {
-            id: 'shared'
-        };
-        expect(sanitizeEventPayload([
-            {
-                a: shared
-            },
-            {
-                b: shared
-            }
-        ])).toEqual([
-            {
-                a: {
-                    id: 'shared'
-                }
-            },
-            {
-                b: {
-                    id: 'shared'
-                }
-            }
-        ]);
-    });
-    it('should truncate a graph deeper than the depth cap', ()=>{
-        const deep = {};
-        let cursor = deep;
-        for(let level = 0; level < 12; level++){
-            const next = {};
-            cursor.child = next;
-            cursor = next;
-        }
-        let result = sanitizeEventPayload(deep);
-        for(let level = 0; level < 7; level++){
-            result = result.child;
-        }
-        expect(result.child).toBe('[TRUNCATED]');
-    });
-    it('should replace a buffer with a marker instead of exploding it into indexes', ()=>{
-        const result = sanitizeEventPayload({
-            id: '1',
-            content: Buffer.from('hello')
-        });
-        expect(result).toEqual({
-            id: '1',
-            content: '[BINARY]'
-        });
-    });
-});