appwrite 21.0.0 → 21.0.1

data/lib/appwrite/query.rb

@@ -133,10 +133,28 @@ module Appwrite
                 return Query.new("offset", nil, offset).to_s
             end
 
+            # Filter resources where attribute contains the specified value.
+            # For string attributes, checks if the string contains the substring.
+            #
+            # Note: For array attributes, use contains_any or contains_all instead.
             def contains(attribute, value)
                 return Query.new("contains", attribute, value).to_s
             end
 
+            # Filter resources where attribute contains ANY of the specified values.
+            # For array and relationship attributes, matches documents where the attribute
+            # contains at least one of the given values.
+            def contains_any(attribute, value)
+                return Query.new("containsAny", attribute, value).to_s
+            end
+
+            # Filter resources where attribute contains ALL of the specified values.
+            # For array and relationship attributes, matches documents where the attribute
+            # contains every one of the given values.
+            def contains_all(attribute, value)
+                return Query.new("containsAll", attribute, value).to_s
+            end
+
             def not_contains(attribute, value)
                 return Query.new("notContains", attribute, value).to_s
             end

data/lib/appwrite/services/activities.rb

@@ -0,0 +1,64 @@
+#frozen_string_literal: true
+
+module Appwrite
+    class Activities < Service
+
+        def initialize(client)
+            @client = client
+        end
+
+        # List all events for selected filters.
+        #
+        # @param [String] 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 attributes such as userId, teamId, etc.
+        #
+        # @return [ActivityEventList]
+        def list_events(queries: nil)
+            api_path = '/activities/events'
+
+            api_params = {
+                queries: queries,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ActivityEventList
+            )
+        end
+
+        # Get event by ID.
+        # 
+        #
+        # @param [String] event_id Event ID.
+        #
+        # @return [ActivityEvent]
+        def get_event(event_id:)
+            api_path = '/activities/events/{eventId}'
+                .gsub('{eventId}', event_id)
+
+            if event_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "eventId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::ActivityEvent
+            )
+        end
+
+    end 
+end

data/lib/appwrite/services/backups.rb

