zer/lib/chain-builder.js

Generate Gremlin queries by chaining JavaScript function calls

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.syntaxSymbol = exports.rendererSymbol = exports.chainSymbol = exports.renderSymbol = exports.inspectSymbol = undefined;
exports.createChainBuilder = createChainBuilder;

var _util = require('util');

var _util2 = _interopRequireDefault(_util);

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _chain = require('./chain');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Given a Chain, returns a Proxy which intercepts all property lookups
 * and function calls and helps adding generic members to that chain.
 *
 * The Proxy target is a no-op function. This allows us to intercept any
 * property lookup (since functions are objects in JavaScript) as well
 * as function calls. The following will be intercepted by the Proxy:
 *    foo.bar
 *    foo.bar()
 *    foo.bar(...args);
 */
function createChainBuilder(chain, render, syntax) {

  const handlers = createProxyHandlers(chain, render, syntax);

  const builder = new Proxy(() => {}, {
    // Intercepts any property lookup, such as foo.bar
    get(target, name, receiver) {
      const handler = handlers[name];

      // Allow intercepting special names, typically Symbol (either Standard/
      // non-Standard).
      if (_lodash2.default.isFunction(handler)) {
        return handler();
      }

      // Add a generic step to the Chain
      chain.addStep(name);

      return receiver;
    },

    // Intercepts any function call, such as foo.bar(...args)
    apply(target, thisArg, args) {
      chain.addArguments(...args);

      return builder;
    }
  });

  return builder;
}
;

const inspectSymbol = exports.inspectSymbol = Symbol('inspect');
const renderSymbol = exports.renderSymbol = Symbol('render');
const chainSymbol = exports.chainSymbol = Symbol('chain');
const rendererSymbol = exports.rendererSymbol = Symbol('renderFunction');
const syntaxSymbol = exports.syntaxSymbol = Symbol('syntax');

function createProxyHandlers(chain, render, syntax) {
  const handlers = {
    [inspectSymbol]() {
      return chain.members;
    },
    [renderSymbol]() {
      return render(chain, syntax);
    },
    [rendererSymbol]() {
      return render;
    },
    [syntaxSymbol]() {
      return syntax;
    },
    [chainSymbol]() {
      return chain;
    },
    toString() {
      return () => render(chain, syntax);
    },
    // Called with console.log(chain) -- single arg
    [_util2.default.inspect.custom]() {
      return () => _util2.default.inspect(render(chain, syntax));
    },
    // Called with console.log('arg', chain) -- multiple args
    [Symbol.toPrimitive]() {
      return () => _util2.default.inspect(render(chain, syntax));
    },
    [Symbol.toStringTag]() {
      return () => render(chain, syntax);
    },
    __repr__() {
      return () => chain.members;
    }
  };

  return handlers;
}