Node.js memory leaks?

Question

I have some code below that I'm using in my Express.js app to centralize some acl logic. If the function returns true or false explicitly the middleware can handle the next call. But if it doesn't return it's up to the authorize logic to execute next() whenever it's finished doing it's thing.

To avoid having to write out the error data, I want to just pass in an error() function that can be called, which just calls the next function internally.

Someone told me that this can lead to some kind of memory leaks since the next function is in it's own closure and referencing it from outside. I see similar techniques being used in a lot of examples online, but I'm still quite new to Node.js so wondering if there is any truth to this?

this.router.use(function (req, res, next) {
    var err = {
            code: 403,
            exception: 'UnauthorizedException',
            data: {}
        },
        error = function () {
            next(err);
        },
        authorize = app.route.authorize(req, res, next, error);

    if (authorize === false) {
        next(err);
    }
    else if (authorize === true) {
        next();
    }
});

EDIT:Remove variables

this.router.use(function (req, res, next) {
    var authorize = app.route.authorize(req, res, next, function () {
        next({
            code: 403,
            exception: 'UnauthorizedException',
            data: {}
        });
    });

    if (authorize === false) {
        next({
            code: 403,
            exception: 'UnauthorizedException',
            data: {}
        });
    }
    else if (authorize === true) {
        next();
    }
});

Answer 1

When you set up the middleware, the .use() method is called there once, the anonymous handler/middleware is written to memory once, and it's that same middleware function that gets called for each new request.

The err variable is instantiated every time the middleware runs, and it's a different object. Had you put it outside and into the closure scope of .use(), it would then be the same object.

It is then passed to next and next is very likely another middleware function that gets instantiated once and stays the same in memory which persists and grabs onto its closure access.

But then, when the next function finishes running, the object that err points to would lose its references -- it should be garbage-collected.