appwrite 28.4.0 → 30.0.0

data/lib/appwrite/query/builder.rb

@@ -0,0 +1,361 @@
+require 'json'
+
+module Appwrite
+    class Query::Builder
+        def initialize
+            @queries = []
+        end
+
+        def build
+            return @queries.dup
+        end
+
+        def equal(attribute, value)
+            return push(Query.equal(attribute, value))
+        end
+
+        def not_equal(attribute, value)
+            return push(Query.not_equal(attribute, value))
+        end
+
+        def less_than(attribute, value)
+            return push(Query.less_than(attribute, value))
+        end
+
+        def less_than_equal(attribute, value)
+            return push(Query.less_than_equal(attribute, value))
+        end
+
+        def greater_than(attribute, value)
+            return push(Query.greater_than(attribute, value))
+        end
+
+        def greater_than_equal(attribute, value)
+            return push(Query.greater_than_equal(attribute, value))
+        end
+
+        def search(attribute, value)
+            return push(Query.search(attribute, value))
+        end
+
+        def is_null(attribute)
+            return push(Query.is_null(attribute))
+        end
+
+        def is_not_null(attribute)
+            return push(Query.is_not_null(attribute))
+        end
+
+        def between(attribute, start, ending)
+            return push(Query.between(attribute, start, ending))
+        end
+
+        def starts_with(attribute, value)
+            return push(Query.starts_with(attribute, value))
+        end
+
+        def ends_with(attribute, value)
+            return push(Query.ends_with(attribute, value))
+        end
+
+        def select(attributes)
+            return push(Query.select(attributes))
+        end
+
+        def cursor_after(id)
+            return push(Query.cursor_after(id))
+        end
+
+        def cursor_before(id)
+            return push(Query.cursor_before(id))
+        end
+
+        def order_asc(attribute)
+            return push(Query.order_asc(attribute))
+        end
+
+        def order_desc(attribute)
+            return push(Query.order_desc(attribute))
+        end
+
+        def order_random()
+            return push(Query.order_random())
+        end
+
+        def limit(limit)
+            return push(Query.limit(limit))
+        end
+
+        def offset(offset)
+            return push(Query.offset(offset))
+        end
+
+        def contains(attribute, value)
+            return push(Query.contains(attribute, value))
+        end
+
+        def contains_any(attribute, value)
+            return push(Query.contains_any(attribute, value))
+        end
+
+        def contains_all(attribute, value)
+            return push(Query.contains_all(attribute, value))
+        end
+
+        def not_contains(attribute, value)
+            return push(Query.not_contains(attribute, value))
+        end
+
+        def not_search(attribute, value)
+            return push(Query.not_search(attribute, value))
+        end
+
+        def not_between(attribute, start, ending)
+            return push(Query.not_between(attribute, start, ending))
+        end
+
+        def not_starts_with(attribute, value)
+            return push(Query.not_starts_with(attribute, value))
+        end
+
+        def not_ends_with(attribute, value)
+            return push(Query.not_ends_with(attribute, value))
+        end
+
+        def regex(attribute, pattern)
+            return push(Query.regex(attribute, pattern))
+        end
+
+        def exists(attributes)
+            return push(Query.exists(attributes))
+        end
+
+        def not_exists(attributes)
+            return push(Query.not_exists(attributes))
+        end
+
+        def created_before(value)
+            return push(Query.created_before(value))
+        end
+
+        def created_after(value)
+            return push(Query.created_after(value))
+        end
+
+        def created_between(start, ending)
+            return push(Query.created_between(start, ending))
+        end
+
+        def updated_before(value)
+            return push(Query.updated_before(value))
+        end
+
+        def updated_after(value)
+            return push(Query.updated_after(value))
+        end
+
+        def updated_between(start, ending)
+            return push(Query.updated_between(start, ending))
+        end
+
+        def or(queries)
+            return push(Query.or(queries))
+        end
+
+        def and(queries)
+            return push(Query.and(queries))
+        end
+
+        def elem_match(attribute, queries)
+            return push(Query.elem_match(attribute, queries))
+        end
+
+        def relationship(attribute, queries)
+            return push(Query.relationship(attribute, queries))
+        end
+
+        def distance_equal(attribute, values, distance, meters = true)
+            return push(Query.distance_equal(attribute, values, distance, meters))
+        end
+
+        def distance_not_equal(attribute, values, distance, meters = true)
+            return push(Query.distance_not_equal(attribute, values, distance, meters))
+        end
+
+        def distance_greater_than(attribute, values, distance, meters = true)
+            return push(Query.distance_greater_than(attribute, values, distance, meters))
+        end
+
+        def distance_less_than(attribute, values, distance, meters = true)
+            return push(Query.distance_less_than(attribute, values, distance, meters))
+        end
+
+        def intersects(attribute, values)
+            return push(Query.intersects(attribute, values))
+        end
+
+        def not_intersects(attribute, values)
+            return push(Query.not_intersects(attribute, values))
+        end
+
+        def crosses(attribute, values)
+            return push(Query.crosses(attribute, values))
+        end
+
+        def not_crosses(attribute, values)
+            return push(Query.not_crosses(attribute, values))
+        end
+
+        def overlaps(attribute, values)
+            return push(Query.overlaps(attribute, values))
+        end
+
+        def not_overlaps(attribute, values)
+            return push(Query.not_overlaps(attribute, values))
+        end
+
+        def touches(attribute, values)
+            return push(Query.touches(attribute, values))
+        end
+
+        def not_touches(attribute, values)
+            return push(Query.not_touches(attribute, values))
+        end
+
+        def count(attribute = '*', alias_name = '')
+            return push(Query.count(attribute, alias_name))
+        end
+
+        def count_distinct(attribute, alias_name = '')
+            return push(Query.count_distinct(attribute, alias_name))
+        end
+
+        def sum(attribute, alias_name = '')
+            return push(Query.sum(attribute, alias_name))
+        end
+
+        def avg(attribute, alias_name = '')
+            return push(Query.avg(attribute, alias_name))
+        end
+
+        def min(attribute, alias_name = '')
+            return push(Query.min(attribute, alias_name))
+        end
+
+        def max(attribute, alias_name = '')
+            return push(Query.max(attribute, alias_name))
+        end
+
+        def stddev(attribute, alias_name = '')
+            return push(Query.stddev(attribute, alias_name))
+        end
+
+        def stddev_pop(attribute, alias_name = '')
+            return push(Query.stddev_pop(attribute, alias_name))
+        end
+
+        def stddev_samp(attribute, alias_name = '')
+            return push(Query.stddev_samp(attribute, alias_name))
+        end
+
+        def variance(attribute, alias_name = '')
+            return push(Query.variance(attribute, alias_name))
+        end
+
+        def var_pop(attribute, alias_name = '')
+            return push(Query.var_pop(attribute, alias_name))
+        end
+
+        def var_samp(attribute, alias_name = '')
+            return push(Query.var_samp(attribute, alias_name))
+        end
+
+        def bit_and(attribute, alias_name = '')
+            return push(Query.bit_and(attribute, alias_name))
+        end
+
+        def bit_or(attribute, alias_name = '')
+            return push(Query.bit_or(attribute, alias_name))
+        end
+
+        def bit_xor(attribute, alias_name = '')
+            return push(Query.bit_xor(attribute, alias_name))
+        end
+
+        def group_by(attributes)
+            return push(Query.group_by(attributes))
+        end
+
+        def having(queries)
+            return push(Query.having(queries))
+        end
+
+        def distinct()
+            return push(Query.distinct())
+        end
+
+        def join(table, left, right = '', operator = '=', alias_name = '')
+            return push(Query.join(table, left, right, operator, alias_name))
+        end
+
+        def left_join(table, left, right = '', operator = '=', alias_name = '')
+            return push(Query.left_join(table, left, right, operator, alias_name))
+        end
+
+        def right_join(table, left, right = '', operator = '=', alias_name = '')
+            return push(Query.right_join(table, left, right, operator, alias_name))
+        end
+
+        def full_outer_join(table, left, right = '', operator = '=', alias_name = '')
+            return push(Query.full_outer_join(table, left, right, operator, alias_name))
+        end
+
+        def cross_join(table, alias_name = '')
+            return push(Query.cross_join(table, alias_name))
+        end
+
+        def vector_dot(attribute, vector)
+            return push(Query.vector_dot(attribute, vector))
+        end
+
+        def vector_cosine(attribute, vector)
+            return push(Query.vector_cosine(attribute, vector))
+        end
+
+        def vector_euclidean(attribute, vector)
+            return push(Query.vector_euclidean(attribute, vector))
+        end
+
+        def covers(attribute, values)
+            return push(Query.covers(attribute, values))
+        end
+
+        def not_covers(attribute, values)
+            return push(Query.not_covers(attribute, values))
+        end
+
+        def spatial_equals(attribute, values)
+            return push(Query.spatial_equals(attribute, values))
+        end
+
+        def not_spatial_equals(attribute, values)
+            return push(Query.not_spatial_equals(attribute, values))
+        end
+
+        def page(page, per_page = 25)
+            return push(Query.page(page, per_page))
+        end
+
+        private
+
+        def push(query)
+            if query.is_a?(Array)
+                @queries.concat(query)
+            else
+                @queries << query
+            end
+
+            return self
+        end
+    end
+end

