Combine

Author: Diego van Haaster

projects/angular-odata/src/lib/resources/query/expressions/base.ts

@@ -34,7 +34,7 @@ export abstract class Expression<T> implements Renderable {
   abstract clone(): Expression<T>;
 
   children() {
-    return this._children;
+    return [...this._children];
   }
 
   length() {
@@ -47,6 +47,7 @@ export abstract class Expression<T> implements Renderable {
       children: this._children.map((c) => c.toJson()),
     };
   }
+
   resolve(parser: any) {
     return parser;
   }

projects/angular-odata/src/lib/resources/query/expressions/expand.ts

@@ -273,4 +273,8 @@ export class ExpandExpression<T> extends Expression<T> {
     if (opts !== undefined) opts(node);
     return this._add(node);
   }
+
+  combine(expression: ExpandExpression<T>): ExpandExpression<T> {
+    return this._add(expression);
+  }
 }

projects/angular-odata/src/lib/resources/query/expressions/filter.ts

@@ -284,4 +284,9 @@ export class FilterExpression<F> extends Expression<F> {
   isof(left: any, type?: string): FilterExpression<F> {
     return this._add(syntax.isof(left, type));
   }
+
+  combine(exp: FilterExpression<F>, connector: FilterConnector = "and"): FilterExpression<F> {
+    return this._add(exp, connector);
+  }
+
 }

projects/angular-odata/src/lib/resources/query/expressions/orderby.ts

@@ -51,6 +51,7 @@ export class OrderByField implements Renderable {
       this.order,
     );
   }
+
   resolve(parser: any) {
     return parser;
   }
@@ -138,4 +139,8 @@ export class OrderByExpression<T> extends Expression<T> {
   descending(field: any) {
     return this._add(new OrderByField(field, 'desc'));
   }
+
+  combine(expression: OrderByExpression<T>): OrderByExpression<T> {
+    return this._add(expression);
+  }
 }

projects/angular-odata/src/lib/resources/query/expressions/search.ts

@@ -180,6 +180,7 @@ export class SearchExpression<T> extends Expression<T> {
       negated: json['negated'],
     });
   }
+
   connector() {
     return this._connector;
   }
@@ -209,4 +210,8 @@ export class SearchExpression<T> extends Expression<T> {
   term(value: any) {
     return this._add(new SearchTerm(value));
   }
+
+  combine(expression: SearchExpression<T>, connector: SearchConnector = 'AND'): SearchExpression<T> {
+    return this._add(expression, connector);
+  }
 }

projects/angular-odata/src/lib/resources/query/expressions/select.ts

@@ -87,4 +87,8 @@ export class SelectExpression<T> extends Expression<T> {
     fields.forEach((f) => this._add(f));
     return this;
   }
+
+  combine(expression: SelectExpression<T>): SelectExpression<T> {
+    return this._add(expression);
+  }
 }

projects/angular-odata/src/lib/resources/query/handlers.ts

@@ -679,6 +679,116 @@ export class ODataQueryOptionsHandler<T> {
     this.paging(options);
   }
 
+  /**
+   * Combine the given query options with the current query. 
+   * @param options The query to be combined. 
+   */
+  combine(options: ODataQueryArguments<T>) {
+    if (options.select !== undefined) {
+      if (options.select instanceof SelectExpression) {
+        const current = this.options.expression(QueryOption.select) as SelectExpression<T>;
+        if (current === undefined) {
+          this.options.expression(
+            QueryOption.select,
+            options.select as SelectExpression<T>,
+          );
+        } else {
+          current.combine(options.select as SelectExpression<T>);
+        }
+      } else if (options.select !== null) {
+        const current = this.options.option(QueryOption.select);
+        if (current === undefined) {
+          this.options.option(QueryOption.select, options.select);
+        } else {
+          this.options.option(QueryOption.select, [current, options.select]);
+        }
+      } else {
+        this.options.remove(QueryOption.select);
+      }
+    }
+    if (options.expand !== undefined) {
+      if (options.expand instanceof ExpandExpression) {
+        const current = this.options.expression(QueryOption.expand) as ExpandExpression<T>;
+        if (current === undefined) {
+          this.options.expression(
+            QueryOption.expand,
+            options.expand as ExpandExpression<T>,
+          );
+        } else {
+          current.combine(options.expand as ExpandExpression<T>);
+        }
+      } else if (options.expand !== null) {
+        const current = this.options.option(QueryOption.expand);
+        if (current === undefined) {
+          this.options.option(QueryOption.expand, options.expand);
+        } 
+      } else {
+        this.options.remove(QueryOption.expand);
+      }
+    }
+    if (options.search !== undefined) {
+      if (options.search instanceof SearchExpression) {
+        const current = this.options.expression(QueryOption.search) as SearchExpression<T>;
+        if (current === undefined) {
+          this.options.expression(
+            QueryOption.search,
+            options.search as SearchExpression<T>,
+          );
+        } else {
+          current.combine(options.search as SearchExpression<T>);
+        }
+      } else if (options.search !== null) {
+        const current = this.options.option(QueryOption.search);
+        if (current === undefined) {
+          this.options.option(QueryOption.search, options.search);
+        }
+      } else {
+        this.options.remove(QueryOption.search);
+      }
+    }
+    if (options.filter !== undefined) {
+      if (options.filter instanceof FilterExpression) {
+        const current = this.options.expression(QueryOption.filter) as FilterExpression<T>;
+        if (current === undefined) {
+          this.options.expression(
+            QueryOption.filter,
+            options.filter as FilterExpression<T>,
+          );
+        } else {
+          current.combine(options.filter as FilterExpression<T>);
+        }
+      } else if (options.filter !== null) {
+        const current = this.options.option(QueryOption.filter);
+        if (current === undefined) {
+          this.options.option(QueryOption.filter, options.filter);
+        }
+      } else {
+        this.options.remove(QueryOption.filter);
+      }
+    }
+    if (options.orderBy !== undefined) {
+      if (options.orderBy instanceof OrderByExpression) {
+        const current = this.options.expression(QueryOption.orderBy) as OrderByExpression<T>;
+        if (current === undefined) {
+          this.options.expression(
+            QueryOption.orderBy,
+            options.orderBy as OrderByExpression<T>,
+          );
+        } else {
+          current.combine(options.orderBy as OrderByExpression<T>);
+        }
+      } else if (options.orderBy !== null) {
+        const current = this.options.option(QueryOption.filter);
+        if (current === undefined) {
+          this.options.option(QueryOption.orderBy, options.orderBy);
+        }
+      } else {
+        this.options.remove(QueryOption.orderBy);
+      }
+    }
+    this.paging(options);
+  }
+
   toJson() {
     return this.options.toJson();
   }