fix(filters): make sure clauses is always initialized

src/api/NestedRestriction.ts

@@ -19,7 +19,7 @@ export class NestedRestriction {
     }
 
     /** The clauses containing the nested restrictions and their logical operators. */
-    public clauses = [] as Clause[];
+    public clauses?: Clause[];
 
     constructor(...clauses: Clause[]) {
         this.clauses = clauses;
@@ -37,8 +37,10 @@ export class NestedRestriction {
 
     /** Adds an additional clause. */
     private withClause(clause: Clause) {
+        if (!this.clauses) {
+            this.clauses = [] as Clause[];
+        }
         this.clauses.push(clause);
         return this;
     }
-
 }

src/dao/AbstractDAO.ts

@@ -165,9 +165,11 @@ export abstract class AbstractDAO<K, T> extends BaseDAO implements IValueProvide
       if (visitor.onRestriction) { visitor.onRestriction(restriction); }
     } else if (restriction instanceof NestedRestriction) {
       if (visitor.onNestedRestriction) { visitor.onNestedRestriction(restriction); }
-      restriction.clauses.forEach((c) => {
-        self.visitClause(c, visitor);
-      });
+      if (restriction.clauses) {
+        restriction.clauses.forEach((c) => {
+          self.visitClause(c, visitor);
+        });
+      }
     } else {
       log.warn('Restriction is of an unknown type: ' + JSON.stringify(restriction));
     }
@@ -181,9 +183,11 @@ export abstract class AbstractDAO<K, T> extends BaseDAO implements IValueProvide
   protected visitFilter(filter: Filter, visitor: IFilterVisitor) {
     const self = this;
     if (visitor.onFilter) { visitor.onFilter(filter); }
-    filter.clauses.forEach((clause) => {
-      self.visitClause(clause, visitor);
-    });
+    if (filter.clauses) {
+      filter.clauses.forEach((clause) => {
+        self.visitClause(clause, visitor);
+      });
+    }
   }
 
   /**

src/dao/V1FilterProcessor.ts

@@ -35,6 +35,10 @@ export class V1FilterProcessor implements IFilterProcessor {
       ret.limit = '' + filter.limit;
     }
 
+    if (!filter.clauses) {
+      return ret;
+    }
+
     for (const clause of filter.clauses) {
       if (clause.operator !== Operators.OR) {
         throw new OnmsError('V1 only supports OR operators!');

src/dao/V2FilterProcessor.ts

@@ -124,8 +124,11 @@ export class V2FilterProcessor implements IFilterProcessor {
   }
 
   /** Given a list of clauses, recursively generate the FIQL query string. */
-  private toFIQL(clauses: Clause[]) {
+  private toFIQL(clauses: Clause[] | undefined) {
     let search = '';
+    if (!clauses || clauses.length === 0) {
+      return search;
+    }
     for (const clause of clauses) {
       if (search.length > 0) {
         search += this.toFIQLOperator(clause.operator);