We're mixing module styles here. Looking back its clear that I started it by injecting `config` at the module level, but this diff makes it more apparent. We can go two ways here, let the "module level" be a singleton, or refactor instantiation to allow multiple instances. In this case I don't think it technically matters because we only expect to have one of these, but in general I prefer allowing multiple instances.

The style I try to follow is:

* export a single function whose arguments inject "module" level dependencies
    * the arguments substitute for direct `require`s (usually for easier testing)
    * the function returns a Constructor
    * the Constructor arguments inject "instance" level dependencies

You can think of it as a poor man's AMD I suppose, if that helps. The downside is that initialization is a two-part process, module and instance. Also, you can create multiple "Constructor instances" which is weird but not too hard to avoid in practice. The benefit is more control over dependencies which seems to be most helpful in unit testing.

The thing I did wrong here was inject `config` to the module and used it to construct an instance. What I should have done was inject the *parts* of config needed at the module and instance levels separately.

How *I* would like to structure this is put `pool` inside the `MySql` constructor as `this.pool` and `MySql.connect` should have an argument for (connection) options.

What do you think?