graphile-search-plugin/main/index.js

generate search conditions for your tsvector columns

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.PgSearchPlugin = void 0;

var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));

function _templateObject3() {
  var data = (0, _taggedTemplateLiteral2["default"])(["", ".", " @@ ", ""]);

  _templateObject3 = function _templateObject3() {
    return data;
  };

  return data;
}

function _templateObject2() {
  var data = (0, _taggedTemplateLiteral2["default"])(["ts_rank ( ", ".", ", ", " )"]);

  _templateObject2 = function _templateObject2() {
    return data;
  };

  return data;
}

function _templateObject() {
  var data = (0, _taggedTemplateLiteral2["default"])(["websearch_to_tsquery('english', ", ")"]);

  _templateObject = function _templateObject() {
    return data;
  };

  return data;
}

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

var PgSearchPlugin = function PgSearchPlugin(builder, _ref) {
  var _ref$pgSearchPrefix = _ref.pgSearchPrefix,
      pgSearchPrefix = _ref$pgSearchPrefix === void 0 ? 'tsv' : _ref$pgSearchPrefix;
  builder.hook('GraphQLInputObjectType:fields', function addConditionInputField(fields, build, context) {
    var inflection = build.inflection;
    var _context$scope = context.scope,
        isPgCondition = _context$scope.isPgCondition,
        table = _context$scope.pgIntrospection,
        fieldWithHooks = context.fieldWithHooks;

    if (!isPgCondition || !table || table.kind !== 'class') {
      return fields;
    }

    var tsvs = table.attributes.filter(function (attr) {
      return attr.type.name === 'tsvector';
    });
    if (!tsvs.length) return fields;
    return build.extend(fields, tsvs.reduce(function (m, v) {
      var key = inflection.camelCase("".concat(pgSearchPrefix, "_").concat(v.name));
      m[key] = fieldWithHooks(key, {
        type: build.graphql.GraphQLString
      }, {});
      return m;
    }, {}));
  });
  builder.hook('GraphQLObjectType:fields:field:args', function addSqlWhereClause(args, build, context) {
    var sql = build.pgSql,
        inflection = build.inflection;
    var _context$scope2 = context.scope,
        isPgFieldConnection = _context$scope2.isPgFieldConnection,
        isPgFieldSimpleCollection = _context$scope2.isPgFieldSimpleCollection,
        procOrTable = _context$scope2.pgFieldIntrospection,
        tableIfProc = _context$scope2.pgFieldIntrospectionTable,
        addArgDataGenerator = context.addArgDataGenerator;
    var table = tableIfProc || procOrTable;

    if (!isPgFieldConnection && !isPgFieldSimpleCollection || !table || table.kind !== 'class') {
      return args;
    }

    var tsvs = table.attributes.filter(function (attr) {
      return attr.type.name === 'tsvector';
    });
    if (!tsvs.length) return args;

    var _iterator = _createForOfIteratorHelper(tsvs),
        _step;

    try {
      var _loop = function _loop() {
        var tsv = _step.value;
        var conditionFieldName = inflection.camelCase(pgSearchPrefix + '_' + tsv.name);

        var conditionGenerator = function conditionGenerator(value, _ref2) {
          var queryBuilder = _ref2.queryBuilder,
              sql = _ref2.sql,
              sqlTableAlias = _ref2.sqlTableAlias;

          if (value == null) {
            return;
          }

          var tsquery = sql.fragment(_templateObject(), sql.value(value));
          queryBuilder.orderBy(sql.fragment(_templateObject2(), sqlTableAlias, sql.identifier(tsv.name), tsquery), false, false);
          return sql.fragment(_templateObject3(), sqlTableAlias, sql.identifier(tsv.name), tsquery);
        };

        addArgDataGenerator(function conditionSQLBuilder(_ref3) {
          var condition = _ref3.condition;

          if (!condition || !(conditionFieldName in condition)) {
            return {};
          }

          var conditionValue = condition[conditionFieldName];
          return {
            pgQuery: function pgQuery(queryBuilder) {
              var sqlCondition = conditionGenerator(conditionValue, {
                queryBuilder: queryBuilder,
                sql: sql,
                sqlTableAlias: queryBuilder.getTableAlias()
              }, build);

              if (sqlCondition) {
                queryBuilder.where(sqlCondition);
              }
            }
          };
        });
      };

      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        _loop();
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }

    return args;
  }, [], // Make sure we're loaded before PgConnectionArgOrderBy, otherwise
  // ordering added by conditions will be overridden by the default
  // ordering.
  ['PgConnectionArgOrderBy'], []);
};

exports.PgSearchPlugin = PgSearchPlugin;
var _default = PgSearchPlugin;
exports["default"] = _default;