Merge pull request #53 from pavelsvagr/fix/disable-paths-create-serializer-if-not-exists

🐛 Add disableFields support for not defined serializers.

Author: vlasy

src/serializers.ts

@@ -57,16 +57,45 @@ const serializers: Dictionary<SerializerFn> = {
 const sliceByPrefix = (prefix: string, paths?: string[]) =>
     (paths || []).filter((field) => field.startsWith(prefix)).map((field) => field.slice(prefix.length));
 
+const groupPrefixes = (paths: string[] = []): Map<string, string[] | null> => {
+    const prefixes = new Map<string, string[] | null>();
+
+    paths.forEach((path) => {
+        const [prefix, value] = path.split(/\.(.+)/);
+        if (value && prefixes.has(prefix)) {
+            const prefixValues = prefixes.get(prefix);
+            if (prefixValues) prefixValues.push(value);
+        } else {
+            prefixes.set(prefix, value ? [value] : null);
+        }
+    });
+    return prefixes;
+};
+
 const disablePaths = (paths?: string[]) => {
+    const notDisabled = new Map<string, boolean>(paths?.map((path) => [path, true]) || []);
+
     forEach(serializers, (value, key) => {
         const affectedFields = sliceByPrefix(`${key}.`, paths);
 
         if (affectedFields.length === 0) return;
+        affectedFields.forEach((path) => notDisabled.delete(`${key}.${path}`));
+
         const newSerializer: SerializerFn = (obj: Dictionary<any>) => {
             return omit(value(obj), affectedFields);
         };
         serializers[key] = newSerializer;
     });
+
+    if (!notDisabled.size) return;
+
+    const prefixGroups = groupPrefixes(Array.from(notDisabled.keys()));
+
+    prefixGroups.forEach((fields, prefix) => {
+        serializers[prefix] = (obj: Dictionary<any>) => {
+            return fields === null ? {} : omit(obj, fields);
+        };
+    });
 };
 
 const enablePaths = (paths?: string[]) => {

src/tests/serializers.test.ts

@@ -147,6 +147,92 @@ test('Disable custom path', () => {
     expect(loggerWrites).toBeCalled();
 });
 
+test('Disable path without default serializer', () => {
+    const loggerWrites = jest.fn();
+    const data = {
+        customData: 'Some server data',
+        test: 'test',
+    };
+
+    const logger = loggerFactory({
+        disableFields: ['data.customData'],
+        streams: [
+            {
+                stream: new Writable({
+                    write: (chunk, encoding, next) => {
+                        const json = JSON.parse(chunk);
+                        expect(json.data).toEqual(pick(data, 'test'));
+                        loggerWrites();
+                        next();
+                    },
+                }),
+            },
+        ],
+    });
+
+    logger.info({ data });
+    expect(loggerWrites).toBeCalled();
+});
+
+test('Disable field without default serializer', () => {
+    const loggerWrites = jest.fn();
+    const data = {
+        customData: {
+            test: 'Some server data',
+        },
+        test: 'test',
+    };
+
+    const logger = loggerFactory({
+        disableFields: ['data'],
+        streams: [
+            {
+                stream: new Writable({
+                    write: (chunk, encoding, next) => {
+                        const json = JSON.parse(chunk);
+                        expect(json.data).toEqual({});
+                        loggerWrites();
+                        next();
+                    },
+                }),
+            },
+        ],
+    });
+
+    logger.info({ data });
+    expect(loggerWrites).toBeCalled();
+});
+
+test('Disable fields without default serializer from 1 object', () => {
+    const loggerWrites = jest.fn();
+    const data = {
+        customData: {
+            test: 'Some server data',
+        },
+        customData2: 'Some another data',
+        test: 'test',
+    };
+
+    const logger = loggerFactory({
+        disableFields: ['data.customData', 'data.customData2'],
+        streams: [
+            {
+                stream: new Writable({
+                    write: (chunk, encoding, next) => {
+                        const json = JSON.parse(chunk);
+                        expect(json.data).toEqual(pick(data, 'test'));
+                        loggerWrites();
+                        next();
+                    },
+                }),
+            },
+        ],
+    });
+
+    logger.info({ data });
+    expect(loggerWrites).toBeCalled();
+});
+
 test('Enable custom path', () => {
     const loggerWrites = jest.fn();
     const req = {
@@ -184,10 +270,8 @@ test('Some express headers are enabled by default', () => {
                     write: (chunk, encoding, next) => {
                         const json = JSON.parse(chunk);
                         const validHeaders = ['x-deviceid', 'authorization', 'user-agent'];
-                        validHeaders.forEach(header =>
-                            expect(json.req.headers[header]).toBeDefined()
-                        );
-                        Object.keys(json.req.headers).forEach(header =>
+                        validHeaders.forEach((header) => expect(json.req.headers[header]).toBeDefined());
+                        Object.keys(json.req.headers).forEach((header) =>
                             expect(validHeaders.includes(header)).toBe(true)
                         );
                         loggerWrites();