first attempt to generalize aspect implementation

FirstAspectGeneralizationAOP.js

function aspect(joinPoint, { before, around, after }) {
    return function (...args) {
        before && before(this, joinPoint.name, ...args);
        const result = around ? around(this, joinPoint, ...args) : joinPoint.apply(this, args);
        after && after(this, joinPoint.name, result, ...args);
        return result;
    }
}

function loggerAspect(joinPoint, logger) {
    function before() { logger.log("logging before") }
    function after(context, name, result) { logger.log("logging after", "result:", result) }
    return aspect(joinPoint, { before, after })
}


class Person {
        constructor(name) {
                this.name = name
        }

        greeting() {
                return "Hello " + this.name
        }
}

const person = new Person("john doe");

person.greeting();
// <- "Hello john doe"

// Apply logger aspect
Person.prototype.greeting = loggerAspect(Person.prototype.greeting, console)

person.greeting();
// logging before
// logging after result: Hello john doe
// <- "Hello john doe"