@nymphjs/query-parser 1.0.0-beta.13 → 1.0.0-beta.131

package/src/queryParser.test.ts

@@ -1,8 +1,15 @@
 import type { Entity } from '@nymphjs/client';
-import queryParser from './queryParser';
+import queryParser from './queryParser.js';
 
 const BlogPost = function () {} as unknown as typeof Entity;
 const Category = function () {} as unknown as typeof Entity;
+const List = function () {} as unknown as typeof Entity;
+
+const Mail = function () {} as unknown as typeof Entity;
+const Headers = function () {} as unknown as typeof Entity;
+const Body = function () {} as unknown as typeof Entity;
+const Label = function () {} as unknown as typeof Entity;
+const Domain = function () {} as unknown as typeof Entity;
 
 describe('queryParser', () => {
   it('parses a basic query', () => {
@@ -55,13 +62,13 @@ describe('queryParser', () => {
   });
 
   it('gives the correct entity and default fields to bare queries', () => {
-    const query = 'category<{cat search}>';
+    const query = 'category<{Cat search}>';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
       defaultFields: ['text'],
       qrefMap: {
-        cat: {
+        Cat: {
           class: Category,
           defaultFields: ['name'],
         },
@@ -97,13 +104,13 @@ describe('queryParser', () => {
 
   it('parses the example query from the readme', () => {
     const query =
-      'limit:4 foobar (| [archived] mdate<"2 weeks ago") category<{cat Tech}>';
+      'limit:4 foobar (| [archived] mdate<"2 weeks ago") category<{Cat Tech}>';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
       defaultFields: ['title', 'body'],
       qrefMap: {
-        cat: {
+        Cat: {
           class: Category,
           defaultFields: ['name'],
         },
@@ -150,31 +157,809 @@ describe('queryParser', () => {
     ]);
   });
 
-  it('parses all options', () => {
-    const query = 'limit:10 offset:15 reverse:true search';
+  it('parses a query with json value with spaces', () => {
+    const query =
+      'obj={"prop": "my value"} foobar arr=["a value", "another value"]';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
-      defaultFields: ['text'],
+      defaultFields: ['title', 'body'],
     });
 
     expect(options).toEqual({
       class: BlogPost,
-      limit: 10,
-      offset: 15,
-      reverse: true,
     });
 
     expect(selectors).toEqual([
+      {
+        type: '&',
+        equal: [
+          ['obj', { prop: 'my value' }],
+          ['arr', ['a value', 'another value']],
+        ],
+      },
       {
         type: '|',
-        ilike: [['text', '%search%']],
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
       },
     ]);
   });
 
-  it('parses simple equal clauses', () => {
-    const query = 'prop=string';
+  it('parses a query with nested json value with spaces', () => {
+    const query =
+      'obj={"obj": {"sub": "my value"}, "prop": "my value"} foobar arr=["a value", "another value", {"prop": [1, 2, 3]}]';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        equal: [
+          ['obj', { obj: { sub: 'my value' }, prop: 'my value' }],
+          ['arr', ['a value', 'another value', { prop: [1, 2, 3] }]],
+        ],
+      },
+      {
+        type: '|',
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses a query with broken json', () => {
+    const query = 'obj={"obj":"val"';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        equal: [['obj', '{"obj":"val"']],
+      },
+    ]);
+  });
+
+  it('parses a query with broken json and correct json', () => {
+    const query = 'obj={"obj":"val" another={"prop":"value"}';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        equal: [
+          ['another', { prop: 'value' }],
+          ['obj', '{"obj":"val"'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses a query with search', () => {
+    const query = 'limit:4 foobar prop(a search string)';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+      qrefMap: {
+        cat: {
+          class: Category,
+          defaultFields: ['name'],
+        },
+      },
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 4,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        search: [['prop', 'a search string']],
+      },
+      {
+        type: '|',
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses a query with not search', () => {
+    const query = 'limit:4 foobar -prop(a search string)';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+      qrefMap: {
+        cat: {
+          class: Category,
+          defaultFields: ['name'],
+        },
+      },
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 4,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        '!search': [['prop', 'a search string']],
+      },
+      {
+        type: '|',
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses a query with colon search', () => {
+    const query = 'limit:4 foobar prop:string';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+      qrefMap: {
+        cat: {
+          class: Category,
+          defaultFields: ['name'],
+        },
+      },
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 4,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        search: [['prop', 'string']],
+      },
+      {
+        type: '|',
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses a query with not colon search', () => {
+    const query = 'limit:4 foobar -prop:string';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+      qrefMap: {
+        cat: {
+          class: Category,
+          defaultFields: ['name'],
+        },
+      },
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 4,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        '!search': [['prop', 'string']],
+      },
+      {
+        type: '|',
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses a query with search in a selector', () => {
+    const query =
+      'limit:4 foobar (| prop(a search string) prop2("another search string"))';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+      qrefMap: {
+        cat: {
+          class: Category,
+          defaultFields: ['name'],
+        },
+      },
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 4,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        selector: [
+          {
+            type: '|',
+            search: [
+              ['prop', 'a search string'],
+              ['prop2', '"another search string"'],
+            ],
+          },
+        ],
+      },
+      {
+        type: '|',
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses a query with colon search in a selector', () => {
+    const query =
+      'limit:4 foobar (| prop:string prop2:"another search string" -prop3:pickle -prop4:\'another -pickle string\')';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+      qrefMap: {
+        cat: {
+          class: Category,
+          defaultFields: ['name'],
+        },
+      },
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 4,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        selector: [
+          {
+            type: '|',
+            search: [
+              ['prop', 'string'],
+              ['prop2', '"another search string"'],
+            ],
+            '!search': [
+              ['prop3', 'pickle'],
+              ['prop4', "'another -pickle string'"],
+            ],
+          },
+        ],
+      },
+      {
+        type: '|',
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses a query with lt and tag', () => {
+    const query = 'limit:4 foobar mdate<"2 weeks ago" <tag>';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+      qrefMap: {
+        cat: {
+          class: Category,
+          defaultFields: ['name'],
+        },
+      },
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 4,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        lt: [['mdate', null, '2 weeks ago']],
+        tag: ['tag'],
+      },
+      {
+        type: '|',
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses a query with contain that has brackets', () => {
+    const query = 'limit:4 foobar string<"a string with < and > characters">';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+      qrefMap: {
+        cat: {
+          class: Category,
+          defaultFields: ['name'],
+        },
+      },
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 4,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        contain: [['string', 'a string with < and > characters']],
+      },
+      {
+        type: '|',
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses a query with contain that has quotes', () => {
+    const query = 'limit:4 foobar string<"a string with a \\" characters">';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+      qrefMap: {
+        cat: {
+          class: Category,
+          defaultFields: ['name'],
+        },
+      },
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 4,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        contain: [['string', 'a string with a " characters']],
+      },
+      {
+        type: '|',
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses a query with a dash in the property name', () => {
+    const query = 'limit:4 foobar Test-Prop<"a string">';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+      qrefMap: {
+        cat: {
+          class: Category,
+          defaultFields: ['name'],
+        },
+      },
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 4,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        contain: [['Test-Prop', 'a string']],
+      },
+      {
+        type: '|',
+        ilike: [
+          ['title', '%foobar%'],
+          ['body', '%foobar%'],
+        ],
+      },
+    ]);
+  });
+
+  it('parses all options', () => {
+    const query = 'limit:10 offset:15 sort:someProp reverse:true search';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['text'],
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 10,
+      offset: 15,
+      sort: 'someProp',
+      reverse: true,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '|',
+        ilike: [['text', '%search%']],
+      },
+    ]);
+  });
+
+  it('parses null sort option', () => {
+    const query = 'limit:10 offset:15 sort:- reverse:true search';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+      defaultFields: ['text'],
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+      limit: 10,
+      offset: 15,
+      sort: null,
+      reverse: true,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '|',
+        ilike: [['text', '%search%']],
+      },
+    ]);
+  });
+
+  it('parses simple equal clauses', () => {
+    const query = 'prop=string';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        equal: [['prop', 'string']],
+      },
+    ]);
+  });
+
+  it('parses simple not equal clauses', () => {
+    const query = '-prop=string';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        '!equal': [['prop', 'string']],
+      },
+    ]);
+  });
+
+  it('parses quoted equal clauses', () => {
+    const query = 'prop="a string"';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        equal: [['prop', 'a string']],
+      },
+    ]);
+  });
+
+  it('parses quoted not equal clauses', () => {
+    const query = '-prop="a string"';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        '!equal': [['prop', 'a string']],
+      },
+    ]);
+  });
+
+  it('parses json equal clauses', () => {
+    const query = 'prop=true';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        equal: [['prop', true]],
+      },
+    ]);
+  });
+
+  it('parses json not equal clauses', () => {
+    const query = '-prop=true';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        '!equal': [['prop', true]],
+      },
+    ]);
+  });
+
+  it('parses guid clauses', () => {
+    const query = '{111111111111111111111111}';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        guid: ['111111111111111111111111'],
+      },
+    ]);
+  });
+
+  it('parses not guid clauses', () => {
+    const query = '-{111111111111111111111111}';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        '!guid': ['111111111111111111111111'],
+      },
+    ]);
+  });
+
+  it('parses tag clauses', () => {
+    const query = '<tagname>';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        tag: ['tagname'],
+      },
+    ]);
+  });
+
+  it('parses not tag clauses', () => {
+    const query = '-<tagname>';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        '!tag': ['tagname'],
+      },
+    ]);
+  });
+
+  it('parses truthy clauses', () => {
+    const query = '[truthyname]';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        truthy: ['truthyname'],
+      },
+    ]);
+  });
+
+  it('parses not truthy clauses', () => {
+    const query = '-[truthyname]';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        '!truthy': ['truthyname'],
+      },
+    ]);
+  });
+
+  it('parses ref clauses', () => {
+    const query = 'prop<{111111111111111111111111}>';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        ref: [['prop', '111111111111111111111111']],
+      },
+    ]);
+  });
+
+  it('parses not ref clauses', () => {
+    const query = '-prop<{111111111111111111111111}>';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        '!ref': [['prop', '111111111111111111111111']],
+      },
+    ]);
+  });
+
+  it('parses simple contain clauses', () => {
+    const query = 'prop<string>';
+    const [options, ...selectors] = queryParser({
+      query,
+      entityClass: BlogPost,
+    });
+
+    expect(options).toEqual({
+      class: BlogPost,
+    });
+
+    expect(selectors).toEqual([
+      {
+        type: '&',
+        contain: [['prop', 'string']],
+      },
+    ]);
+  });
+
+  it('parses simple not contain clauses', () => {
+    const query = '-prop<string>';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -187,13 +972,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        equal: [['prop', 'string']],
+        '!contain': [['prop', 'string']],
       },
     ]);
   });
 