@@ -0,0 +1,383 @@
+#frozen_string_literal: true
+
+module Appwrite
+    class Backups < Service
+
+        def initialize(client)
+            @client = client
+        end
+
+        # List all archives for a project.
+        #
+        # @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.
+        #
+        # @return [BackupArchiveList]
+        def list_archives(queries: nil)
+            api_path = '/backups/archives'
+
+            api_params = {
+                queries: queries,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::BackupArchiveList
+            )
+        end
+
+        # Create a new archive asynchronously for a project.
+        #
+        # @param [Array] services Array of services to backup
+        # @param [String] resource_id Resource ID. When set, only this single resource will be backed up.
+        #
+        # @return [BackupArchive]
+        def create_archive(services:, resource_id: nil)
+            api_path = '/backups/archives'
+
+            if services.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "services"')
+            end
+
+            api_params = {
+                services: services,
+                resourceId: resource_id,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::BackupArchive
+            )
+        end
+
+        # Get a backup archive using it's ID.
+        #
+        # @param [String] archive_id Archive ID. Choose a custom ID`. 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.
+        #
+        # @return [BackupArchive]
+        def get_archive(archive_id:)
+            api_path = '/backups/archives/{archiveId}'
+                .gsub('{archiveId}', archive_id)
+
+            if archive_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "archiveId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::BackupArchive
+            )
+        end
+
+        # Delete an existing archive for a project.
+        #
+        # @param [String] archive_id Policy 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.
+        #
+        # @return []
+        def delete_archive(archive_id:)
+            api_path = '/backups/archives/{archiveId}'
+                .gsub('{archiveId}', archive_id)
+
+            if archive_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "archiveId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'DELETE',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+            )
+        end
+
+        # List all policies for a project.
+        #
+        # @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.
+        #
+        # @return [BackupPolicyList]
+        def list_policies(queries: nil)
+            api_path = '/backups/policies'
+
+            api_params = {
+                queries: queries,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::BackupPolicyList
+            )
+        end
+
+        # Create a new backup policy.
+        #
+        # @param [String] policy_id Policy 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 [Array] services Array of services to backup
+        # @param [Integer] retention Days to keep backups before deletion
+        # @param [String] schedule Schedule CRON syntax.
+        # @param [String] name Policy name. Max length: 128 chars.
+        # @param [String] resource_id Resource ID. When set, only this single resource will be backed up.
+        # @param [] enabled Is policy enabled? When set to 'disabled', no backups will be taken
+        #
+        # @return [BackupPolicy]
+        def create_policy(policy_id:, services:, retention:, schedule:, name: nil, resource_id: nil, enabled: nil)
+            api_path = '/backups/policies'
+
+            if policy_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "policyId"')
+            end
+
+            if services.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "services"')
+            end
+
+            if retention.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "retention"')
+            end
+
+            if schedule.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "schedule"')
+            end
+
+            api_params = {
+                policyId: policy_id,
+                name: name,
+                services: services,
+                resourceId: resource_id,
+                enabled: enabled,
+                retention: retention,
+                schedule: schedule,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::BackupPolicy
+            )
+        end
+
+        # Get a backup policy using it's ID.
+        #
+        # @param [String] policy_id Policy ID. Choose a custom ID`. 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.
+        #
+        # @return [BackupPolicy]
+        def get_policy(policy_id:)
+            api_path = '/backups/policies/{policyId}'
+                .gsub('{policyId}', policy_id)
+
+            if policy_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "policyId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::BackupPolicy
+            )
+        end
+
+        # Update an existing policy using it's ID.
+        #
+        # @param [String] policy_id Policy ID. Choose a custom ID`. 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] name Policy name. Max length: 128 chars.
+        # @param [Integer] retention Days to keep backups before deletion
+        # @param [String] schedule Cron expression
+        # @param [] enabled Is Backup enabled? When set to 'disabled', No backup will be taken
+        #
+        # @return [BackupPolicy]
+        def update_policy(policy_id:, name: nil, retention: nil, schedule: nil, enabled: nil)
+            api_path = '/backups/policies/{policyId}'
+                .gsub('{policyId}', policy_id)
+
+            if policy_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "policyId"')
+            end
+
+            api_params = {
+                name: name,
+                retention: retention,
+                schedule: schedule,
+                enabled: enabled,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'PATCH',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::BackupPolicy
+            )
+        end
+
+        # Delete a policy using it's ID.
+        #
+        # @param [String] policy_id Policy 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.
+        #
+        # @return []
+        def delete_policy(policy_id:)
+            api_path = '/backups/policies/{policyId}'
+                .gsub('{policyId}', policy_id)
+
+            if policy_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "policyId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'DELETE',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+            )
+        end
+
+        # Create and trigger a new restoration for a backup on a project.
+        #
+        # @param [String] archive_id Backup archive ID to restore
+        # @param [Array] services Array of services to restore
+        # @param [String] new_resource_id Unique 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] new_resource_name Database name. Max length: 128 chars.
+        #
+        # @return [BackupRestoration]
+        def create_restoration(archive_id:, services:, new_resource_id: nil, new_resource_name: nil)
+            api_path = '/backups/restoration'
+
+            if archive_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "archiveId"')
+            end
+
+            if services.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "services"')
+            end
+
+            api_params = {
+                archiveId: archive_id,
+                services: services,
+                newResourceId: new_resource_id,
+                newResourceName: new_resource_name,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::BackupRestoration
+            )
+        end
+
+        # List all backup restorations for a project.
+        #
+        # @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.
+        #
+        # @return [BackupRestorationList]
+        def list_restorations(queries: nil)
+            api_path = '/backups/restorations'
+
+            api_params = {
+                queries: queries,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::BackupRestorationList
+            )
+        end
+
+        # Get the current status of a backup restoration.
+        #
+        # @param [String] restoration_id Restoration ID. Choose a custom ID`. 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.
+        #
+        # @return [BackupRestoration]
+        def get_restoration(restoration_id:)
+            api_path = '/backups/restorations/{restorationId}'
+                .gsub('{restorationId}', restoration_id)
+
+            if restoration_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "restorationId"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::BackupRestoration
+            )
+        end
+
+    end 
+end

data/lib/appwrite/services/databases.rb

@@ -1556,9 +1556,10 @@ module Appwrite
         # @param [] required Is attribute required?
         # @param [String] default Default value for attribute when not provided. Cannot be set when attribute is required.
         # @param [] array Is attribute an array?
+        # @param [] encrypt Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
         #
         # @return [AttributeLongtext]
-        def create_longtext_attribute(database_id:, collection_id:, key:, required:, default: nil, array: nil)
+        def create_longtext_attribute(database_id:, collection_id:, key:, required:, default: nil, array: nil, encrypt: nil)
             api_path = '/databases/{databaseId}/collections/{collectionId}/attributes/longtext'
                 .gsub('{databaseId}', database_id)
                 .gsub('{collectionId}', collection_id)
@@ -1584,6 +1585,7 @@ module Appwrite
                 required: required,
                 default: default,
                 array: array,
