zer/lib/dsl.js

Generate Gremlin queries by chaining JavaScript function calls

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createDsl = createDsl;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _2 = require('./');

var _chainBuilder = require('./chain-builder');

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

function wrapBuilder(builder, dsl) {
  return new Proxy(builder, {
    get(target, name, receiver) {
      if (_lodash2.default.has(dsl, name)) {
        return (...args) => {
          const dslChainProxy = dsl[name](...args);
          const dslChain = dslChainProxy[_chainBuilder.chainSymbol];

          target[_chainBuilder.chainSymbol].composeWith(dslChain);

          return wrapBuilder(target, dsl);
        };
      }

      // Handle String properties, but make sure to return a wrappedBuilder
      // so custom steps can be chained after any other steps, either custom or
      // generic.
      if (_lodash2.default.isString(name)) {
        return wrapBuilder(target[name], dsl);
      }

      // Do nothing, ie. forward Symbol objects to wrapped builder
      return target[name];
    },

    apply(target, thisArg, args) {
      // Intercept function call, and ensure we still return a wrappedBuilder
      // so next steps can continue chaining custom steps as well as generic
      // steps.
      const toWrap = target(...args);

      return wrapBuilder(toWrap, dsl);
    }
  });
}
function createDsl(chainCreator, dsl) {
  return new Proxy(chainCreator, {
    get(target, name, receiver) {
      const builder = target[name];

      return wrapBuilder(builder, dsl);
    }
  });
}