Future fix for filters clobbering each other

```
{ node: { id: '' } }
{ node: { type: '' } }
```
The latter wins with former logic.
Now each object is converted to cypher string, then joined together.

Author: CarsonF

src/core/database/query/filters.ts

@@ -11,11 +11,11 @@ import {
 } from 'cypher-query-builder';
 import { PatternCollection } from 'cypher-query-builder/dist/typings/clauses/pattern-clause';
 import { Comparator } from 'cypher-query-builder/dist/typings/clauses/where-comparators';
-import { AndConditions } from 'cypher-query-builder/src/clauses/where-utils';
 import { identity, isFunction } from 'lodash';
 import { AbstractClass, ConditionalKeys } from 'type-fest';
 import { DateTimeFilter } from '~/common';
 import { ACTIVE } from './matching';
+import { WhereAndList } from './where-and-list';
 import { path as pathPattern } from './where-path';
 
 export type Builder<T, K extends keyof T = keyof T> = (
@@ -55,7 +55,7 @@ export const builder =
     const type = filters.constructor === Object ? null : filters.constructor;
     query.comment(type?.name ?? 'Filters');
 
-    let conditions: AndConditions = {};
+    const conditions = [];
     const afters: Array<(query: Query) => Query> = [];
     for (const key of Object.keys(builders)) {
       const value = filters[key];
@@ -70,11 +70,11 @@ export const builder =
         afters.push(res);
         continue;
       }
-      conditions = { ...conditions, ...res };
+      conditions.push(res);
     }
 
-    if (Object.keys(conditions).length > 0) {
-      query.where(conditions);
+    if (conditions.length > 0) {
+      query.where(new WhereAndList(conditions));
     }
     for (const after of afters) {
       after(query);

src/core/database/query/where-and-list.ts

@@ -0,0 +1,26 @@
+import {
+  ParameterBag,
+  Precedence,
+  stringCons,
+  WhereOp,
+} from 'cypher-query-builder';
+import { AnyConditions } from 'cypher-query-builder/dist/typings/clauses/where-utils';
+
+export class WhereAndList extends WhereOp {
+  constructor(public conditions: AnyConditions[]) {
+    super();
+  }
+
+  evaluate(params: ParameterBag, precedence = Precedence.None, name = '') {
+    // If this operator will not be used, precedence should not be altered
+    const newPrecedence =
+      this.conditions.length < 2 ? precedence : Precedence.And;
+    const strings = this.conditions.map((condition) =>
+      stringCons(params, condition, newPrecedence, name),
+    );
+
+    const string = strings.join(' AND ');
+    const braces = precedence !== 0 && precedence > newPrecedence;
+    return braces ? `(${string})` : string;
+  }
+}