-  it('parses simple not equal clauses', () => {
-    const query = 'prop!=string';
+  it('parses json contain clauses', () => {
+    const query = 'prop<true>';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -206,13 +991,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!equal': [['prop', 'string']],
+        contain: [['prop', true]],
       },
     ]);
   });
 
-  it('parses quoted equal clauses', () => {
-    const query = 'prop="a string"';
+  it('parses json not contain clauses', () => {
+    const query = '-prop<true>';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -225,13 +1010,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        equal: [['prop', 'a string']],
+        '!contain': [['prop', true]],
       },
     ]);
   });
 
-  it('parses quoted not equal clauses', () => {
-    const query = 'prop!="a string"';
+  it('parses match clauses', () => {
+    const query = 'prop~/regex/';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -244,13 +1029,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!equal': [['prop', 'a string']],
+        match: [['prop', 'regex']],
       },
     ]);
   });
 
-  it('parses json equal clauses', () => {
-    const query = 'prop=true';
+  it('parses not match clauses', () => {
+    const query = '-prop~/regex/';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -263,13 +1048,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        equal: [['prop', true]],
+        '!match': [['prop', 'regex']],
       },
     ]);
   });
 
-  it('parses json not equal clauses', () => {
-    const query = 'prop!=true';
+  it('parses imatch clauses', () => {
+    const query = 'prop~/regex/i';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -282,13 +1067,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!equal': [['prop', true]],
+        imatch: [['prop', 'regex']],
       },
     ]);
   });
 
