New: adds getters and setters support

.babelrc

@@ -16,7 +16,12 @@
            "legacy": true
         }
       ],
-      "@babel/plugin-proposal-class-properties",
+      [
+        "@babel/plugin-proposal-class-properties",
+        {
+          "loose": true
+        }
+      ],
       "@babel/plugin-proposal-optional-chaining"
     ],
     "ignore": [

src/decorators/class.js

@@ -17,27 +17,45 @@ function getMethodDescriptor(propertyName, target) {
 }
 
 export function classMethodDecorator({ target, methodName, descriptor }, config = {}) {
-    descriptor.value = functionDecorator.call( // eslint-disable-line no-param-reassign
-        this,
-        descriptor.value,
-        {
-            ...config,
-            methodName,
-            serviceName : config.serviceName || target.constructor.name
-        }
-    );
+    const methods = [ 'value', 'initializer' ];
+
+    if (config.getters) methods.push('get');
+    if (config.setters) methods.push('set');
+    const functionDecoratorConfig = {
+        ...config,
+        methodName,
+        serviceName : config.serviceName || target.constructor.name
+    };
+
+    methods
+        .filter(key => descriptor[key] && isFunction(descriptor[key]))
+        .forEach(key => {
+            const old = descriptor[key];
+
+            descriptor[key] = key === 'initializer'// eslint-disable-line no-param-reassign
+                ? function () {
+                    return functionDecorator(
+                        old.call(target),
+                        functionDecoratorConfig
+                    );
+                }
+                : functionDecorator(
+                    descriptor[key],
+                    functionDecoratorConfig
+                );
+        });
 
     return descriptor;
 }
 
 export default function getClassLoggerDecorator(target, config = {}) {
     getMethodNames(target.prototype)
         .filter(methodName => {
-            if (config.include && config.include.includes(methodName)) {
+            if (config.include?.includes(methodName)) {
                 return true;
             }
 
-            if (config.exclude && config.exclude.includes(methodName)) {
+            if (config.exclude?.includes(methodName)) {
                 return false;
             }
 
@@ -48,11 +66,12 @@ export default function getClassLoggerDecorator(target, config = {}) {
         .forEach(methodName => {
             const descriptor = getMethodDescriptor(methodName, target);
 
+            if (!descriptor) return;
+
             Object.defineProperty(
                 target.prototype,
                 methodName,
-                classMethodDecorator.call(
-                    this,
+                classMethodDecorator(
                     { target, methodName, descriptor },
                     { serviceName: target.name,  ...config }
                 )

src/decorators/function.js

@@ -1,5 +1,4 @@
 
-import defaults from '../defaults';
 import {
     isPromise,
     isFunction,
@@ -27,14 +26,13 @@ export default function functionDecorator(method, config = {}) {
         errorLevel
     } = {
         methodName : method.name,
-        ...defaults,
-        ...this,
         ...config
     };
+
     const basicLogObject = {
         service     : config.serviceName,
         method      : methodName,
-        application : this.name,
+        application : config.name,
         level
     };
 

src/index.js

@@ -1,26 +1,29 @@
-import { isClass, isFunction } from './utils';
+import { isClass, isFunction, mergeConfigs } from './utils';
 import {
     functionDecorator,
     classMethodDecorator,
     classDecorator
 } from  './decorators';
+import defaultConfig from './defaults';
+
+const dfc = [ defaultConfig ];
 // TODO change from log(opts)(func) to log(func, opts)
+
 export class Decorator {
-    constructor(opts = {}) {
+    constructor(...opts) {
         return (...args) => {
             return (target, methodName, descriptor) => {
                 if (methodName && descriptor) {
-                    return classMethodDecorator.call(
-                        opts,
+                    return classMethodDecorator(
                         { target, methodName, descriptor },
-                        ...args
+                        ...mergeConfigs(args, opts, dfc)
                     );
                 }
                 if (isClass(target)) {
-                    return classDecorator.call(opts, target, ...args);
+                    return classDecorator(target, ...mergeConfigs(args, opts, dfc));
                 }
                 if (isFunction(target)) {
-                    return functionDecorator.call(opts, target, ...args);
+                    return functionDecorator(target, ...mergeConfigs(args, opts, dfc));
                 }
                 throw new Error(`Can't decorate ${typeof target}, only functions, classes and class methods are allowed`);
             };

tests/package/classes.test.js

@@ -116,3 +116,55 @@ test('include/exlude methods', function () {
     assert.equal(calculator.addOne(15), 16);
     verifyStdout(logger, [ { method: '_sum', params: '[ 15, 1 ]', result: '16' } ], { level: 'info', single: false });
 });
+
+test('Class with getters and setters', function () {
+    const logger = new Logger();
+    const decorator = new Decorator({ logger });
+    const verbose = decorator({ level: 'verbose', getters: true });
+
+    @verbose
+    class Calculator {
+        get one() {
+            return 1;
+        }
+        two = 2
+        addOne = a => {
+            return this._sum(a, this.one);
+        }
+        _sum(a, b) {
+            return a + b;
+        }
+    }
+    const calculator = new Calculator();
+    const res = calculator.addOne(13);
+
+    assert.equal(res, 14);
+    verifyStdout(logger, { params: '[]', result: '1', method: 'one' }, { level: 'verbose' });
+});
+
+
+// test('Class with getters and setters', function () {
+//     const logger = new Logger();
+//     const decorator = new Decorator({ logger });
+//     const verbose = decorator({ level: 'verbose' });
+
+//     decorator({ level: 'info', getters: false });
+//     class Calculator {
+//         get one() {
+//             return 1;
+//         }
+//         two = 2
+//         @verbose
+//         addOne = a => {
+//             return this._sum(a, this.one);
+//         }
+//         _sum(a, b) {
+//             return a + b;
+//         }
+//     }
+//     const calculator = new Calculator();
+//     const res = calculator.addOne(13);
+
+//     assert.equal(res, 14);
+//     verifyStdout(logger, { params: '[ 13 ]', result: '14', method: 'addOne' }, { level: 'verbose' });
+// });