CODEWITHSUNDEEP
javascriptnode.jsconstructordecoratorrepository-pattern
lukas
lukas

Reputation: 23

Decorator in Node - is it possible to iterate through class methods inside the constructor in order to override / apply a decorator to them

Up front I'm new to Node / Javascript an. What I am trying to do is to add a logging to my repository using a decorator function. Therefor I'm trying to iterate though each function from inside the constructor and override it with something like: "
Object.getOwnPropertyNames(Repository.prototype).forEach((func) => this.decorator(func));" My problem is that "Object.getOwnPropertyNames" only returns the function names instead of the actual function. Is there a way to apply this decorator to each function?

"use strict"
const db = require("./Database/db_operations");
const logger = require("./utils/logger")
const {createTables} = require("./Database/db_operations");
const loggingTypes = require("./utils/logginTypes")

class Repository {

    async saveTermin(Termin) {

    }


    async saveToDo(toDo) {
        return await db.saveToDo(toDo);
    }

    async saveAppointment(Appointment) {
        return await db.saveAppointment(Appointment);
    }

    async updateAppointment(Appointment) {
        return await db.updateAppointment(Appointment);
    }

    async deleteAppointment(uuid) {
        return await db.deleteAppointment(uuid);
    }

    async saveAppointmentParticipants(appointment) {
        return await db.saveAppointmentParticipants(appointment);
    }

    async saveAppointmentFiles(appointment) {
        return await db.saveAppointmentFiles(appointment)
    }

    async getAppointmentFiles(appointment) {
        return await db.getAppointmentFiles(appointment)
    }

    async deleteToDo(todo) {
        return await db.deleteToDo(todo)
    }

}



// All functions will be mapped to there type to optimize logging. If a function is not mapped to its type,
// it will be automaticly assigned to the "unspecified type". Logging will still work, but depending on what
// arguments are given and what is returned, the output might not perfectly fit

const funcMapping = new Map();

// GET
funcMapping.set(Repository.prototype.getAppointmentFiles, loggingTypes.GET);
funcMapping.set(Repository.prototype.getAllDatas, loggingTypes.GET);
funcMapping.set(Repository.prototype.getAllToDos, loggingTypes.GET);


//SAVE
funcMapping.set(Repository.prototype.saveToDo, loggingTypes.SAVE);
funcMapping.set(Repository.prototype.saveAppointment, loggingTypes.SAVE);
funcMapping.set(Repository.prototype.saveAppointmentParticipants, loggingTypes.SAVE);

//DELETE
funcMapping.set(Repository.prototype.deleteAppointment, loggingTypes.DELETE);
funcMapping.set(Repository.prototype.deleteToDo, loggingTypes.DELETE);


Object.getOwnPropertyNames(Repository.prototype)
    .forEach(name => {
        const func = Repository.prototype[name];
        // checking loggingTypes - if no type is assigned function will be assigned to "UNASSIGNED".
        // console.log(funcMapping.has(func) +" "+ func.name)
        if (!funcMapping.has(func)) {
            funcMapping.set(func, loggingTypes.UNASSIGNED);
        }
        // function will only be wrapped if logging is enabled.
        if (funcMapping.get(func)[1]) {
            Repository.prototype[name] = async function (...args) {
                // calls the original methode

                const returnValue = await func.apply(this, args);

                const argumentsInArray = Array.prototype.slice.call(args);

                // Put any additional logic here and it will be applied -> magic
                // Logging
                db.writeLogging(logger(func, returnValue, funcMapping.get(func)[0]), args).then(() => {
                    console.log(`Function "${name}()" was successfully logged and saved to Database`)
                }).catch(e => {
                    console.log(`Function "${name}()" could not be logged and saved to Database. ${func}`)
                    console.log(e)
                })
                return returnValue;
            }
        }
    });

