gesundheit/lib/engine.js

// Generated by CoffeeScript 1.4.0
var Engine, anyDB, dialects, fakeEngine, queries, url;

url = require('url');

anyDB = require('any-db');

queries = require('./queries');

dialects = require('./dialects');

module.exports = function() {
  return Engine.create.apply(Engine, arguments);
};

Engine = (function() {
  /*
    ``Engine`` is gesundheits interface to an actual database.
  
    Engines have all of the :ref:`query factory functions <query-factories>`
    attached to them as instance methods that automatically bind created queries
    to the engine. They also have these additionaly methods
  */

  Engine.create = function(dbUrl, poolOptions) {
    /*
        Create an :class:`engine::Engine` instance from an Any-DB_ connect string
        and extra connection pool options, this is exported by gesundheit as
        ``gesundheit.engine(...)``.
    
        :ref:`This example <engine-usage-example>` shows the most common way to set up
        a single default database engine for an application.
    
        .. _Any-DB: https://github.com/grncdr/node-any-db
        .. _Any-DB ConnectionPool: https://github.com/grncdr/node-any-db/blob/master/DESIGN.md#connectionpool
    */

    var ctor, dialect, driverName, pool;
    driverName = url.parse(dbUrl).protocol.replace(':', '').split('+').shift();
    if (driverName === 'fake') {
      return fakeEngine();
    }
    ctor = dialects[driverName];
    if (!(ctor != null)) {
      throw new Error('no such driver: ' + driverName);
    }
    dialect = new ctor;
    pool = anyDB.createPool(dbUrl, poolOptions);
    return new Engine(driverName, dbUrl, pool, dialect);
  };

  function Engine(driver, url, pool, dialect) {
    this.driver = driver;
    this.url = url;
    this.pool = pool;
    this.dialect = dialect;
    queries.mixinFactoryMethods(this);
  }

  Engine.prototype.query = function(statement, params, callback) {
    /*
        Passes arguments directly to the query method of the underlying `Any-DB
        ConnectionPool`_
    */

    var _ref;
    return (_ref = this.pool).query.apply(_ref, arguments);
  };

  Engine.prototype.begin = function(callback) {
    /*
        Start a new transaction and return it.
    
        The returned object behaves exactly like a new engine, but has ``commit``
        and ``rollback`` methods instead of ``close``. (In fact it's an `Any-DB
        Transaction`_ that has had the query factory functions mixed in to it).
    
        .. _Any-DB Transaction: https://github.com/grncdr/node-any-db#transaction
    */

    var tx;
    tx = queries.mixinFactoryMethods(this.pool.begin(callback));
    tx.engine = this;
    tx.compile = this.dialect.compile.bind(this.dialect);
    return tx;
  };

  Engine.prototype.compile = function(root) {
    /*
        Render an AST to a SQL string and collect parameters
    */
    return this.dialect.compile(root);
  };

  Engine.prototype.close = function() {
    /*
        Closes the internal connection pool.
    */
    return this.pool.close();
  };

  return Engine;

})();

fakeEngine = function() {
  /*
    Create a no-op engine that simply returns the compiled SQL and parameter
    array to the result callback. This will be the default until you over-ride
    with ``gesundheit.defaultEngine = myAppEngine``.
  */

  var dialect, engine;
  dialect = new dialects.base;
  engine = {
    compile: function(node) {
      return dialect.compile(node);
    },
    begin: function(cb) {
      if (cb) {
        process.nextTick(cb.bind(null, engine));
      }
      return engine;
    },
    query: function(sql, params, cb) {
      throw new Error("Cannot query with fakeEngine. Do `gesundheit.defaultEngine = gesundheit.engine(url)` before querying");
    },
    close: function() {}
  };
  return engine;
};