[Proposal] Add fallback support with `limit` and `skip` (for non unique indexed fields). Avoid `sort` arg pollution.

[nodkz]

Current connection implementation does not allow to create Connection which uses mongoose text search or geo search. So connections should support fallback traversing with limit and skip for such queries.

Current implementation pollutes resolveParams.sort and it brings problems when setup a custom sorting. So connections should work with any type of sorting, even return the same record twice.

NB: Connections guarantee that does not return records twice only if used sorting on unique indexed fields.

[nodkz]

First of all, should be changed sort definition in options:

composeWithConnection(userTypeComposer, {
  findResolverName: 'findMany',
  countResolverName: 'count',
  sort: {
    // Sorting key, visible for users in GraphQL Schema
    _ID_ASC: { 
      // Sorting value for ORM/Driver
      value: { _id: 1 },

      // Field names in record, which data will be packed in `cursor`
      //   edges {
      //     cursor   <- base64(cursorData), for this example `cursorData` = { _id: 334ae453 }
      //     node     <- record from DB
      //   }
      // By this fields MUST be created UNIQUE index in database!
      cursorFields: ['_id'], 

      // If for connection query provided `before` argument with above `cursor`.
      // We should construct (`rawQuery`) which will be point to dataset before cursor.
      // Unpacked data from `cursor` will be available in (`cursorData`) argument.
      // PS. All other filter options provided via GraphQL query will be added automatically.
      // ----- [record] -----   sorted dataset, according to above option with `value` name
      // ^^^^^                 `rawQuery` should filter this set    
      beforeCursorQuery: (rawQuery, cursorData, resolveParams) => {
        if (!rawQuery._id) rawQuery._id = {};
        rawQuery._id.$lt = cursorData._id;
      },

      // Constructing `rawQuery` for connection `after` argument.
      // ----- [record] -----   sorted dataset
      //                ^^^^^  `rawQuery` should filter this set    
      afterCursorQuery: (rawQuery, cursorData, resolveParams) => {
        if (!rawQuery._id) rawQuery._id = {};
        rawQuery._id.$gt = cursorData._id;
      },
    },

    _ID_DESC: { 
      value: { _id: -1 },
      cursorFields: ['_id'], 
      beforeCursorQuery: (rawQuery, cursorData, resolveParams) => {
        if (!rawQuery._id) rawQuery._id = {};
        rawQuery._id.$gt = cursorData._id;
      },
      afterCursorQuery: (rawQuery, cursorData, resolveParams) => {
        if (!rawQuery._id) rawQuery._id = {};
        rawQuery._id.$lt = cursorData._id;
      },
    },

    // More complex sorting parameter with 2 fields
    AGE_ID_ASC: {
      value: { age: 1, _id: -1 },
      // By these fields MUST be created COMPOUND UNIQUE index in database!
      cursorFields: ['age', '_id'], 
      beforeCursorQuery: (rawQuery, cursorData, resolveParams) => {
        if (!rawQuery.age) rawQuery.age = {};
        if (!rawQuery._id) rawQuery._id = {};
        rawQuery.age.$lt = cursorData.age;
        rawQuery._id.$gt = cursorData._id;
      },
      afterCursorQuery: (rawQuery, cursorData, resolveParams) => {
        if (!rawQuery.age) rawQuery.age = {};
        if (!rawQuery._id) rawQuery._id = {};
        rawQuery.age.$gt = cursorData.age;
        rawQuery._id.$lt = cursorData._id;
      },
    }
  },
});

[nodkz]

Limit sort fallback algorithm realized in 937a682

[nodkz]

For history: configuration options for previous version 1.0.0

import composeWithConnection from 'graphql-compose-connection';
import userTypeComposer from './user.js';
const OPERATORS_FIELDNAME = '_operators';

composeWithConnection(userTypeComposer, {
  findResolverName: 'findMany',
  countResolverName: 'count',
  sort: {
    _ID_DESC: {
      uniqueFields: ['_id'],
      sortValue: { _id: -1 },
      directionFilter: (filter, cursorData, isBefore) => {
        filter[OPERATORS_FIELDNAME] = filter[OPERATORS_FIELDNAME] || {};
        filter[OPERATORS_FIELDNAME]._id = filter[OPERATORS_FIELDNAME]._id || {};
        if (isBefore) {
          filter[OPERATORS_FIELDNAME]._id.gt = cursorData._id;
        } else {
          filter[OPERATORS_FIELDNAME]._id.lt = cursorData._id;
        }
        return filter;
      },
    },
    AGE_ID_ASC: {
      uniqueFields: ['age', '_id'],
      sortValue: { age: 1, _id: -1 },
      directionFilter: (filter, cursorData, isBefore) => {
        filter[OPERATORS_FIELDNAME] = filter[OPERATORS_FIELDNAME] || {};
        filter[OPERATORS_FIELDNAME]._id = filter[OPERATORS_FIELDNAME]._id || {};
        filter[OPERATORS_FIELDNAME].age = filter[OPERATORS_FIELDNAME].age || {};
        if (isBefore) {
          filter[OPERATORS_FIELDNAME].age.lt = cursorData.age;
          filter[OPERATORS_FIELDNAME]._id.gt = cursorData._id;
        } else {
          filter[OPERATORS_FIELDNAME].age.gt = cursorData.age;
          filter[OPERATORS_FIELDNAME]._id.lt = cursorData._id;
        }
        return filter;
      },
    }
  },
})