appwrite 28.3.2 → 29.0.0

data/lib/appwrite/models/waf_rule_rate_limit.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class WafRuleRateLimit
+            attr_reader :id
+            attr_reader :created_at
+            attr_reader :updated_at
+            attr_reader :name
+            attr_reader :description
+            attr_reader :team_id
+            attr_reader :project_id
+            attr_reader :resource_type
+            attr_reader :resource_id
+            attr_reader :action
+            attr_reader :priority
+            attr_reader :enabled
+            attr_reader :conditions
+            attr_reader :config
+            attr_reader :limit
+            attr_reader :interval
+            attr_reader :key
+            attr_reader :strategy
+            attr_reader :max_bucket_size
+
+            def initialize(
+                id:,
+                created_at:,
+                updated_at:,
+                name:,
+                description:,
+                team_id:,
+                project_id:,
+                resource_type:,
+                resource_id:,
+                action:,
+                priority:,
+                enabled:,
+                conditions:,
+                config:,
+                limit:,
+                interval:,
+                key:,
+                strategy:,
+                max_bucket_size:
+            )
+                @id = id
+                @created_at = created_at
+                @updated_at = updated_at
+                @name = name
+                @description = description
+                @team_id = team_id
+                @project_id = project_id
+                @resource_type = resource_type
+                @resource_id = resource_id
+                @action = validate_action(action)
+                @priority = priority
+                @enabled = enabled
+                @conditions = conditions
+                @config = config
+                @limit = limit
+                @interval = interval
+                @key = key
+                @strategy = strategy
+                @max_bucket_size = max_bucket_size
+            end
+
+            def self.from(map:)
+                map = { "$id" => "", "$createdAt" => "", "$updatedAt" => "", "name" => "", "description" => "", "teamId" => "", "projectId" => "", "resourceType" => "api", "resourceId" => "", "priority" => 0, "enabled" => true, "conditions" => [], "config" => {}, "limit" => 100, "interval" => 3600, "key" => "ip", "strategy" => "fixedWindow", "maxBucketSize" => 0 }.merge(map)
+                WafRuleRateLimit.new(
+                    id: map["$id"],
+                    created_at: map["$createdAt"],
+                    updated_at: map["$updatedAt"],
+                    name: map["name"],
+                    description: map["description"],
+                    team_id: map["teamId"],
+                    project_id: map["projectId"],
+                    resource_type: map["resourceType"],
+                    resource_id: map["resourceId"],
+                    action: map["action"],
+                    priority: map["priority"],
+                    enabled: map["enabled"],
+                    conditions: map["conditions"],
+                    config: map["config"],
+                    limit: map["limit"],
+                    interval: map["interval"],
+                    key: map["key"],
+                    strategy: map["strategy"],
+                    max_bucket_size: map["maxBucketSize"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$createdAt": @created_at,
+                    "$updatedAt": @updated_at,
+                    "name": @name,
+                    "description": @description,
+                    "teamId": @team_id,
+                    "projectId": @project_id,
+                    "resourceType": @resource_type,
+                    "resourceId": @resource_id,
+                    "action": @action,
+                    "priority": @priority,
+                    "enabled": @enabled,
+                    "conditions": @conditions,
+                    "config": @config,
+                    "limit": @limit,
+                    "interval": @interval,
+                    "key": @key,
+                    "strategy": @strategy,
+                    "maxBucketSize": @max_bucket_size
+                }
+            end
+
+            private
+
+            def validate_action(action)
+                valid_action = [
+                    Appwrite::Enums::WafRuleAction::BYPASS,
+                    Appwrite::Enums::WafRuleAction::DENY,
+                    Appwrite::Enums::WafRuleAction::CHALLENGE,
+                    Appwrite::Enums::WafRuleAction::RATELIMIT,
+                    Appwrite::Enums::WafRuleAction::REDIRECT,
+                ]
+
+                unless valid_action.include?(action)
+                    raise ArgumentError, "Invalid " + action + ". Must be one of: " + valid_action.join(', ')
+                end
+
+                action
+            end
+        end
+    end
+end

data/lib/appwrite/models/waf_rule_redirect.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Appwrite
+    module Models
+        class WafRuleRedirect
+            attr_reader :id
+            attr_reader :created_at
+            attr_reader :updated_at
+            attr_reader :name
+            attr_reader :description
+            attr_reader :team_id
+            attr_reader :project_id
+            attr_reader :resource_type
+            attr_reader :resource_id
+            attr_reader :action
+            attr_reader :priority
+            attr_reader :enabled
+            attr_reader :conditions
+            attr_reader :config
+            attr_reader :location
+            attr_reader :status_code
+
+            def initialize(
+                id:,
+                created_at:,
+                updated_at:,
+                name:,
+                description:,
+                team_id:,
+                project_id:,
+                resource_type:,
+                resource_id:,
+                action:,
+                priority:,
+                enabled:,
+                conditions:,
+                config:,
+                location:,
+                status_code:
+            )
+                @id = id
+                @created_at = created_at
+                @updated_at = updated_at
+                @name = name
+                @description = description
+                @team_id = team_id
+                @project_id = project_id
+                @resource_type = resource_type
+                @resource_id = resource_id
+                @action = validate_action(action)
+                @priority = priority
+                @enabled = enabled
+                @conditions = conditions
+                @config = config
+                @location = location
+                @status_code = status_code
+            end
+
+            def self.from(map:)
+                map = { "$id" => "", "$createdAt" => "", "$updatedAt" => "", "name" => "", "description" => "", "teamId" => "", "projectId" => "", "resourceType" => "api", "resourceId" => "", "priority" => 0, "enabled" => true, "conditions" => [], "config" => {}, "location" => "/", "statusCode" => 302 }.merge(map)
+                WafRuleRedirect.new(
+                    id: map["$id"],
+                    created_at: map["$createdAt"],
+                    updated_at: map["$updatedAt"],
+                    name: map["name"],
+                    description: map["description"],
+                    team_id: map["teamId"],
+                    project_id: map["projectId"],
+                    resource_type: map["resourceType"],
+                    resource_id: map["resourceId"],
+                    action: map["action"],
+                    priority: map["priority"],
+                    enabled: map["enabled"],
+                    conditions: map["conditions"],
+                    config: map["config"],
+                    location: map["location"],
+                    status_code: map["statusCode"]
+                )
+            end
+
+            def to_map
+                {
+                    "$id": @id,
+                    "$createdAt": @created_at,
+                    "$updatedAt": @updated_at,
+                    "name": @name,
+                    "description": @description,
+                    "teamId": @team_id,
+                    "projectId": @project_id,
+                    "resourceType": @resource_type,
+                    "resourceId": @resource_id,
+                    "action": @action,
+                    "priority": @priority,
+                    "enabled": @enabled,
+                    "conditions": @conditions,
+                    "config": @config,
+                    "location": @location,
+                    "statusCode": @status_code
+                }
+            end
+
+            private
+
+            def validate_action(action)
+                valid_action = [
+                    Appwrite::Enums::WafRuleAction::BYPASS,
+                    Appwrite::Enums::WafRuleAction::DENY,
+                    Appwrite::Enums::WafRuleAction::CHALLENGE,
+                    Appwrite::Enums::WafRuleAction::RATELIMIT,
+                    Appwrite::Enums::WafRuleAction::REDIRECT,
+                ]
+
+                unless valid_action.include?(action)
+                    raise ArgumentError, "Invalid " + action + ". Must be one of: " + valid_action.join(', ')
+                end
+
+                action
+            end
+        end
+    end
+end

data/lib/appwrite/models/webhook.rb

@@ -48,6 +48,7 @@ module Appwrite
             end
 
             def self.from(map:)
+                map = { "$id" => "", "$createdAt" => "", "$updatedAt" => "", "name" => "", "url" => "", "events" => [], "tls" => true, "authUsername" => "", "authPassword" => "", "secret" => "", "enabled" => true, "logs" => "", "attempts" => 0 }.merge(map)
                 Webhook.new(
                     id: map["$id"],
                     created_at: map["$createdAt"],

data/lib/appwrite/models/webhook_list.rb

@@ -15,6 +15,7 @@ module Appwrite
             end
 
             def self.from(map:)
+                map = { "total" => 0, "webhooks" => [] }.merge(map)
                 WebhookList.new(
                     total: map["total"],
                     webhooks: map["webhooks"].map { |it| Webhook.from(map: it) }

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