Feat json queries

src/SDK/Language/Deno.php

@@ -140,6 +140,9 @@ public function getTypeName(array $parameter, array $spec = []): string
         if (!empty($parameter['enumValues'])) {
             return \ucfirst($parameter['name']);
         }
+        if (!empty($parameter['name']) && $parameter['name'] === 'queries') {
+            return 'Query[]';
+        }
         return match ($parameter['type']) {
             self::TYPE_INTEGER => 'number',
             self::TYPE_STRING => 'string',

src/SDK/Language/JS.php

@@ -131,7 +131,9 @@ public function getTypeName(array $parameter, array $spec = []): string
         if (!empty($parameter['enumValues'])) {
             return \ucfirst($parameter['name']);
         }
-
+        if (!empty($parameter['name']) && $parameter['name'] === 'queries') {
+            return 'Query[]';
+        }
         switch ($parameter['type']) {
             case self::TYPE_INTEGER:
             case self::TYPE_NUMBER:

src/SDK/Language/Node.php

@@ -25,6 +25,9 @@ public function getTypeName(array $parameter, array $spec = []): string
         if (!empty($parameter['enumValues'])) {
             return \ucfirst($parameter['name']);
         }
+        if (!empty($parameter['name']) && $parameter['name'] === 'queries') {
+            return 'Query[]';
+        }
         return match ($parameter['type']) {
             self::TYPE_INTEGER,
             self::TYPE_NUMBER => 'number',

src/SDK/Language/Web.php

@@ -185,6 +185,9 @@ public function getTypeName(array $parameter, array $method = []): string
         if (!empty($parameter['enumValues'])) {
             return \ucfirst($parameter['name']);
         }
+        if (!empty($parameter['name']) && $parameter['name'] === 'queries') {
+            return 'Query[]';
+        }
         switch ($parameter['type']) {
             case self::TYPE_INTEGER:
             case self::TYPE_NUMBER:

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

@@ -1,60 +1,66 @@
 package {{ sdk.namespace | caseDot }}
 
-class Query {
-  companion object {
-    fun equal(attribute: String, value: Any) = addQuery(attribute, "equal", value)
+import com.google.gson.Gson
 
-    fun notEqual(attribute: String, value: Any) = Query.addQuery(attribute, "notEqual", value)
+class Query(
+    val method: String,
+    val attribute: String? = null,
+    val values: List<Any>? = null,
+) {
+    override fun toString() = gson.toJson(this)
 
-    fun lessThan(attribute: String, value: Any) = Query.addQuery(attribute, "lessThan", value)
+    companion object {
+        private val gson = Gson()
 
-    fun lessThanEqual(attribute: String, value: Any) = Query.addQuery(attribute, "lessThanEqual", value)
+        fun equal(attribute: String, value: Any) = Query("equal", attribute, parseValue(value))
 
-    fun greaterThan(attribute: String, value: Any) = Query.addQuery(attribute, "greaterThan", value)
+        fun notEqual(attribute: String, value: Any) = Query("notEqual", attribute, listOf(value))
 
-    fun greaterThanEqual(attribute: String, value: Any) = Query.addQuery(attribute, "greaterThanEqual", value)
-
-    fun search(attribute: String, value: String) = Query.addQuery(attribute, "search", value)
+        fun lessThan(attribute: String, value: Any) = Query("lessThan", attribute, listOf(value))
 
-    fun isNull(attribute: String) = "isNull(\"${attribute}\")"
+        fun lessThanEqual(attribute: String, value: Any) = Query("lessThanEqual", attribute, listOf(value))
 
-    fun isNotNull(attribute: String) = "isNotNull(\"${attribute}\")"
+        fun greaterThan(attribute: String, value: Any) = Query("greaterThan", attribute, listOf(value))
 
-    fun between(attribute: String, start: Int, end: Int) = "between(\"${attribute}\", ${start}, ${end})"
+        fun greaterThanEqual(attribute: String, value: Any) = Query("greaterThanEqual", attribute, listOf(value))
 
-    fun between(attribute: String, start: Double, end: Double) = "between(\"${attribute}\", ${start}, ${end})"
+        fun search(attribute: String, value: String) = Query("search", attribute, listOf(value))
 
-    fun between(attribute: String, start: String, end: String) = "between(\"${attribute}\", \"${start}\", \"${end}\")"
+        fun isNull(attribute: String) = Query("isNull", attribute)
 
-    fun startsWith(attribute: String, value: String) = Query.addQuery(attribute, "startsWith", value)
+        fun isNotNull(attribute: String) = Query("isNotNull", attribute)
 
-    fun endsWith(attribute: String, value: String) = Query.addQuery(attribute, "endsWith", value)
+        fun between(attribute: String, start: Any, end: Any) = Query("between", attribute, listOf(start, end))
 
-    fun select(attributes: List<String>) = "select([${attributes.joinToString(",") { "\"$it\"" }}])"
+        fun startsWith(attribute: String, value: String) = Query("startsWith", attribute, listOf(value))
 
-    fun orderAsc(attribute: String) = "orderAsc(\"${attribute}\")"
+        fun endsWith(attribute: String, value: String) = Query("endsWith", attribute, listOf(value))
 
-    fun orderDesc(attribute: String) = "orderDesc(\"${attribute}\")"
+        fun select(attributes: List<String>) = Query("select", null, attributes)
 
-    fun cursorBefore(documentId: String) = "cursorBefore(\"${documentId}\")"
+        fun orderAsc(attribute: String) = Query("orderAsc", attribute)
 
-    fun cursorAfter(documentId: String) = "cursorAfter(\"${documentId}\")"
+        fun orderDesc(attribute: String) = Query("orderDesc", attribute)
 
-    fun limit(limit: Int) = "limit(${limit})"
+        fun cursorBefore(documentId: String) = Query("cursorBefore", null, listOf(documentId))
 
-    fun offset(offset: Int) = "offset(${offset})"
+        fun cursorAfter(documentId: String) = Query("cursorAfter", null, listOf(documentId))
 
-    private fun addQuery(attribute: String, method: String, value: Any): String {
-      return when (value) {
-        is List<*> -> "${method}(\"${attribute}\", [${value.map{it -> parseValues(it!!)}.joinToString(",")}])"
-    	  else -> "${method}(\"${attribute}\", [${Query.parseValues(value)}])"
-      }
-    }
-    private fun parseValues(value: Any): String {
-      return when (value) {
-        is String -> "\"${value}\""
-    	  else -> "${value}"
-      }
+        fun limit(limit: Int) = Query("limit", null, listOf(limit))
+
+        fun offset(offset: Int) = Query("offset", null, listOf(offset))
+
+        fun contains(attribute: String, value: Any) = Query("contains", attribute, parseValue(value))
+
+        fun or(queries: List<Query>) = Query("or", null, queries)
+
+        fun and(queries: List<Query>) = Query("and", null, queries)
+
+        private fun parseValue(value: Any): List<Any> {
+            return when (value) {
+                is List<*> -> value as List<Any>
+                else -> listOf(value)
+            }
+        }
     }
-  }
-}
+}

templates/dart/lib/package.dart.twig

@@ -7,6 +7,7 @@ library {{ language.params.packageName }};
 
 import 'dart:async';
 import 'dart:typed_data';
+import 'dart:convert';
 
 import 'src/enums.dart';
 import 'src/service.dart';

templates/dart/lib/query.dart.twig

@@ -1,99 +1,121 @@
 part of {{ language.params.packageName }};
 
+
 /// Helper class to generate query strings.
 class Query {
-  Query._();
+  final String method;
+  final String? attribute;
+  final dynamic values;
+
+  Query._(this.method, [this.attribute = null, this.values = null]);
+
+  Map<String, dynamic> toJson() {
+    final map = <String, dynamic>{
+      'method': method,
+    };
+
+    if(attribute != null) {
+      map['attribute'] = attribute;
+    }
+
+    if(values != null) {
+      map['values'] = values is List ? values : [values];
+    }
+
+    return map;
+  }
+
+  @override
+  String toString() => jsonEncode(toJson());
 
   /// Filter resources where [attribute] is equal to [value].
   /// 
   /// [value] can be a single value or a list. If a list is used
   /// the query will return resources where [attribute] is equal
   /// to any of the values in the list.
-  static String equal(String attribute, dynamic value) =>
-      _addQuery(attribute, 'equal', value);
+  static Query equal(String attribute, dynamic value) =>
+      Query._('equal', attribute, value);
 
   /// Filter resources where [attribute] is not equal to [value].
-  ///
-  /// [value] can be a single value or a list. If a list is used
-  /// the query will return resources where [attribute] is equal
-  /// to any of the values in the list.
-  static String notEqual(String attribute, dynamic value) =>
-      _addQuery(attribute, 'notEqual', value);
+  static Query notEqual(String attribute, dynamic value) =>
+      Query._('notEqual', attribute, [value]);
 
   /// Filter resources where [attribute] is less than [value].
-  static String lessThan(String attribute, dynamic value) =>
-      _addQuery(attribute, 'lessThan', value);
+  static Query lessThan(String attribute, dynamic value) =>
+      Query._('lessThan', attribute, value);
 
   /// Filter resources where [attribute] is less than or equal to [value].
-  static String lessThanEqual(String attribute, dynamic value) =>
-      _addQuery(attribute, 'lessThanEqual', value);
+  static Query lessThanEqual(String attribute, dynamic value) =>
+      Query._('lessThanEqual', attribute, value);
 
   /// Filter resources where [attribute] is greater than [value].
-  static String greaterThan(String attribute, dynamic value) =>
-      _addQuery(attribute, 'greaterThan', value);
+  static Query greaterThan(String attribute, dynamic value) =>
+      Query._('greaterThan', attribute, value);
 
   /// Filter resources where [attribute] is greater than or equal to [value].
-  static String greaterThanEqual(String attribute, dynamic value) =>
-      _addQuery(attribute, 'greaterThanEqual', value);
+  static Query greaterThanEqual(String attribute, dynamic value) =>
+      Query._('greaterThanEqual', attribute, value);
 
   /// Filter resources where by searching [attribute] for [value].
-  static String search(String attribute, String value) =>
-      _addQuery(attribute, 'search', value);
+  static Query search(String attribute, String value) =>
+      Query._('search', attribute, value);
 
   /// Filter resources where [attribute] is null.
-  static String isNull(String attribute) => 'isNull("$attribute")';
+  static Query isNull(String attribute) => Query._('isNull', attribute);
 
   /// Filter resources where [attribute] is not null.
-  static String isNotNull(String attribute) => 'isNotNull("$attribute")';
+  static Query isNotNull(String attribute) => Query._('isNotNull', attribute);
 
   /// Filter resources where [attribute] is between [start] and [end] (inclusive).
-  static String between(String attribute, dynamic start, dynamic end) =>
-      'between("$attribute", ${_parseValues(start)}, ${_parseValues(end)})';
+  static Query between(String attribute, dynamic start, dynamic end) =>
+      Query._('between', attribute, [start, end]);
 
   /// Filter resources where [attribute] starts with [value].
-  static String startsWith(String attribute, String value) =>
-      _addQuery(attribute, 'startsWith', value);
+  static Query startsWith(String attribute, String value) =>
+      Query._('startsWith', attribute, value);
 
   /// Filter resources where [attribute] ends with [value].
-  static String endsWith(String attribute, String value) =>
-      _addQuery(attribute, 'endsWith', value);
+  static Query endsWith(String attribute, String value) =>
+      Query._('endsWith', attribute, value);
+
+  /// Filter resouorces where [attribute] contains [value]
+  /// [value] can be a single value or a list.
+  static Query contains(String attribute, dynamic value) => 
+      Query._('contains', attribute, value);
+
+  static Query or(List<Query> queries) => Query._('or', null, queries);
+
+  static Query and(List<Query> queries) => Query._('and', null, queries);
 
   /// Specify which attributes should be returned by the API call.
-  static String select(List<String> attributes) =>
-      'select([${attributes.map((attr) => "\"$attr\"").join(",")}])';
+  static Query select(List<String> attributes) =>
+      Query._('select', null, attributes);
 
   /// Sort results by [attribute] ascending.
-  static String orderAsc(String attribute) => 'orderAsc("$attribute")';
+  static Query orderAsc(String attribute) => Query._('orderAsc', attribute);
 
   /// Sort results by [attribute] descending.
-  static String orderDesc(String attribute) => 'orderDesc("$attribute")';
+  static Query orderDesc(String attribute) => Query._('orderDesc', attribute);
 
   /// Return results before [id].
   /// 
   /// Refer to the [Cursor Based Pagination]({{sdk.url}}/docs/pagination#cursor-pagination)
   /// docs for more information.
-  static String cursorBefore(String id) => 'cursorBefore("$id")';
+  static Query cursorBefore(String id) => Query._('cursorBefore', null, id);
 
   /// Return results after [id].
   /// 
   /// Refer to the [Cursor Based Pagination]({{sdk.url}}/docs/pagination#cursor-pagination)
   /// docs for more information.
-  static String cursorAfter(String id) => 'cursorAfter("$id")';
+  static Query cursorAfter(String id) => Query._('cursorAfter', null, id);
 
   /// Return only [limit] results.
-  static String limit(int limit) => 'limit($limit)';
+  static Query limit(int limit) => Query._('limit', null, limit);
 
   /// Return results from [offset].
   /// 
   /// Refer to the [Offset Pagination]({{sdk.url}}/docs/pagination#offset-pagination)
   /// docs for more information.
-  static String offset(int offset) => 'offset($offset)';
-
-  static String _addQuery(String attribute, String method, dynamic value) => (value
-          is List)
-      ? '$method("$attribute", [${value.map((item) => _parseValues(item)).join(",")}])'
-      : '$method("$attribute", [${_parseValues(value)}])';
+  static Query offset(int offset) => Query._('offset', null, offset);
 
-  static String _parseValues(dynamic value) =>
-      (value is String) ? '"$value"' : '$value';
 }