Add HAS operator

README.md

@@ -168,4 +168,5 @@ A list of all operators are as follows:
 | `lte`                | less than or equal to        |
 | `startswith`         | starts with                  |
 | `endswith`           | ends with                    |
+| `has`                | array has any element        |
 

lib/sort-and-filter.ts

@@ -1,7 +1,7 @@
 import {
     createParamDecorator, ExecutionContext
 } from '@nestjs/common';
-import { Equal, FindManyOptions, FindOperator, ILike, LessThan, LessThanOrEqual, Like, MoreThan, MoreThanOrEqual, Not, ObjectLiteral, SelectQueryBuilder } from 'typeorm';
+import { Brackets, Equal, FindManyOptions, FindOperator, ILike, In, LessThan, LessThanOrEqual, Like, MoreThan, MoreThanOrEqual, Not, ObjectLiteral, SelectQueryBuilder } from 'typeorm';
 
 export enum SearchOps {
   EQUALS     = 'eq',
@@ -13,7 +13,8 @@ export enum SearchOps {
   GTE        = 'gte',
   LTE        = 'lte',
   STARTSWITH = 'startswith',
-  ENDSWITH   = 'endswith'
+  ENDSWITH   = 'endswith',
+  HAS        = 'has',
 }
 
 export interface SortAndFilterParams {
@@ -107,6 +108,7 @@ const searchOpToOperator = {
   [SearchOps.LT]:         '<',
   [SearchOps.GTE]:        '>=',
   [SearchOps.LTE]:        '<=',
+  [SearchOps.HAS]:         '@>',
 };
 
 function NotEqual<T>(value: T | FindOperator<T>): FindOperator<T> {
@@ -125,17 +127,18 @@ const searchOpToTypeormOperator = {
   [SearchOps.LT]:         LessThan,
   [SearchOps.GTE]:        MoreThanOrEqual,
   [SearchOps.LTE]:        LessThanOrEqual,
+  [SearchOps.HAS]:        In,
 };
 
-function paramTransform(param: string, op: SearchOps) {
+function paramTransform(param: string, op: SearchOps): string {
   switch(op) {
     case SearchOps.CONTAINS:
     case SearchOps.ICONTAINS:
       return `%${param}%`
     case SearchOps.STARTSWITH:
       return `${param}%`
     case SearchOps.ENDSWITH:
-      return `%${param}`
+      return `%${param}`;
   }
 
   return param;
@@ -166,14 +169,25 @@ SelectQueryBuilder.prototype.sortAndFilter = function<Entity>(this: SelectQueryB
     let counter = 0;
     for (let [key, value] of Object.entries(params.filter)) {
       let op = searchOpToOperator[value.op] || '=';
-      let param = paramTransform(value.value, value.op);
-
+
       if (key.includes('.')) {
         key = buildSortAndFilterJoins(this, key, 'Filter');
       }
 
-      this.andWhere(`${this.alias}.${key} ${op} :filterValue${counter}`, { [`filterValue${counter}`]: param });
-      ++counter;
+      this.andWhere(new Brackets(qb => {
+        value.value.split('|').forEach(p => {
+          let filterValue: string | string[];
+          if (value.op === SearchOps.HAS)
+            filterValue = [ p ];
+          else
+            filterValue = paramTransform(p, value.op);
+
+          qb.orWhere(`${this.alias}.${key} ${op} :filterValue${counter}`, {
+            [`filterValue${counter}`]: filterValue
+          });
+          ++counter;
+        });
+      }));
     }
   }
 
@@ -191,15 +205,23 @@ export const sortAndFilter = <T extends ObjectLiteral>(params: SortAndFilterPara
   }
 
   if (params.filter) {
+    options.where = {};
     for (let [key, value] of Object.entries(params.filter)) {
-      options.where ||= {};
 
-      let param = paramTransform(value.value, value.op);
       const op = searchOpToTypeormOperator[value.op] || Equal;
 
-      options.where[key] = op(param);
+      if (value.value.includes('|')) {
+        // NOTE(justin): OR group
+        throw new Error('Repository does not support grouped OR\'s you must use the QueryBuilder.');
+      } else {
+        if (value.op === SearchOps.HAS) {
+          options.where[key] = [value.value];
+        } else {
+          options.where[key] = op(paramTransform(value.value, value.op));
+        }
+      }
     }
   }
 
   return options;
-}
+}

lib/spec/all.spec.ts

@@ -2,10 +2,49 @@ import { expect } from "chai";
 import supertest = require("supertest");
 import { TestFactory } from "./factories";
 import { app } from "./helper";
+import { SomeEnum } from "./test-app/test.entity";
 
 let testFactory = new TestFactory();
 
 
+context('QueryBuilder only', () => {
+	describe('Filtering with OR', () => {
+		it('can do multiple values, which are ORed', async () => {
+			const record = await testFactory.create({ name: 'find me!', email: '[email protected]' });
+			await testFactory.create({ name: 'me too!', email: '[email protected]' });
+			const res = await supertest(app.getHttpServer())
+				.get('/tests?filter=name__contains:find|too')
+
+			const { body } = res;
+
+			expect(body.results.length).to.eq(2);
+		});
+
+
+		it('can filter arrays by multiple values', async () => {
+			const record = await testFactory.create({
+				name: 'name',
+				email: '[email protected]',
+			});
+			record.someArray = [SomeEnum.Choice1, SomeEnum.Choice3];
+			const record2 = await testFactory.create({
+				name: 'another',
+				email: '[email protected]',
+			});
+			record2.someArray = [SomeEnum.Choice3];
+			await record.save();
+			await record2.save();
+
+
+			const url = `/tests?filter=someArray__has:2|1`;
+			const res = await supertest(app.getHttpServer()).get(url);
+			const { body } = res;
+
+			expect(body.results.length).to.eq(1);
+		});
+	});
+});
+
 // NOTE(justin): runs all tests for both repo and query builder controllers
 ['/tests', '/tests/repo'].forEach(api => {
 	context(api, () => {
@@ -82,6 +121,21 @@ let testFactory = new TestFactory();
 				expect(body.results[0].id).to.eq(record.id);
 			});
 
+			it('can filter arrays', async () => {
+				const record = await testFactory.create({
+					name: 'name',
+					email: '[email protected]',
+				});
+				record.someArray = [SomeEnum.Choice1, SomeEnum.Choice3];
+				await record.save();
+
+				const url = `${api}?filter=someArray__has:2`;
+				const res = await supertest(app.getHttpServer()).get(url);
+				const { body } = res;
+
+				expect(body.results.length).to.eq(0);
+			});
+
 			it('can "not equals" filter', async () => {
 				await testFactory.create({ name: 'thing' });
 
@@ -103,7 +157,7 @@ let testFactory = new TestFactory();
 				await future.save();
 
 				const middle = new Date('2025-02-10');
-				const url = `/tests?filter=createdAt__lt:${(middle.toISOString())}`;
+				const url = `${api}?filter=createdAt__lt:${(middle.toISOString())}`;
 				const res = await supertest(app.getHttpServer())
 					.get(url)
 

lib/spec/test-app/app.module.ts

@@ -17,4 +17,4 @@ import { TestModule } from "./test.module";
     TestModule
   ],
 })
-export class AppModule {};
+export class AppModule {};

lib/spec/test-app/test.controller.ts

@@ -16,7 +16,7 @@ export class TestController {
 	    }) paginateParams: PaginateParams,
 	    @SortAndFilter({
 	      sortable: ['name', 'email'],
-	      filterable: ['name', 'email', 'createdAt'],
+	      filterable: ['name', 'email', 'someArray', 'createdAt'],
 	    }) sortAndFilterParams: SortAndFilterParams,
 	): Promise<Paginated<Test>> {
 		return this.testRepository
@@ -32,9 +32,9 @@ export class TestController {
 	    }) paginateParams: PaginateParams,
 	    @SortAndFilter({
 	      sortable: ['name', 'email'],
-	      filterable: ['name', 'email', 'createdAt'],
+	      filterable: ['name', 'email', 'someArray', 'createdAt'],
 	    }) sortAndFilterParams: SortAndFilterParams,
 	): Promise<Paginated<Test>> {
 		return paginate(this.testRepository, paginateParams, sortAndFilter(sortAndFilterParams));
 	}
-}
+}

lib/spec/test-app/test.entity.ts

@@ -1,5 +1,11 @@
 import { BaseEntity, Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from "typeorm";
 
+export enum SomeEnum {
+	Choice1 = '1',
+	Choice2 = '2',
+	Choice3 = '3',
+};
+
 @Entity()
 export class Test extends BaseEntity {
 	@PrimaryGeneratedColumn()
@@ -11,9 +17,17 @@ export class Test extends BaseEntity {
 	@Column()
 	email: string;
 
+	@Column({
+		type: 'enum',
+		enum: SomeEnum,
+		array: true,
+		default: '{}'
+	})
+	someArray: SomeEnum[];
+
 	@UpdateDateColumn()
 	updatedAt: Date;
 
 	@CreateDateColumn()
 	createdAt: Date;
-}
+}