-  it('parses guid clauses', () => {
-    const query = '{111111111111111111111111}';
+  it('parses not imatch clauses', () => {
+    const query = '-prop~/regex/i';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -301,13 +1086,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        guid: ['111111111111111111111111'],
+        '!imatch': [['prop', 'regex']],
       },
     ]);
   });
 
-  it('parses not guid clauses', () => {
-    const query = '{!111111111111111111111111}';
+  it('parses simple like clauses', () => {
+    const query = 'prop~pattern';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -320,13 +1105,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!guid': ['111111111111111111111111'],
+        like: [['prop', 'pattern']],
       },
     ]);
   });
 
-  it('parses tag clauses', () => {
-    const query = '<tagname>';
+  it('parses simple not like clauses', () => {
+    const query = '-prop~pattern';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -339,13 +1124,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        tag: ['tagname'],
+        '!like': [['prop', 'pattern']],
       },
     ]);
   });
 
-  it('parses not tag clauses', () => {
-    const query = '<!tagname>';
+  it('parses quoted like clauses', () => {
+    const query = 'prop~"a pattern"';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -358,13 +1143,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!tag': ['tagname'],
+        like: [['prop', 'a pattern']],
       },
     ]);
   });
 
-  it('parses truthy clauses', () => {
-    const query = '[truthyname]';
+  it('parses quoted not like clauses', () => {
+    const query = '-prop~"a pattern"';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -377,13 +1162,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        truthy: ['truthyname'],
+        '!like': [['prop', 'a pattern']],
       },
     ]);
   });
 