data/lib/appwrite/query.rb

@@ -216,6 +216,15 @@ module Appwrite
                 return Query.new("elemMatch", attribute, queries.map { |query| JSON.parse(query) }).to_s
             end
 
+            # Constrain populated related documents on a relationship attribute.
+            #
+            # @param attribute [String] The relationship attribute to query.
+            # @param queries [Array<String>] Filter, order, select, and pagination queries applied to related documents.
+            # @return [String] The query string.
+            def relationship(attribute, queries)
+                return Query.new("relationship", attribute, queries.map { |query| JSON.parse(query) }).to_s
+            end
+
             def distance_equal(attribute, values, distance, meters = true)
                 return Query.new("distanceEqual", attribute, [[values, distance, meters]]).to_s
             end
@@ -275,6 +284,187 @@ module Appwrite
             def not_touches(attribute, values)
                 return Query.new("notTouches", attribute, [values]).to_s
             end
+
+            def count(attribute = '*', alias_name = '')
+                return Query.new("count", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def count_distinct(attribute, alias_name = '')
+                return Query.new("countDistinct", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def sum(attribute, alias_name = '')
+                return Query.new("sum", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def avg(attribute, alias_name = '')
+                return Query.new("avg", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def min(attribute, alias_name = '')
+                return Query.new("min", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def max(attribute, alias_name = '')
+                return Query.new("max", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def stddev(attribute, alias_name = '')
+                return Query.new("stddev", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def stddev_pop(attribute, alias_name = '')
+                return Query.new("stddevPop", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def stddev_samp(attribute, alias_name = '')
+                return Query.new("stddevSamp", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def variance(attribute, alias_name = '')
+                return Query.new("variance", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def var_pop(attribute, alias_name = '')
+                return Query.new("varPop", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def var_samp(attribute, alias_name = '')
+                return Query.new("varSamp", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def bit_and(attribute, alias_name = '')
+                return Query.new("bitAnd", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def bit_or(attribute, alias_name = '')
+                return Query.new("bitOr", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def bit_xor(attribute, alias_name = '')
+                return Query.new("bitXor", attribute, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def group_by(attributes)
+                return Query.new("groupBy", nil, attributes).to_s
+            end
+
+            def having(queries)
+                return Query.new("having", nil, queries.map { |query| JSON.parse(query) }).to_s
+            end
+
+            def distinct()
+                return Query.new("distinct", nil, nil).to_s
+            end
+
+            def on(left, right, operator = '=')
+                return Query.new("on", nil, [left, operator, right]).to_s
+            end
+
+            def join(table, left, right = '', operator = '=', alias_name = '')
+                return create_join("join", table, left, right, operator, alias_name)
+            end
+
+            def left_join(table, left, right = '', operator = '=', alias_name = '')
+                return create_join("leftJoin", table, left, right, operator, alias_name)
+            end
+
+            def right_join(table, left, right = '', operator = '=', alias_name = '')
+                return create_join("rightJoin", table, left, right, operator, alias_name)
+            end
+
+            def full_outer_join(table, left, right = '', operator = '=', alias_name = '')
+                return create_join("fullOuterJoin", table, left, right, operator, alias_name)
+            end
+
+            def cross_join(table, alias_name = '')
+                return Query.new("crossJoin", table, alias_name != '' ? alias_name : nil).to_s
+            end
+
+            def covers(attribute, values)
+                return Query.new("covers", attribute, [values]).to_s
+            end
+
+            def not_covers(attribute, values)
+                return Query.new("notCovers", attribute, [values]).to_s
+            end
+
+            def spatial_equals(attribute, values)
+                return Query.new("spatialEquals", attribute, [values]).to_s
+            end
+
+            def not_spatial_equals(attribute, values)
+                return Query.new("notSpatialEquals", attribute, [values]).to_s
+            end
+
+            def page(page, per_page = 25)
+                if page < 1
+                    raise ArgumentError, "Page must be >= 1, got #{page}"
+                end
+                if per_page < 1
+                    raise ArgumentError, "Per page must be >= 1, got #{per_page}"
+                end
+
+                return [
+                    limit(per_page),
+                    offset((page - 1) * per_page),
+                ]
+            end
+
+            def builder
+                return Builder.new
+            end
+
+            def _flatten(value)
+                return value.build if value.is_a?(Builder)
+                return value.to_s if value.is_a?(Query)
+                return value unless value.is_a?(Array)
+
+                out = []
+                changed = false
+                value.each do |item|
+                    flat = _flatten(item)
+                    if item.is_a?(Builder) || item.is_a?(Query)
+                        if flat.is_a?(Array)
+                            out.concat(flat)
+                        else
+                            out << flat
+                        end
+                        changed = true
+                        next
+                    end
+                    changed = true if flat != item
+                    out << flat
+                end
+
+                changed ? out : value
+            end
+
+            private
+
+            def create_join(method, table, left, right, operator, alias_name)
+                return nested_join(method, table, '', left) if left.is_a?(Array)
+                return nested_join(method, table, left, right) if right.is_a?(Array)
+
+                return join_query(method, table, left, right, operator, alias_name)
+            end
+
+            def nested_join(method, table, alias_name, on)
+                values = []
+                values << alias_name if alias_name != ''
+                on.each { |query| values << JSON.parse(query) }
+
+                return Query.new(method, table, values).to_s
+            end
+
+            def join_query(method, table, left, right, operator, alias_name)
+                values = [left, operator, right]
+                values << alias_name if alias_name != ''
+
+                return Query.new(method, table, values).to_s
+            end
         end
     end
+
+    require_relative 'query/builder'
 end