appwrite 21.0.0 → 21.1.0

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

@@ -614,7 +614,7 @@ module Appwrite
         # 
         #
         # @param [String] database_id Database ID.
-        # @param [String] collection_id Collection ID. You can create a new table using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
+        # @param [String] collection_id Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).
         # @param [String] key Attribute Key.
         # @param [] required Is attribute required?
         # @param [] default Default value for attribute when not provided. Cannot be set when attribute is required.
@@ -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 = {
@@ -2039,6 +2043,56 @@ module Appwrite
             )
         end
 
+        #
+        # @deprecated This API has been deprecated since 1.8.0. Please use `TablesDB.updateRelationshipColumn` instead.
+        #
+        # Update relationship attribute. [Learn more about relationship
+        # attributes](https://appwrite.io/docs/databases-relationships#relationship-attributes).
+        # 
+        #
+        # @param [String] database_id Database ID.
+        # @param [String] collection_id Collection ID.
+        # @param [String] key Attribute Key.
+        # @param [RelationMutate] on_delete Constraints option
+        # @param [String] new_key New Attribute Key.
+        #
+        # @return [AttributeRelationship]
+        def update_relationship_attribute(database_id:, collection_id:, key:, on_delete: nil, new_key: nil)
+            api_path = '/databases/{databaseId}/collections/{collectionId}/attributes/relationship/{key}'
+                .gsub('{databaseId}', database_id)
+                .gsub('{collectionId}', collection_id)
+                .gsub('{key}', key)
+
+            if database_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
+            end
+
+            if collection_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
+            end
+
+            if key.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "key"')
+            end
+
+            api_params = {
+                onDelete: on_delete,
+                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::AttributeRelationship
+            )
+        end
+
         #
         # @deprecated This API has been deprecated since 1.8.0. Please use `TablesDB.createStringColumn` instead.
         #
@@ -2173,9 +2227,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 +2256,7 @@ module Appwrite
                 required: required,
                 default: default,
                 array: array,
+                encrypt: encrypt,
             }
             
             api_headers = {
@@ -2398,9 +2454,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 +2488,7 @@ module Appwrite
                 required: required,
                 default: default,
                 array: array,
+                encrypt: encrypt,
             }
             
             api_headers = {
@@ -2591,56 +2649,6 @@ module Appwrite
             )
         end
 
-        #
-        # @deprecated This API has been deprecated since 1.8.0. Please use `TablesDB.updateRelationshipColumn` instead.
-        #
-        # Update relationship attribute. [Learn more about relationship
-        # attributes](https://appwrite.io/docs/databases-relationships#relationship-attributes).
-        # 
-        #
-        # @param [String] database_id Database ID.
-        # @param [String] collection_id Collection ID.
-        # @param [String] key Attribute Key.
-        # @param [RelationMutate] on_delete Constraints option
-        # @param [String] new_key New Attribute Key.
-        #
-        # @return [AttributeRelationship]
-        def update_relationship_attribute(database_id:, collection_id:, key:, on_delete: nil, new_key: nil)
-            api_path = '/databases/{databaseId}/collections/{collectionId}/attributes/{key}/relationship'
-                .gsub('{databaseId}', database_id)
-                .gsub('{collectionId}', collection_id)
-                .gsub('{key}', key)
-
-            if database_id.nil?
-              raise Appwrite::Exception.new('Missing required parameter: "databaseId"')
-            end
-
-            if collection_id.nil?
-              raise Appwrite::Exception.new('Missing required parameter: "collectionId"')
-            end
-
-            if key.nil?
-              raise Appwrite::Exception.new('Missing required parameter: "key"')
-            end
-
-            api_params = {
-                onDelete: on_delete,
-                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::AttributeRelationship
-            )
-        end
-
         #
         # @deprecated This API has been deprecated since 1.8.0. Please use `TablesDB.listRows` instead.
         #
@@ -2652,9 +2660,10 @@ module Appwrite
         # @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.
         # @param [String] transaction_id Transaction ID to read uncommitted changes within the transaction.
         # @param [] total When set to false, the total count returned will be 0 and will not be calculated.
+        # @param [Integer] ttl TTL (seconds) for cached responses when caching is enabled for select queries. Must be between 0 and 86400 (24 hours).
         #
         # @return [DocumentList]
-        def list_documents(database_id:, collection_id:, queries: nil, transaction_id: nil, total: nil)
+        def list_documents(database_id:, collection_id:, queries: nil, transaction_id: nil, total: nil, ttl: nil)
             api_path = '/databases/{databaseId}/collections/{collectionId}/documents'
                 .gsub('{databaseId}', database_id)
                 .gsub('{collectionId}', collection_id)
@@ -2671,6 +2680,7 @@ module Appwrite
                 queries: queries,
                 transactionId: transaction_id,
                 total: total,
+                ttl: ttl,
             }
             
             api_headers = {