-  it('parses not truthy clauses', () => {
-    const query = '[!truthyname]';
+  it('parses ilike clauses', () => {
+    const query = 'prop~"a pattern"i';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -396,13 +1181,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!truthy': ['truthyname'],
+        ilike: [['prop', 'a pattern']],
       },
     ]);
   });
 
-  it('parses ref clauses', () => {
-    const query = 'prop<{111111111111111111111111}>';
+  it('parses not ilike clauses', () => {
+    const query = '-prop~"a pattern"i';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -415,13 +1200,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        ref: [['prop', '111111111111111111111111']],
+        '!ilike': [['prop', 'a pattern']],
       },
     ]);
   });
 
-  it('parses not ref clauses', () => {
-    const query = 'prop!<{111111111111111111111111}>';
+  it('parses simple gt clauses', () => {
+    const query = 'prop>30.5';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -434,13 +1219,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!ref': [['prop', '111111111111111111111111']],
+        gt: [['prop', 30.5]],
       },
     ]);
   });
 
-  it('parses simple contain clauses', () => {
-    const query = 'prop<string>';
+  it('parses simple not gt clauses', () => {
+    const query = '-prop>30.5';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -453,13 +1238,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        contain: [['prop', 'string']],
+        '!gt': [['prop', 30.5]],
       },
     ]);
   });
 
-  it('parses simple not contain clauses', () => {
-    const query = 'prop!<string>';
+  it('parses simple relative gt clauses', () => {
+    const query = 'prop>yesterday';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -472,13 +1257,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!contain': [['prop', 'string']],
+        gt: [['prop', null, 'yesterday']],
       },
     ]);
   });
 
-  it('parses json contain clauses', () => {
-    const query = 'prop<true>';
+  it('parses simple relative not gt clauses', () => {
+    const query = '-prop>yesterday';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -491,13 +1276,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        contain: [['prop', true]],
+        '!gt': [['prop', null, 'yesterday']],
       },
     ]);
   });
 
-  it('parses json not contain clauses', () => {
-    const query = 'prop!<true>';
+  it('parses quote relative gt clauses', () => {
+    const query = 'prop>"3 weeks ago"';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -510,13 +1295,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!contain': [['prop', true]],
+        gt: [['prop', null, '3 weeks ago']],
       },
     ]);
   });
 
-  it('parses match clauses', () => {
-    const query = 'prop~/regex/';
+  it('parses quote relative not gt clauses', () => {
+    const query = '-prop>"3 weeks ago"';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -529,13 +1314,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        match: [['prop', 'regex']],
+        '!gt': [['prop', null, '3 weeks ago']],
       },
     ]);
   });
 
-  it('parses not match clauses', () => {
-    const query = 'prop!~/regex/';
+  it('parses simple gte clauses', () => {
+    const query = 'prop>=30.5';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -548,13 +1333,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!match': [['prop', 'regex']],
+        gte: [['prop', 30.5]],
       },
     ]);
   });
 