+                encrypt: encrypt,
             }
             
             api_headers = {
@@ -1665,9 +1667,10 @@ module Appwrite
         # @param [] required Is attribute required?
         # @param [String] default Default value for attribute when not provided. Cannot be set when attribute is required.
         # @param [] array Is attribute an array?
+        # @param [] encrypt Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
         #
         # @return [AttributeMediumtext]
-        def create_mediumtext_attribute(database_id:, collection_id:, key:, required:, default: nil, array: nil)
+        def create_mediumtext_attribute(database_id:, collection_id:, key:, required:, default: nil, array: nil, encrypt: nil)
             api_path = '/databases/{databaseId}/collections/{collectionId}/attributes/mediumtext'
                 .gsub('{databaseId}', database_id)
                 .gsub('{collectionId}', collection_id)
@@ -1693,6 +1696,7 @@ module Appwrite
                 required: required,
                 default: default,
                 array: array,
+                encrypt: encrypt,
             }
             
             api_headers = {
@@ -2173,9 +2177,10 @@ module Appwrite
         # @param [] required Is attribute required?
         # @param [String] default Default value for attribute when not provided. Cannot be set when attribute is required.
         # @param [] array Is attribute an array?
+        # @param [] encrypt Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
         #
         # @return [AttributeText]
-        def create_text_attribute(database_id:, collection_id:, key:, required:, default: nil, array: nil)
+        def create_text_attribute(database_id:, collection_id:, key:, required:, default: nil, array: nil, encrypt: nil)
             api_path = '/databases/{databaseId}/collections/{collectionId}/attributes/text'
                 .gsub('{databaseId}', database_id)
                 .gsub('{collectionId}', collection_id)
@@ -2201,6 +2206,7 @@ module Appwrite
                 required: required,
                 default: default,
                 array: array,
+                encrypt: encrypt,
             }
             
             api_headers = {
@@ -2398,9 +2404,10 @@ module Appwrite
         # @param [] required Is attribute required?
         # @param [String] default Default value for attribute when not provided. Cannot be set when attribute is required.
         # @param [] array Is attribute an array?
+        # @param [] encrypt Toggle encryption for the attribute. Encryption enhances security by not storing any plain text values in the database. However, encrypted attributes cannot be queried.
         #
         # @return [AttributeVarchar]
-        def create_varchar_attribute(database_id:, collection_id:, key:, size:, required:, default: nil, array: nil)
+        def create_varchar_attribute(database_id:, collection_id:, key:, size:, required:, default: nil, array: nil, encrypt: nil)
             api_path = '/databases/{databaseId}/collections/{collectionId}/attributes/varchar'
                 .gsub('{databaseId}', database_id)
                 .gsub('{collectionId}', collection_id)
@@ -2431,6 +2438,7 @@ module Appwrite
                 required: required,
                 default: default,
                 array: array,
+                encrypt: encrypt,
             }
             
             api_headers = {

data/lib/appwrite/services/health.rb

@@ -167,6 +167,54 @@ module Appwrite
             )
         end
 
+        # Get billing project aggregation queue.
+        #
+        # @param [Integer] threshold Queue size threshold. When hit (equal or higher), endpoint returns server error. Default value is 5000.
+        #
+        # @return [HealthQueue]
+        def get_queue_billing_project_aggregation(threshold: nil)
+            api_path = '/health/queue/billing-project-aggregation'
+
+            api_params = {
+                threshold: threshold,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::HealthQueue
+            )
+        end
+
+        # Get billing team aggregation queue.
+        #
+        # @param [Integer] threshold Queue size threshold. When hit (equal or higher), endpoint returns server error. Default value is 5000.
+        #
+        # @return [HealthQueue]
+        def get_queue_billing_team_aggregation(threshold: nil)
+            api_path = '/health/queue/billing-team-aggregation'
+
+            api_params = {
+                threshold: threshold,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::HealthQueue
+            )
+        end
+
         # Get the number of builds that are waiting to be processed in the Appwrite
         # internal queue server.
         #
@@ -192,6 +240,30 @@ module Appwrite
             )
         end
 
+        # Get the priority builds queue size.
+        #
+        # @param [Integer] threshold Queue size threshold. When hit (equal or higher), endpoint returns server error. Default value is 500.
+        #
+        # @return [HealthQueue]
+        def get_queue_priority_builds(threshold: nil)
+            api_path = '/health/queue/builds-priority'
+
+            api_params = {
+                threshold: threshold,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::HealthQueue
+            )
+        end
+
         # Get the number of certificates that are waiting to be issued against
         # [Letsencrypt](https://letsencrypt.org/) in the Appwrite internal queue
         # server.
@@ -426,6 +498,30 @@ module Appwrite
             )
         end
 
+        # Get region manager queue.
+        #
+        # @param [Integer] threshold Queue size threshold. When hit (equal or higher), endpoint returns server error. Default value is 100.
+        #
+        # @return [HealthQueue]
+        def get_queue_region_manager(threshold: nil)
+            api_path = '/health/queue/region-manager'
+
+            api_params = {
+                threshold: threshold,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::HealthQueue
+            )
+        end
+
         # Get the number of metrics that are waiting to be processed in the Appwrite
         # stats resources queue.
         #
@@ -476,6 +572,30 @@ module Appwrite
             )
         end
 
+        # Get threats queue.
+        #
+        # @param [Integer] threshold Queue size threshold. When hit (equal or higher), endpoint returns server error. Default value is 100.
+        #
+        # @return [HealthQueue]
+        def get_queue_threats(threshold: nil)
+            api_path = '/health/queue/threats'
+
+            api_params = {
+                threshold: threshold,
+            }
+            
+            api_headers = {
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::HealthQueue
+            )
+        end
+
         # Get the number of webhooks that are waiting to be processed in the Appwrite
         # internal queue server.
         #