Hello! queryql seems pretty useful, and we're considering using it for a service here at TpT.

Do you have any examples of what a Querier would look like if it were to support joins? It seems like the examples deal with single tables.

Say for example our database schema looks like this:

table foo {
   id int
   the_important_stuff string
}

table bar {
   id int
   foo_id int references(foo.id)
   type string
}

And let's say we want to fetch foo by looking at bar.type:

/foos?filter[bar.type]=APPLE

Is that going to require a custom querier function? Something like this:

  'filter:[bar.type]='(builder, { field, operator, value }) {
    return builder.innerJoin('bar', 'foo.id', 'bar.foo_id').where(field, operator, value);
  }

Hi,

I was trying to create a querier that accepts an 'is not' operator but it seems like there is a validation that prevents the values of the filters to be null however the KnexAdapter stablish that the is not operator needs to be null.

Minimal example:

// Querier
class TestQuerier extends QueryQL {
  defineSchema(schema) {
    schema.filter('test', '=')
    schema.filter('testing', '!=')
    schema.filter('testNull', 'is not')
    schema.sort('test')
    schema.sort('testing')
    schema.page()
  }
}

// Test
  test('returns `true` if valid', () => {
    const querier = new TestQuerier(
      {
        filter: { test: 123, testNull: { 'is not': null} },
        sort: 'test',
        page: 2,
      },
      knex('test')
    )

    expect(querier.validate()).toBe(true)
    // ValidationError: filter:testNull[is not] must be one of [array, boolean, number, string]
  })

// If i try to pass a string
  test('returns `true` if valid', () => {
    const querier = new TestQuerier(
      {
        filter: { test: 123, testNull: { 'is not': 'foo'} },
        sort: 'test',
        page: 2,
      },
      knex('test')
    )

    expect(querier.validate()).toBe(true)
    // ValidationError: filter:testNull[is not] must be [null]
  })

I think that it have something to do with the method defineValidation in the FilterParser.

Thanks in advance

I am trying to get QueryQL to work with my Express + MikroORM app. MikroORM uses knex under the hood so I believe I should be able to get this to work without writing an adapter.

My Querier class looks like this:

import QueryQL from '@truepic/queryql';

export class ContentQuerier extends QueryQL {

  get pageDefaults() {
    return {
      size: 12
    };
  }

}

and I attempt to use this class in my route:

const queryBuilder = orm.em.createQueryBuilder(Content);
const query = req.query;
const querier = new ContentQuerier(query, queryBuilder);

but I get a TypeScript error on that final line, flagging the query and queryBuilder properties: src/routes/records.ts:19:40 - error TS2554: Expected 0 arguments, but got 2.

Any idea why TypeScript thinks the QueryQL consturctor doesn't have any parameters? Thanks!

With pagination you often have to return two pieces of information. One is the data itself , the second is the total number of rows that would have been returned without pagination. Is there a feature or best practice to be able to return this second piece of information? I guess I can create a second count querier and share the filters with the querier that queries for the data.

This project is awesome and seems like it would drastically simplify the building of our backend filtering/sorting/pagination, but it falls short in a critical area that I have a requirement for. As the title states, I need to be able to support the AND and OR operators, including nesting of operators. Let's say for example I have this structure:

const sampleNoteData = {
  id: '1',
  status: 'open',
  authorId: '313'
}

I want to be able to build a query that looks like this:

const query = {
  filter: {
    _or: {
      id: {
        in: [1, 3]
      },
      _and: {
        status: 'open',
        authorId: '313'
      }
    }
  }
}

Nothing would look much different in the QueryQL class:

class NotesQuerier extends QueryQL {
  defineSchema(schema) {
    schema.filter('id', 'in');
    schema.filter('status', '=');
    schema.filter('authorId', '=');
  }
}

That would result in a knex query like this:

knex('notes').whereIn('id', [1, 3]).orWhere(function() {
  this.where('status', 'open').andWhere('authorId', '313')
});

Hello,

I am trying to setup a simple filter my code looks like this below:

const QueryQL = require('@truepic/queryql')

class UsedFlag extends QueryQL { defineSchema(dev_CareRecipients) { dev_CareRecipients.filter('UsedFlag', '=') dev_CareRecipients.page() } }

router.get('/', async (req, res) => { const querier = new UsedFlag(req.query, knex('dev_CareRecipients')) let dev_CareRecipients

try {
  dev_CareRecipients = await querier.run()
} catch (error) {
  // Handle validation error, such as by passing to an Express error handler:
  next(error)
}

res.send({ dev_CareRecipients })

})

My url looks like this below

GET http://vm213062fc:3000/dev_CareRecipients?filter[UsedFlag]=false&page=[size]=10 Could you please let me know if I am going wrong anywhere please

Hi! This project looks great! I'm trying to work out how to use it with our app, which currently uses the Sequelize ORM. Am I right that Sequelize needs to have a query builder in order to make an adapter for it? Looks like it doesn't yet: https://github.com/sequelize/sequelize/issues/394. If not, any hints you might be able to provide on what SequelizeAdapter might need to look like would be awesome. Here's part of what I've been trying:

'filter:*'(model, { field, operator, value }) {
        return model.findAll({
            where: {
                [field]: {
                    [this.operatorMap[operator]]: value,
                },
            },
        });
    }

But that returns the actual found elements, not a query builder, so I think that's not the right track?

Hey there, awesome project! I just wanted to point out something that had me stuck for a couple of hours.

Koa's request object does not support nested parsing of the query string (it uses Node's native querystring).

I had to install qs to parse the query string properly.

It could be a good idea to update the docs to make sure people know they need to provide the query object in the correct structure when dealing with nested data.

Hi Thanks for your queryql

This is my defineValidation

defineValidation(schema) { return { 'filter:host[=]': schema.string().required(), 'page:size': schema.number().max(100), } }

When there is no filter in my request it dose not check filters. It checks only if filter is exists in my request. I have to check it myself

if (!req.query.filter || !req.query.filter.host) { res.status(400).send(); return; }

Sometimes "batch" selection requires something like:

/images?filter[id][in][]=229303&filter[id][in][]=393093&filter[id][in][]=102933&filter[id][in][]=3993004&filter[id][in][]=192383....(more and more filters)

And will hit the URL length limitation

So far, depends on the HTTP method, I prefer using the body to filter (e.g: on PUT { body: { filters: [...] } }) But how you advise to do it for GET method?

For most, this should not be a breaking change.

It's only breaking if you directly interact with the schema (i.e., querier.schema) and depend on the underlying data structures of filters or sorts. mapFilterFieldsToOperators has also been renamed to mapFilterNamesToOperators.