-  it('parses imatch clauses', () => {
-    const query = 'prop~/regex/i';
+  it('parses simple not gte clauses', () => {
+    const query = '-prop>=30.5';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -567,13 +1352,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        imatch: [['prop', 'regex']],
+        '!gte': [['prop', 30.5]],
       },
     ]);
   });
 
-  it('parses not imatch clauses', () => {
-    const query = 'prop!~/regex/i';
+  it('parses simple relative gte clauses', () => {
+    const query = 'prop>=yesterday';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -586,13 +1371,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!imatch': [['prop', 'regex']],
+        gte: [['prop', null, 'yesterday']],
       },
     ]);
   });
 
-  it('parses simple like clauses', () => {
-    const query = 'prop~pattern';
+  it('parses simple relative not gte clauses', () => {
+    const query = '-prop>=yesterday';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -605,13 +1390,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        like: [['prop', 'pattern']],
+        '!gte': [['prop', null, 'yesterday']],
       },
     ]);
   });
 
-  it('parses simple not like clauses', () => {
-    const query = 'prop!~pattern';
+  it('parses quote relative gte clauses', () => {
+    const query = 'prop>="3 weeks ago"';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -624,13 +1409,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!like': [['prop', 'pattern']],
+        gte: [['prop', null, '3 weeks ago']],
       },
     ]);
   });
 
-  it('parses quoted like clauses', () => {
-    const query = 'prop~"a pattern"';
+  it('parses quote relative not gte clauses', () => {
+    const query = '-prop>="3 weeks ago"';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -643,13 +1428,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        like: [['prop', 'a pattern']],
+        '!gte': [['prop', null, '3 weeks ago']],
       },
     ]);
   });
 
-  it('parses quoted not like clauses', () => {
-    const query = 'prop!~"a pattern"';
+  it('parses simple lt clauses', () => {
+    const query = 'prop<30.5';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -662,13 +1447,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!like': [['prop', 'a pattern']],
+        lt: [['prop', 30.5]],
       },
     ]);
   });
 
-  it('parses ilike clauses', () => {
-    const query = 'prop~"a pattern"i';
+  it('parses simple not lt clauses', () => {
+    const query = '-prop<30.5';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -681,13 +1466,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        ilike: [['prop', 'a pattern']],
+        '!lt': [['prop', 30.5]],
       },
     ]);
   });
 
-  it('parses not ilike clauses', () => {
-    const query = 'prop!~"a pattern"i';
+  it('parses simple relative lt clauses', () => {
+    const query = 'prop<yesterday';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -700,13 +1485,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        '!ilike': [['prop', 'a pattern']],
+        lt: [['prop', null, 'yesterday']],
       },
     ]);
   });
 
-  it('parses simple gt clauses', () => {
-    const query = 'prop>30.5';
+  it('parses simple relative not lt clauses', () => {
+    const query = '-prop<yesterday';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -719,13 +1504,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        gt: [['prop', 30.5]],
+        '!lt': [['prop', null, 'yesterday']],
       },
     ]);
   });
 
-  it('parses simple relative gt clauses', () => {
-    const query = 'prop>yesterday';
+  it('parses quote relative lt clauses', () => {
+    const query = 'prop<"3 weeks ago"';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -738,13 +1523,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        gt: [['prop', null, 'yesterday']],
+        lt: [['prop', null, '3 weeks ago']],
       },
     ]);
   });
 
-  it('parses quote relative gt clauses', () => {
-    const query = 'prop>"3 weeks ago"';
+  it('parses quote relative not lt clauses', () => {
+    const query = '-prop<"3 weeks ago"';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -757,13 +1542,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        gt: [['prop', null, '3 weeks ago']],
+        '!lt': [['prop', null, '3 weeks ago']],
       },
     ]);
   });
 
-  it('parses simple gte clauses', () => {
-    const query = 'prop>=30.5';
+  it('parses simple lte clauses', () => {
+    const query = 'prop<=30.5';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -776,13 +1561,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        gte: [['prop', 30.5]],
+        lte: [['prop', 30.5]],
       },
     ]);
   });
 