module.exports = new Repository();



    const appointment_model = require('../models/Appointment');
    const contact_model = require('../models/Contact');
    const toDo_model = require('../models/ToDo');
    const file_model = require('../models/File');
    const loggingTypes = require("./logginTypes")
    
    
    function log() {
        // returns a function that returns an object. When this function is then called the object is returned
        return function decorator(funcToLog, returnValue, funcType, ...args) {
            // console.log("arguments in logger" + args);
    
            // create prototype for object that later will be passed to database
            const descriptor = function (user, change, changedAt) {
                this.user = user; // some user id
                this.change = change; //
                this.changedAt = changedAt; // date when changes occoured
                this.appointmentId = getUuid(appointment_model);
                this.todoId = getUuid(toDo_model);
                this.contactId = getUuid(contact_model);
                this.fileId = getUuid(file_model);
            };
    
    
            // contains all logging Data about the function beeing called -> name of function, usedArguments and returnValue
            function getChanges(func, funcType, returnValue, args) {
                let changes = null;
                switch (funcType) {
                    case loggingTypes.GET[0]:
                        changes = {
                            funcName: func.name, //
                            funcType: funcType, //
                            dataSetToChange: {...args},
                            newData: returnValue
                        }
                        break;
                    case loggingTypes.SAVE[0]:
                        changes = {
                            funcName: func.name, //
                            funcType: funcType, //
                            dataSetToChange: {...args}, // ?
                            newData: returnValue // could call function here
                        }
                        break;
                    case loggingTypes.UPDATE[0]:
                        changes = {
                            funcName: func.name, //
                            funcType: funcType, //
                            dataSetToChange: {...args},
                            newData: returnValue
                        }
                        break;
                    case loggingTypes.DELETE[0]:
                        changes = {
                            funcName: func.name, //
                            funcType: funcType, //
                            dataSetToChange: {...args},
                            newData: returnValue
                        }
                        break;
                    case loggingTypes.UNASSIGNED[0]:
                        changes = {
                            funcName: func.name, //
                            funcType: funcType, //
                            dataSetToChange: {...args},
                            newData: returnValue
                        }
                }
                return changes;
            }
    
            function getUuid(model_type) {
                let uuid = null;
                console.log(args)
                for (let i = 0; i < args.length; i++) {
                     console.log(args[i])
                     if (args[i] instanceof model_type) {
                         uuid = parseInt(args[i].uuid);
                    }
                    return uuid;
                }
            }
    
    
            return new descriptor("someUserId", JSON.stringify(getChanges(funcToLog, funcType, returnValue, args)), new Date())
        }
    }
    
    module.exports = log();

Upvotes: 2

Views: 1369

Answers (1)

GOTO 0
GOTO 0

Reputation: 47642

You can easily map function names to their values using an intermediate step:

Object.getOwnPropertyNames(Repository.prototype)
.map(name => Repository.prototype[name])
.forEach((func) => this.decorator(func));

Anyway, the constructor is not the best place to do this, because you would end up applying the decorator every time a new instance of the class is created.

I would rather move the whole decorator logic after the class definition, before the assignment to module.exports.

Object.getOwnPropertyNames(Repository.prototype)
.forEach(name => {
    const func = Repository.prototype[name];
    Repository.prototype[name] = function (...args) {
        console.log("Decorator was called");
        const returnValue = func.apply(this, args);

        // Put additional logging logic here...

        return returnValue;
    }
});

Update

In response to what noted in the comments, here is a somewhat more robust version of the code above, with additional precautions you may or may not need:

  • Preserve non-functions
  • Preserve non-value properties
  • Preserve the constructor
  • Preserve non-configurable properties
  • Include properties with symbol keys
Reflect.ownKeys(Repository.prototype).forEach(key => {
    const descriptor = Reflect.getOwnPropertyDescriptor(Repository.prototype, key);
    if (!descriptor.configurable) return;
    const { value } = descriptor;
    if (typeof value !== 'function') return;
    if (value === Repository) return;
    descriptor.value = function (...args) {
        console.log("Decorator was called");
        const returnValue = value.apply(this, args);

        // Additional logging logic here...

        return returnValue;
    };
    Object.defineProperty(Repository.prototype, key, descriptor);
});

Another thing I left out is additional logic to make sure that the decorated methods have the same length and name properties and the same prototype as the original functions. You may want to adjust even more details as you discover additional requirements while using your code.

Upvotes: 1

Related Questions