graph-common/lib/graph.js

Open Graph API core js lib

(function() {
  var Bootstrap, GQL, Graph, Logger, NodeManager, RouterManager, SchemaManager, StorageManager,
    __slice = [].slice;

  GQL = null;

  SchemaManager = null;

  StorageManager = null;

  RouterManager = null;

  NodeManager = null;

  Bootstrap = null;

  Logger = null;

  Graph = (function() {
    function Graph(configuration_manager, done) {
      this.configure(configuration_manager);
      this.inject();
      this.instantiate(done);
    }

    Graph.prototype.configure = function(configuration_manager) {
      this.configuration_manager = configuration_manager;
      return this.configuration = this.configuration_manager.get_configuration();
    };

    Graph.prototype.inject = function() {
      var di;
      di = this.configuration.di || {};
      GQL = require(di.GQL || './gql');
      Bootstrap = require(di.Bootstrap || './bootstrap');
      StorageManager = require(di.StorageManager || './storage_manager');
      RouterManager = require(di.RouterManager || './router_manager');
      NodeManager = require(di.NodeManager || './node_manager');
      SchemaManager = require(di.SchemaManager || './schema_manager');
      return Logger = require(di.Logger || 'winston');
    };

    Graph.prototype.instantiate = function(done) {
      var self;
      self = this;
      this.logger = Logger;
      this.logger.cli();
      this.logger.level = this.configuration.logLevel || 'info';
      if (this.configuration.logFile) {
        this.logger.add(this.logger.transports.File, {
          level: this.logger.level,
          colorize: true,
          json: false,
          filename: this.configuration.logFile
        });
      }
      this.info('Logging level set:', this.logger.level);
      this.storage_manager = new StorageManager(self, this.configuration.StorageManager);
      this.database = this.storage_manager.database;
      this.schema_manager = new SchemaManager(self, this.configuration.SchemaManager || {
        "Schema": "./schema_schema",
        "Node": "./node_schema",
        "Router": "./router_schema"
      });
      return this.node_manager = new NodeManager(self, function() {
        return self.router_manager = new RouterManager(self, function() {
          if (Bootstrap) {
            Bootstrap.bootstrap(self);
          }
          self.info('Graph API initiated');
          return done();
        });
      });
    };

    Graph.prototype.run = function(gql, callback) {
      var self;
      this.input('GQL>', gql);
      self = this;
      return GQL.parse(gql, function(query) {
        return self.query(query, callback);
      });
    };

    Graph.prototype.query = function(query, callback) {
      var _ref;
      this.debug('Graph> Query:', {
        node: ((_ref = query.node) != null ? _ref.path : void 0) || query.node,
        action: query.action,
        data: query.data
      });
      query.graph = this;
      this.node_manager.query(query);
      this.router_manager.query(query);
      return query.run(callback);
    };

    Graph.prototype.disconnect = function() {
      this.database.disconnect();
      return this.info('Disconnected');
    };

    Graph.prototype.create_node = function(node_data) {
      return this.node_manager.create_node(node_data);
    };

    Graph.prototype.create_router = function(router_data) {
      return this.router_manager.create_router(router_data);
    };

    Graph.prototype.log = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return Logger.log.apply(Logger, args);
    };

    Graph.prototype.error = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return Logger.error.apply(Logger, args);
    };

    Graph.prototype.warn = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return Logger.warn.apply(Logger, args);
    };

    Graph.prototype.help = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return Logger.log.apply(Logger, ['help'].concat(__slice.call(args)));
    };

    Graph.prototype.data = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return Logger.log.apply(Logger, ['data'].concat(__slice.call(args)));
    };

    Graph.prototype.info = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return Logger.info.apply(Logger, args);
    };

    Graph.prototype.debug = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return Logger.log.apply(Logger, ['debug'].concat(__slice.call(args)));
    };

    Graph.prototype.prompt = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return Logger.log.apply(Logger, ['prompt'].concat(__slice.call(args)));
    };

    Graph.prototype.verbose = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return Logger.log.apply(Logger, ['verbose'].concat(__slice.call(args)));
    };

    Graph.prototype.input = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return Logger.log.apply(Logger, ['input'].concat(__slice.call(args)));
    };

    Graph.prototype.silly = function() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      return Logger.log.apply(Logger, ['silly'].concat(__slice.call(args)));
    };

    return Graph;

  })();

  module.exports = Graph;

}).call(this);