-  it('parses simple relative gte clauses', () => {
-    const query = 'prop>=yesterday';
+  it('parses simple not lte clauses', () => {
+    const query = '-prop<=30.5';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -795,13 +1580,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        gte: [['prop', null, 'yesterday']],
+        '!lte': [['prop', 30.5]],
       },
     ]);
   });
 
-  it('parses quote relative gte clauses', () => {
-    const query = 'prop>="3 weeks ago"';
+  it('parses simple relative lte clauses', () => {
+    const query = 'prop<=yesterday';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -814,13 +1599,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        gte: [['prop', null, '3 weeks ago']],
+        lte: [['prop', null, 'yesterday']],
       },
     ]);
   });
 
-  it('parses simple lt clauses', () => {
-    const query = 'prop<30.5';
+  it('parses simple relative not lte clauses', () => {
+    const query = '-prop<=yesterday';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -833,13 +1618,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        lt: [['prop', 30.5]],
+        '!lte': [['prop', null, 'yesterday']],
       },
     ]);
   });
 
-  it('parses simple relative lt clauses', () => {
-    const query = 'prop<yesterday';
+  it('parses quote relative lte clauses', () => {
+    const query = 'prop<="3 weeks ago"';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -852,13 +1637,13 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        lt: [['prop', null, 'yesterday']],
+        lte: [['prop', null, '3 weeks ago']],
       },
     ]);
   });
 
-  it('parses quote relative lt clauses', () => {
-    const query = 'prop<"3 weeks ago"';
+  it('parses quote relative not lte clauses', () => {
+    const query = '-prop<="3 weeks ago"';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -871,13 +1656,14 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        lt: [['prop', null, '3 weeks ago']],
+        '!lte': [['prop', null, '3 weeks ago']],
       },
     ]);
   });
 
-  it('parses simple lte clauses', () => {
-    const query = 'prop<=30.5';
+  it('parses complex selectors', () => {
+    const query =
+      '(! [published] <draft>) (| -cdate>"6 months ago" mdate>"1 month ago")';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -890,13 +1676,25 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        lte: [['prop', 30.5]],
+        selector: [
+          {
+            type: '|',
+            '!gt': [['cdate', null, '6 months ago']],
+            gt: [['mdate', null, '1 month ago']],
+          },
+          {
+            type: '!&',
+            truthy: ['published'],
+            tag: ['draft'],
+          },
+        ],
       },
     ]);
   });
 
