appwrite 23.0.0 → 24.0.0

data/lib/appwrite/services/proxy.rb

@@ -0,0 +1,303 @@
+#frozen_string_literal: true
+
+module Appwrite
+    class Proxy < Service
+
+        def initialize(client)
+            @client = client
+        end
+
+        # Get a list of all the proxy rules. You can use the query params to filter
+        # your results.
+        #
+        # @param [Array] queries Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/databases#querying-documents). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: domain, type, trigger, deploymentResourceType, deploymentResourceId, deploymentId, deploymentVcsProviderBranch
+        # @param [] total When set to false, the total count returned will be 0 and will not be calculated.
+        #
+        # @return [ProxyRuleList]
+        def list_rules(queries: nil, total: nil)
+            api_path = '/proxy/rules'
+
+            api_params = {
+                queries: queries,
+                total: total,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ProxyRuleList
+            )
+
+        end
+
+        # Create a new proxy rule for serving Appwrite's API on custom domain.
+        # 
+        # Rule ID is automatically generated as MD5 hash of a rule domain for
+        # performance purposes.
+        #
+        # @param [String] domain Domain name.
+        #
+        # @return [ProxyRule]
+        def create_api_rule(domain:)
+            api_path = '/proxy/rules/api'
+
+            if domain.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "domain"')
+            end
+
+            api_params = {
+                domain: domain,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ProxyRule
+            )
+
+        end
+
+        # Create a new proxy rule for executing Appwrite Function on custom domain.
+        # 
+        # Rule ID is automatically generated as MD5 hash of a rule domain for
+        # performance purposes.
+        #
+        # @param [String] domain Domain name.
+        # @param [String] function_id ID of function to be executed.
+        # @param [String] branch Name of VCS branch to deploy changes automatically
+        #
+        # @return [ProxyRule]
+        def create_function_rule(domain:, function_id:, branch: nil)
+            api_path = '/proxy/rules/function'
+
+            if domain.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "domain"')
+            end
+
+            if function_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "functionId"')
+            end
+
+            api_params = {
+                domain: domain,
+                functionId: function_id,
+                branch: branch,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ProxyRule
+            )
+
+        end
+
+        # Create a new proxy rule for to redirect from custom domain to another
+        # domain.
+        # 
+        # Rule ID is automatically generated as MD5 hash of a rule domain for
+        # performance purposes.
+        #
+        # @param [String] domain Domain name.
+        # @param [String] url Target URL of redirection
+        # @param [StatusCode] status_code Status code of redirection
+        # @param [String] resource_id ID of parent resource.
+        # @param [ProxyResourceType] resource_type Type of parent resource.
+        #
+        # @return [ProxyRule]
+        def create_redirect_rule(domain:, url:, status_code:, resource_id:, resource_type:)
+            api_path = '/proxy/rules/redirect'
+
+            if domain.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "domain"')
+            end
+
+            if url.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "url"')
+            end
+
+            if status_code.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "statusCode"')
+            end
+
+            if resource_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "resourceId"')
+            end
+
+            if resource_type.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "resourceType"')
+            end
+
+            api_params = {
+                domain: domain,
+                url: url,
+                statusCode: status_code,
+                resourceId: resource_id,
+                resourceType: resource_type,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ProxyRule
+            )
+
+        end
+
+        # Create a new proxy rule for serving Appwrite Site on custom domain.
+        # 
+        # Rule ID is automatically generated as MD5 hash of a rule domain for
+        # performance purposes.
+        #
+        # @param [String] domain Domain name.
+        # @param [String] site_id ID of site to be executed.
+        # @param [String] branch Name of VCS branch to deploy changes automatically
+        #
+        # @return [ProxyRule]
+        def create_site_rule(domain:, site_id:, branch: nil)
+            api_path = '/proxy/rules/site'
+
+            if domain.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "domain"')
+            end
+
+            if site_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "siteId"')
+            end
+
+            api_params = {
+                domain: domain,
+                siteId: site_id,
+                branch: branch,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ProxyRule
+            )
+
+        end
+
+        # Get a proxy rule by its unique ID.
+        #
+        # @param [String] rule_id Rule ID.
+        #
+        # @return [ProxyRule]
+        def get_rule(rule_id:)
+            api_path = '/proxy/rules/{ruleId}'
+                .gsub('{ruleId}', rule_id)
+
+            if rule_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "ruleId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ProxyRule
+            )
+
+        end
+
+        # Delete a proxy rule by its unique ID.
+        #
+        # @param [String] rule_id Rule ID.
+        #
+        # @return []
+        def delete_rule(rule_id:)
+            api_path = '/proxy/rules/{ruleId}'
+                .gsub('{ruleId}', rule_id)
+
+            if rule_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "ruleId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'DELETE',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+            )
+
+        end
+
+        # If not succeeded yet, retry verification process of a proxy rule domain.
+        # This endpoint triggers domain verification by checking DNS records. If
+        # verification is successful, a TLS certificate will be automatically
+        # provisioned for the domain asynchronously in the background.
+        #
+        # @param [String] rule_id Rule ID.
+        #
+        # @return [ProxyRule]
+        def update_rule_status(rule_id:)
+            api_path = '/proxy/rules/{ruleId}/status'
+                .gsub('{ruleId}', rule_id)
+
+            if rule_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "ruleId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'PATCH',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ProxyRule
+            )
+
+        end
+
+    end 
+end

