Merge pull request #1141 from appwrite/cursor/add-new-query-methods-and-tests-870c

Add new query methods and tests

Author: abnegate

templates/android/library/src/main/java/io/package/Query.kt.twig

@@ -192,6 +192,84 @@ class Query(
          */
         fun contains(attribute: String, value: Any) = Query("contains", attribute, parseValue(value)).toJson()
 
+        /**
+         * Filter resources where attribute does not contain the specified value.
+         *
+         * @param attribute The attribute to filter on.
+         * @param value The value to compare against.
+         * @returns The query string.
+         */
+        fun notContains(attribute: String, value: Any) = Query("notContains", attribute, parseValue(value)).toJson()
+
+        /**
+         * Filter resources by searching attribute for value (inverse of search).
+         *
+         * @param attribute The attribute to filter on.
+         * @param value The search value to match against.
+         * @returns The query string.
+         */
+        fun notSearch(attribute: String, value: String) = Query("notSearch", attribute, listOf(value)).toJson()
+
+        /**
+         * Filter resources where attribute is not between start and end (exclusive).
+         *
+         * @param attribute The attribute to filter on.
+         * @param start The start value of the range.
+         * @param end The end value of the range.
+         * @returns The query string.
+         */
+        fun notBetween(attribute: String, start: Any, end: Any) = Query("notBetween", attribute, listOf(start, end)).toJson()
+
+        /**
+         * Filter resources where attribute does not start with value.
+         *
+         * @param attribute The attribute to filter on.
+         * @param value The value to compare against.
+         * @returns The query string.
+         */
+        fun notStartsWith(attribute: String, value: String) = Query("notStartsWith", attribute, listOf(value)).toJson()
+
+        /**
+         * Filter resources where attribute does not end with value.
+         *
+         * @param attribute The attribute to filter on.
+         * @param value The value to compare against.
+         * @returns The query string.
+         */
+        fun notEndsWith(attribute: String, value: String) = Query("notEndsWith", attribute, listOf(value)).toJson()
+
+        /**
+         * Filter resources where document was created before date.
+         *
+         * @param value The date value to compare against.
+         * @returns The query string.
+         */
+        fun createdBefore(value: String) = Query("createdBefore", null, listOf(value)).toJson()
+
+        /**
+         * Filter resources where document was created after date.
+         *
+         * @param value The date value to compare against.
+         * @returns The query string.
+         */
+        fun createdAfter(value: String) = Query("createdAfter", null, listOf(value)).toJson()
+
+        /**
+         * Filter resources where document was updated before date.
+         *
+         * @param value The date value to compare against.
+         * @returns The query string.
+         */
+        fun updatedBefore(value: String) = Query("updatedBefore", null, listOf(value)).toJson()
+
+        /**
+         * Filter resources where document was updated after date.
+         *
+         * @param value The date value to compare against.
+         * @returns The query string.
+         */
+        fun updatedAfter(value: String) = Query("updatedAfter", null, listOf(value)).toJson()
+
         /**
          * Combine multiple queries using logical OR operator.
          *

templates/dart/lib/query.dart.twig

@@ -83,6 +83,39 @@ class Query {
   static String contains(String attribute, dynamic value) =>
       Query._('contains', attribute, value).toString();
 
+  /// Filter resources where [attribute] does not contain [value]
+  /// [value] can be a single value or a list.
+  static String notContains(String attribute, dynamic value) =>
+      Query._('notContains', attribute, value).toString();
+
+  /// Filter resources by searching [attribute] for [value] (inverse of search).
+  static String notSearch(String attribute, String value) =>
+      Query._('notSearch', attribute, value).toString();
+
+  /// Filter resources where [attribute] is not between [start] and [end] (exclusive).
+  static String notBetween(String attribute, dynamic start, dynamic end) =>
+      Query._('notBetween', attribute, [start, end]).toString();
+
+  /// Filter resources where [attribute] does not start with [value].
+  static String notStartsWith(String attribute, String value) =>
+      Query._('notStartsWith', attribute, value).toString();
+
+  /// Filter resources where [attribute] does not end with [value].
+  static String notEndsWith(String attribute, String value) =>
+      Query._('notEndsWith', attribute, value).toString();
+
+  /// Filter resources where document was created before [value].
+  static String createdBefore(String value) => Query._('createdBefore', null, value).toString();
+
+  /// Filter resources where document was created after [value].
+  static String createdAfter(String value) => Query._('createdAfter', null, value).toString();
+
+  /// Filter resources where document was updated before [value].
+  static String updatedBefore(String value) => Query._('updatedBefore', null, value).toString();
+
+  /// Filter resources where document was updated after [value].
+  static String updatedAfter(String value) => Query._('updatedAfter', null, value).toString();
+
   static String or(List<String> queries) =>
     Query._('or', null, queries.map((query) => jsonDecode(query)).toList()).toString();
 

templates/dart/test/query_test.dart.twig

@@ -211,5 +211,84 @@ void main() {
     expect(query['values'], 1);
     expect(query['method'], 'offset');
   });
+
+  test('returns notContains', () {
+    final query = Query.notContains('attr', 'value').toJson();
+    expect(query['attribute'], 'attr');
+    expect(query['values'], ['value']);
+    expect(query['method'], 'notContains');
+  });
+
+  test('returns notSearch', () {
+    final query = Query.notSearch('attr', 'keyword1 keyword2').toJson();
+    expect(query['attribute'], 'attr');
+    expect(query['values'], ['keyword1 keyword2']);
+    expect(query['method'], 'notSearch');
+  });
+
+  group('notBetween()', () {
+    test('with integers', () {
+      final query = Query.notBetween('attr', 1, 2).toJson();
+      expect(query['attribute'], 'attr');
+      expect(query['values'], [1, 2]);
+      expect(query['method'], 'notBetween');
+    });
+
+    test('with doubles', () {
+      final query = Query.notBetween('attr', 1.0, 2.0).toJson();
+      expect(query['attribute'], 'attr');
+      expect(query['values'], [1.0, 2.0]);
+      expect(query['method'], 'notBetween');
+    });
+
+    test('with strings', () {
+      final query = Query.notBetween('attr', 'a', 'z').toJson();
+      expect(query['attribute'], 'attr');
+      expect(query['values'], ['a', 'z']);
+      expect(query['method'], 'notBetween');
+    });
+  });
+
+  test('returns notStartsWith', () {
+    final query = Query.notStartsWith('attr', 'prefix').toJson();
+    expect(query['attribute'], 'attr');
+    expect(query['values'], ['prefix']);
+    expect(query['method'], 'notStartsWith');
+  });
+
+  test('returns notEndsWith', () {
+    final query = Query.notEndsWith('attr', 'suffix').toJson();
+    expect(query['attribute'], 'attr');
+    expect(query['values'], ['suffix']);
+    expect(query['method'], 'notEndsWith');
+  });
+
+  test('returns createdBefore', () {
+    final query = Query.createdBefore('2023-01-01').toJson();
+    expect(query['attribute'], null);
+    expect(query['values'], '2023-01-01');
+    expect(query['method'], 'createdBefore');
+  });
+
+  test('returns createdAfter', () {
+    final query = Query.createdAfter('2023-01-01').toJson();
+    expect(query['attribute'], null);
+    expect(query['values'], '2023-01-01');
+    expect(query['method'], 'createdAfter');
+  });
+
+  test('returns updatedBefore', () {
+    final query = Query.updatedBefore('2023-01-01').toJson();
+    expect(query['attribute'], null);
+    expect(query['values'], '2023-01-01');
+    expect(query['method'], 'updatedBefore');
+  });
+
+  test('returns updatedAfter', () {
+    final query = Query.updatedAfter('2023-01-01').toJson();
+    expect(query['attribute'], null);
+    expect(query['values'], '2023-01-01');
+    expect(query['method'], 'updatedAfter');
+  });
 }
 

templates/deno/src/query.ts.twig

@@ -93,9 +93,104 @@ export class Query {
   static offset = (offset: number): string =>
     new Query("offset", undefined, offset).toString();
 
+  /**
+   * Filter resources where attribute contains the specified value.
+   *
+   * @param {string} attribute
+   * @param {string | string[]} value
+   * @returns {string}
+   */
   static contains = (attribute: string, value: string | string[]): string =>
     new Query("contains", attribute, value).toString();
 
+  /**
+   * Filter resources where attribute does not contain the specified value.
+   *
+   * @param {string} attribute
+   * @param {string | string[]} value
+   * @returns {string}
+   */
+  static notContains = (attribute: string, value: string | string[]): string =>
+    new Query("notContains", attribute, value).toString();
+
+  /**
+   * Filter resources by searching attribute for value (inverse of search).
+   * A fulltext index on attribute is required for this query to work.
+   *
+   * @param {string} attribute
+   * @param {string} value
+   * @returns {string}
+   */
+  static notSearch = (attribute: string, value: string): string =>
+    new Query("notSearch", attribute, value).toString();
+
+  /**
+   * Filter resources where attribute is not between start and end (exclusive).
+   *
+   * @param {string} attribute
+   * @param {string | number} start
+   * @param {string | number} end
+   * @returns {string}
+   */
+  static notBetween = (attribute: string, start: string | number, end: string | number): string =>
+    new Query("notBetween", attribute, [start, end] as QueryTypesList).toString();
+
+  /**
+   * Filter resources where attribute does not start with value.
+   *
+   * @param {string} attribute
+   * @param {string} value
+   * @returns {string}
+   */
+  static notStartsWith = (attribute: string, value: string): string =>
+    new Query("notStartsWith", attribute, value).toString();
+
+  /**
+   * Filter resources where attribute does not end with value.
+   *
+   * @param {string} attribute
+   * @param {string} value
+   * @returns {string}
+   */
+  static notEndsWith = (attribute: string, value: string): string =>
+    new Query("notEndsWith", attribute, value).toString();
+
+  /**
+   * Filter resources where document was created before date.
+   *
+   * @param {string} value
+   * @returns {string}
+   */
+  static createdBefore = (value: string): string =>
+    new Query("createdBefore", undefined, value).toString();
+
+  /**
+   * Filter resources where document was created after date.
+   *
+   * @param {string} value
+   * @returns {string}
+   */
+  static createdAfter = (value: string): string =>
+    new Query("createdAfter", undefined, value).toString();
+
+  /**
+   * Filter resources where document was updated before date.
+   *
+   * @param {string} value
+   * @returns {string}
+   */
+  static updatedBefore = (value: string): string =>
+    new Query("updatedBefore", undefined, value).toString();
+
+  /**
+   * Filter resources where document was updated after date.
+   *
+   * @param {string} value
+   * @returns {string}
+   */
+  static updatedAfter = (value: string): string =>
+    new Query("updatedAfter", undefined, value).toString();
+
   static or = (queries: string[]) =>
       new Query("or", undefined, queries.map((query) => JSON.parse(query))).toString();
 

templates/deno/test/query.test.ts.twig

@@ -172,4 +172,59 @@ describe('Query', () => {
         Query.offset(1).toString(),
         `{"method":"offset","values":[1]}`,
     ));
+
+    test('notContains', () => assertEquals(
+        Query.notContains('attr', 'value').toString(),
+        `{"method":"notContains","attribute":"attr","values":["value"]}`,
+    ));
+
+    test('notSearch', () => assertEquals(
+        Query.notSearch('attr', 'keyword1 keyword2').toString(),
+        '{"method":"notSearch","attribute":"attr","values":["keyword1 keyword2"]}',
+    ));
+
+    describe('notBetween', () => {
+        test('with integers', () => assertEquals(
+            Query.notBetween('attr', 1, 2).toString(),
+            `{"method":"notBetween","attribute":"attr","values":[1,2]}`,
+        ));
+        test('with doubles', () => assertEquals(
+            Query.notBetween('attr', 1.2, 2.2).toString(),
+            `{"method":"notBetween","attribute":"attr","values":[1.2,2.2]}`,
+        ));
+        test('with strings', () => assertEquals(
+            Query.notBetween('attr', "a", "z").toString(),
+            `{"method":"notBetween","attribute":"attr","values":["a","z"]}`,
+        ));
+    });
+
+    test('notStartsWith', () => assertEquals(
+        Query.notStartsWith('attr', 'prefix').toString(),
+        `{"method":"notStartsWith","attribute":"attr","values":["prefix"]}`,
+    ));
+
+    test('notEndsWith', () => assertEquals(
+        Query.notEndsWith('attr', 'suffix').toString(),
+        `{"method":"notEndsWith","attribute":"attr","values":["suffix"]}`,
+    ));
+
+    test('createdBefore', () => assertEquals(
+        Query.createdBefore('2023-01-01').toString(),
+        `{"method":"createdBefore","values":["2023-01-01"]}`,
+    ));
+
+    test('createdAfter', () => assertEquals(
+        Query.createdAfter('2023-01-01').toString(),
+        `{"method":"createdAfter","values":["2023-01-01"]}`,
+    ));
+
+    test('updatedBefore', () => assertEquals(
+        Query.updatedBefore('2023-01-01').toString(),
+        `{"method":"updatedBefore","values":["2023-01-01"]}`,
+    ));
+
+    test('updatedAfter', () => assertEquals(
+        Query.updatedAfter('2023-01-01').toString(),
+        `{"method":"updatedAfter","values":["2023-01-01"]}`,
+    ));
 })