-  it('parses simple relative lte clauses', () => {
-    const query = 'prop<=yesterday';
+  it('parses nested selectors', () => {
+    const query =
+      '(! [published] <draft> (| -cdate>"6 months ago" mdate>"1 month ago"))';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -908,17 +1706,37 @@ describe('queryParser', () => {
 
     expect(selectors).toEqual([
       {
-        type: '&',
-        lte: [['prop', null, 'yesterday']],
+        type: '!&',
+        truthy: ['published'],
+        tag: ['draft'],
+        selector: [
+          {
+            type: '|',
+            '!gt': [['cdate', null, '6 months ago']],
+            gt: [['mdate', null, '1 month ago']],
+          },
+        ],
       },
     ]);
   });
 
-  it('parses quote relative lte clauses', () => {
-    const query = 'prop<="3 weeks ago"';
+  it('parses nested qref clauses', () => {
+    const query =
+      'categories<{Category parent<{Category list<{List frosting name(favorite)}>}> -parent<{Category id="sort+newsletters"}>}>';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
+      defaultFields: ['title', 'body'],
+      qrefMap: {
+        Category: {
+          class: Category,
+          defaultFields: ['name'],
+        },
+        List: {
+          class: List,
+          defaultFields: ['name'],
+        },
+      },
     });
 
     expect(options).toEqual({
@@ -928,14 +1746,62 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        lte: [['prop', null, '3 weeks ago']],
+        qref: [
+          [
+            'categories',
+            [
+              { class: Category },
+              {
+                type: '&',
+                qref: [
+                  [
+                    'parent',
+                    [
+                      { class: Category },
+                      {
+                        type: '&',
+                        qref: [
+                          [
+                            'list',
+                            [
+                              { class: List },
+                              {
+                                type: '&',
+                                search: [['name', 'favorite']],
+                              },
+                              {
+                                type: '|',
+                                ilike: [['name', '%frosting%']],
+                              },
+                            ],
+                          ],
+                        ],
+                      },
+                    ],
+                  ],
+                ],
+                '!qref': [
+                  [
+                    'parent',
+                    [
+                      { class: Category },
+                      {
+                        type: '&',
+                        equal: [['id', 'sort+newsletters']],
+                      },
+                    ],
+                  ],
+                ],
+              },
+            ],
+          ],
+        ],
       },
     ]);
   });
 
-  it('parses complex selectors', () => {
-    const query =
-      '(! [published] <draft>) (| cdate>"6 months ago" mdate>"1 month ago")';
+  it('handles badly nested qref', () => {
+    const query = 'categories<{Category parent<{Category id="top"}>';
     const [options, ...selectors] = queryParser({
       query,
       entityClass: BlogPost,
@@ -948,50 +1814,126 @@ describe('queryParser', () => {
     expect(selectors).toEqual([
       {
         type: '&',
-        selector: [
-          {
-            type: '|',
-            gt: [
-              ['cdate', null, '6 months ago'],
-              ['mdate', null, '1 month ago'],
-            ],
-          },
-          {
-            type: '!&',
-            truthy: ['published'],
-            tag: ['draft'],
-          },
-        ],
+        contain: [['categories', '{Category parent<{Category}']],
+        equal: [['id', 'top']],
       },
     ]);
   });
 
-  it('parses nested selectors', () => {
+  it('parses a realistic query', () => {
     const query =
-      '(! [published] <draft> (| cdate>"6 months ago" mdate>"1 month ago"))';
+      'labels<{Label [aggbox]}> -[trash] [delivered] -<spam> -<bare> -<autoreply> -<draft> -<sent> limit:10 reverse:true';
     const [options, ...selectors] = queryParser({
       query,
-      entityClass: BlogPost,
+      entityClass: Mail,
+      defaultFields: ['subject', 'from', 'sender'],
+      qrefMap: {
+        Mail: {
+          class: Mail,
+          defaultFields: ['subject', 'from', 'sender'],
+        },
+        Headers: {
+          class: Headers,
+          defaultFields: ['Message-ID'],
+        },
+        Body: {
+          class: Body,
+          defaultFields: ['text'],
+        },
+        Label: {
+          class: Label,
+          defaultFields: ['name', 'id'],
+        },
+        Domain: {
+          class: Domain,
+          defaultFields: ['fqdn'],
+        },
+      },
+      bareHandler: (
+        input,
+        entityClass,
+        defaultFields = ['subject', 'from', 'sender'],
+      ) => {
+        if (entityClass === Mail) {
+          return {
+            type: '|',
+            search: defaultFields.map((field) => [field, input]) as [
+              string,
+              string,
+            ][],
+            qref: [
+              [
+                'body',
+                [
+                  { class: Body },
+                  {
+                    type: '&',
+                    search: ['text', input],
+                  },
+                ],
+              ],
+              [
+                'body',
+                [
+                  { class: Body },
+                  {
+                    type: '&',
+                    search: ['html', input],
+                  },
+                ],
+              ],
+              [
+                'body',
+                [
+                  { class: Body },
+                  {
+                    type: '&',
+                    search: ['attachments', input],
+                  },
+                ],
+              ],
+            ],
+          };
+        }
+        if (defaultFields.length) {
+          return {
+            type: '|',
+            search: defaultFields.map((field) => [field, input]) as [
+              string,
+              string,
+            ][],
+          };
+        }
+        return {};
+      },
     });
 
     expect(options).toEqual({
-      class: BlogPost,
+      class: Mail,
+      limit: 10,
+      reverse: true,
     });
 
     expect(selectors).toEqual([
       {
-        type: '!&',
-        truthy: ['published'],
-        tag: ['draft'],
-        selector: [
-          {
-            type: '|',
-            gt: [
-              ['cdate', null, '6 months ago'],
-              ['mdate', null, '1 month ago'],
+        type: '&',
+        '!tag': ['spam', 'bare', 'autoreply', 'draft', 'sent'],
+        '!truthy': ['trash'],
+        qref: [
+          [
+            'labels',
+            [
+              {
+                class: Label,
+              },
+              {
+                truthy: ['aggbox'],
+                type: '&',
+              },
             ],
-          },
+          ],
         ],
+        truthy: ['delivered'],
       },
     ]);
   });