data/lib/appwrite/services/sites.rb

@@ -833,9 +833,11 @@ module Appwrite
         # Get a list of all variables of a specific site.
         #
         # @param [String] site_id Site unique ID.
+        # @param [Array] queries Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: key, resourceType, resourceId, secret
+        # @param [] total When set to false, the total count returned will be 0 and will not be calculated.
         #
         # @return [VariableList]
-        def list_variables(site_id:)
+        def list_variables(site_id:, queries: nil, total: nil)
             api_path = '/sites/{siteId}/variables'
                 .gsub('{siteId}', site_id)
 
@@ -844,6 +846,8 @@ module Appwrite
             end
 
             api_params = {
+                queries: queries,
+                total: total,
             }
             
             api_headers = {
@@ -863,12 +867,13 @@ module Appwrite
         # and runtime (server-side rendering) as environment variables.
         #
         # @param [String] site_id Site unique ID.
+        # @param [String] variable_id Variable ID. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
         # @param [String] key Variable key. Max length: 255 chars.
         # @param [String] value Variable value. Max length: 8192 chars.
         # @param [] secret Secret variables can be updated or deleted, but only sites can read them during build and runtime.
         #
         # @return [Variable]
-        def create_variable(site_id:, key:, value:, secret: nil)
+        def create_variable(site_id:, variable_id:, key:, value:, secret: nil)
             api_path = '/sites/{siteId}/variables'
                 .gsub('{siteId}', site_id)
 
@@ -876,6 +881,10 @@ module Appwrite
               raise Appwrite::Exception.new('Missing required parameter: "siteId"')
             end
 
+            if variable_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "variableId"')
+            end
+
             if key.nil?
               raise Appwrite::Exception.new('Missing required parameter: "key"')
             end
@@ -885,6 +894,7 @@ module Appwrite
             end
 
             api_params = {
+                variableId: variable_id,
                 key: key,
                 value: value,
                 secret: secret,
@@ -948,7 +958,7 @@ module Appwrite
         # @param [] secret Secret variables can be updated or deleted, but only sites can read them during build and runtime.
         #
         # @return [Variable]
-        def update_variable(site_id:, variable_id:, key:, value: nil, secret: nil)
+        def update_variable(site_id:, variable_id:, key: nil, value: nil, secret: nil)
             api_path = '/sites/{siteId}/variables/{variableId}'
                 .gsub('{siteId}', site_id)
                 .gsub('{variableId}', variable_id)
@@ -961,10 +971,6 @@ module Appwrite
               raise Appwrite::Exception.new('Missing required parameter: "variableId"')
             end
 
-            if key.nil?
-              raise Appwrite::Exception.new('Missing required parameter: "key"')
-            end
-
             api_params = {
                 key: key,
                 value: value,

data/lib/appwrite/services/tables_db.rb

@@ -593,6 +593,126 @@ module Appwrite
 
         end
 
+        # Create a bigint column. Optionally, minimum and maximum values can be
+        # provided.
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] table_id Table ID.
+        # @param [String] key Column Key.
+        # @param [] required Is column required?
+        # @param [Integer] min Minimum value
+        # @param [Integer] max Maximum value
+        # @param [Integer] default Default value. Cannot be set when column is required.
+        # @param [] array Is column an array?
+        #
+        # @return [ColumnBigint]
+        def create_big_int_column(database_id:, table_id:, key:, required:, min: nil, max: nil, default: nil, array: nil)
+            api_path = '/tablesdb/{databaseId}/tables/{tableId}/columns/bigint'
+                .gsub('{databaseId}', database_id)
+                .gsub('{tableId}', table_id)
+
+            if database_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if table_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "tableId"')
+            end
+
+            if key.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if required.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "required"')
+            end
+
+            api_params = {
+                key: key,
+                required: required,
+                min: min,
+                max: max,
+                default: default,
+                array: array,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ColumnBigint
+            )
+
+        end
+
+        # Update a bigint column. Changing the `default` value will not update
+        # already existing rows.
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] table_id Table ID.
+        # @param [String] key Column Key.
+        # @param [] required Is column required?
+        # @param [Integer] default Default value. Cannot be set when column is required.
+        # @param [Integer] min Minimum value
+        # @param [Integer] max Maximum value
+        # @param [String] new_key New Column Key.
+        #
+        # @return [ColumnBigint]
+        def update_big_int_column(database_id:, table_id:, key:, required:, default:, min: nil, max: nil, new_key: nil)
+            api_path = '/tablesdb/{databaseId}/tables/{tableId}/columns/bigint/{key}'
+                .gsub('{databaseId}', database_id)
+                .gsub('{tableId}', table_id)
+                .gsub('{key}', key)
+
+            if database_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if table_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "tableId"')
+            end
+
+            if key.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            if required.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "required"')
+            end
+
+            if default.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "default"')
+            end
+
+            api_params = {
+                required: required,
+                min: min,
+                max: max,
+                default: default,
+                newKey: new_key,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'PATCH',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ColumnBigint
+            )
+
+        end
+
         # Create a boolean column.
         # 
         #

data/lib/appwrite/services/usage.rb

@@ -0,0 +1,86 @@
+#frozen_string_literal: true
+
+module Appwrite
+    class Usage < Service
+
+        def initialize(client)
+            @client = client
+        end
+
+        # Query usage event metrics from the usage database. Returns individual event
+        # rows with full metadata. Pass Query objects as JSON strings to filter,
+        # paginate, and order results. Supported query methods: equal,
+        # greaterThanEqual, lessThanEqual, orderAsc, orderDesc, limit, offset.
+        # Supported filter attributes: metric, path, method, status, resource,
+        # resourceId, country, userAgent, time (these match the underlying column
+        # names — note that the response surfaces `resource` as `resourceType` and
+        # `country` as `countryCode`). When no time filter is supplied the endpoint
+        # defaults to the last 7 days. Default `limit(100)` is applied if none is
+        # given; user-supplied limits are capped at 500. The `total` field is capped
+        # at 5000 to keep counts predictable — pass `total=false` to skip the count
+        # entirely.
+        #
+        # @param [Array] queries Array of query strings as JSON. Supported: equal("metric", [...]), equal("path", [...]), equal("method", [...]), equal("status", [...]), equal("resource", [...]), equal("resourceId", [...]), equal("country", [...]), equal("userAgent", [...]), greaterThanEqual("time", "..."), lessThanEqual("time", "..."), orderAsc("time"), orderDesc("time"), limit(N), offset(N).
+        # @param [] total When set to false, the total count returned will be 0 and will not be calculated.
+        #
+        # @return [UsageEventList]
+        def list_events(queries: nil, total: nil)
+            api_path = '/usage/events'
+
+            api_params = {
+                queries: queries,
+                total: total,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::UsageEventList
+            )
+
+        end
+
+        # Query usage gauge metrics (point-in-time resource snapshots) from the usage
+        # database. Returns individual gauge snapshots with metric, value, and
+        # timestamp. Pass Query objects as JSON strings to filter, paginate, and
+        # order results. Supported query methods: equal, greaterThanEqual,
+        # lessThanEqual, orderAsc, orderDesc, limit, offset. Supported filter
+        # attributes: metric, time. Use `orderDesc("time"), limit(1)` to fetch the
+        # most recent snapshot. When no time filter is supplied the endpoint defaults
+        # to the last 7 days. Default `limit(100)` is applied if none is given;
+        # user-supplied limits are capped at 500. The `total` field is capped at 5000
+        # to keep counts predictable — pass `total=false` to skip the count
+        # entirely.
+        #
+        # @param [Array] queries Array of query strings as JSON. Supported: equal("metric", [...]), greaterThanEqual("time", "..."), lessThanEqual("time", "..."), orderAsc("time"), orderDesc("time"), limit(N), offset(N).
+        # @param [] total When set to false, the total count returned will be 0 and will not be calculated.
+        #
+        # @return [UsageGaugeList]
+        def list_gauges(queries: nil, total: nil)
+            api_path = '/usage/gauges'
+
+            api_params = {
+                queries: queries,
+                total: total,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::UsageGaugeList
+            )
+
+        end
+
+    end 
+end